作者 | CDA數據分析師 來源 | CDA數據科學研究院
map
map(function,iterable,...)
第一個參數，是函數
第二個參數，是可迭代對象（列表、字符串等）
map返回的是對
可迭代對象
裡的每個元素進行
函數
運算的結果
例如：
def fun(x): return x*3l=[0,1,2,3,4,5]l_m=map(fun,l)print(list(l_m))
原本是
[0,1,2,3,4,5]
運行map後返回的結果是
[0, 3, 6, 9, 12, 15]
相當於對
可迭代對象
裡的每個元素都進行了*3的運算，也就是我們給定
函數
運算的方式，然後返回一個值。
這裡需要注意的是 ，map()直接返回的是一個
<map at 0x205ef31fb00>
的對象
我們需要利用list函數將它裡邊的元素釋放出來。
與此同時，map函數的好朋友就是lambda，lambda匿名函數經常作為map的第一個參數進行組合使用
例如
print(list(map(lambdax:x*3,l)))
返回的結果依舊是
[0, 3, 6, 9, 12, 15]
zip
zip()將多個可迭代對象的元素組合成為為一個元組序列
l=['a','b','c']n=[1,2,3]print(list(zip(l,n)))
[('a', 1), ('b', 2), ('c', 3)]
和map類似，zip返回的也是一個zip的元組迭代器對象，我們需要使用list將它的元素釋放出來
filter
filter（function，sequence）
第一個參數是函數，第二個參數是可迭代對象
最後返回的是，可迭代對象裡滿足函數要求的元素。
因此也稱之為過濾。
long=[1,2,3,4,5]list(filter(lambdax:x%2==0,long))# 找出偶數。# filter函數返回的是迭代器，所以需要用list轉換,進行釋放元素。# 輸出：[2,4]
reduce
reduce（function，iterable）
第一個參數是函數，第二個參數是可迭代對象（列表，字符串等）
導入reduce的時候需要用到funtools這模塊
fromfunctoolsimportreducelk=[2,3,4]reduce(lambday,z:z+y,lk)# out : 9
運算的步驟是
2+3=5
5+4=9
最後返回的結果就是9
apply
DataFrame.apply(func, axis=0, broadcast=False, raw=False, reduce=None, args=(), kwds)
apply函數是pandas.DataFrame裡的方法
例如
kk是pd.DataFrame的類型的數據
000a11b22c33d44ekk["new"]=kk[0].apply(lambdax:x[-1])kk0new00aa11bb22cc33dd44ee
sort_values
參數
DataFrame.sort_values(by, axis=0, ascending=True, inplace=False, kind='quicksort', na_position='last')
參數說明
axis:{0or『index』,1or『columns』}#default 0，默認按照索引排序，即縱向排序，如果為1，則是橫向排序 by:strorlistofstr#如果axis=0，那麼by="列名"；如果axis=1，那麼by="行名"； ascending:#布爾型，True則升序，可以是[True,False]，即第一欄位升序，第二個降序 inplace:#布爾型，是否用排序後的數據框替換現有的數據框 kind:排序方法，#{『quicksort』, 『mergesort』, 『heapsort』}, default 『quicksort』。na_position:#{『first』, 『last』}, default 『last』，默認缺失值排在最後面importpandasaspdimportnumpyasnpa=np.random.randint(low=0,high=100,size=(11,2))data=pd.DataFrame(a)data.apply(lambdax:x*10)[*data.columns]=["z1",'z2']
| | z1 | z2 | | ---: | ---- | ---- | | 0 | 16 | 13 | | 1 | 57 | 0 | | 2 | 36 | 16 | | 3 | 76 | 86 | | 4 | 88 | 64 | | 5 | 12 | 24 | | 6 | 86 | 59 | | 7 | 28 | 61 | | 8 | 44 | 29 | | 9 | 56 | 91 | | 10 | 5 | 4 |
data.sort_values(by="z1",ascending=False)
| | z1 | z2 | | ---: | ---- | ---- | | 4 | 88 | 64 | | 6 | 86 | 59 | | 3 | 76 | 86 | | 1 | 57 | 0 | | 9 | 56 | 91 | | 8 | 44 | 29 | | 2 | 36 | 16 | | 7 | 28 | 61 | | 0 | 16 | 13 | | 5 | 12 | 24 | | 10 | 5 | 4 |
data.sort_values(by="z2",ascending=False)
| | z1 | z2 | | ---: | ---- | ---- | | 9 | 56 | 91 | | 3 | 76 | 86 | | 4 | 88 | 64 | | 7 | 28 | 61 | | 6 | 86 | 59 | | 8 | 44 | 29 | | 5 | 12 | 24 | | 2 | 36 | 16 | | 0 | 16 | 13 | | 10 | 5 | 4 | | 1 | 57 | 0 |
importrandomrandom.seed=1234importpandasaspdimportnumpyasnp#a=np.random.randint(low=0,high=100,size=(10,6))data=pd.DataFrame(a)data.apply(lambdax:x*10)[*data.columns]=["z1",'z2',"z3",'z4',"z5",'z6']data.sort_values(by=8,ascending=False,axis=1)
| | z3 | z4 | z1 | z2 | z5 | z6 | | ----: | - | - | - | - | - | | | 0 | 89 | 63 | 65 | 45 | 61 | 84 | | 1 | 51 | 18 | 75 | 22 | 28 | 29 | | 2 | 44 | 64 | 18 | 13 | 51 | 81 | | 3 | 18 | 29 | 17 | 47 | 4 | 53 | | 4 | 93 | 85 | 15 | 83 | 29 | 70 | | 5 | 19 | 74 | 33 | 83 | 15 | 45 | | 6 | 76 | 66 | 53 | 21 | 35 | 48 | | 7 | 58 | 46 | 31 | 40 | 93 | 55 | | 8 | 95 | 93 | 87 | 54 | 11 | 7 | | 9 | 93 | 62 | 17 | 42 | 65 | 80 |
sort
sort(key,reverse)
這個是列表的方法
key：是排序的條件
reverse：表示是否逆序，默認是從小到大，默認為False
x=['mmm','mm','mm','m']x.sort(key=len)print(x)# out： ['m', 'mm', 'mm', 'mmm']y=[3,2,8,0,1]y.sort(reverse=True)print(y)#[8, 3, 2, 1, 0]#True為逆序排列，False為正序排列
sorted
對所有可迭代對象都可以排序。
而且不會改變原有的可迭代對象的結構，而是生成一個新的數據。
#sorted(L)返回一個排序後的L，不改變原始的LL=[('b',2),('a',100),('c',30),('d',48)]sorted(L,key=lambdax:x[1])# out：# [('b', 2), ('c', 30), ('d', 48), ('a', 100)]sorted(L,key=lambdax:x[0])# out：[('a', 100), ('b', 2), ('c', 30), ('d', 48)]
Enumerate
enumerate 是一個會返回元組迭代器的內置函數，這些元組包含列表的索引和值。當你需要在循環中獲取可迭代對象的每個元素及其索引時，將經常用到該函數。
示例代碼:
letters=['a','b','c','d','e']fori,letterinenumerate(letters):print(i,letter)
返回的結果
0a1b2c3d4e
練習題
Python 中的 Zip 和 Enumerate[相關練習]
使用 zip 寫一個 for 循環，該循環會創建一個字符串，指定每個點的標籤和坐標，並將其附加到列表 points。每個字符串的格式應該為 label: x, y, z。例如，第一個坐標的字符串應該為 F: 23, 677, 4。
參考答案：
x_coord=[23,53,2,-12,95,103,14,-5]y_coord=[677,233,405,433,905,376,432,445]z_coord=[4,16,-6,-42,3,-6,23,-1]labels=["F","J","A","Q","Y","B","W","X"]points=[]# write your for loop hereforlabel,x,y,zinzip(labels,x_coord,y_coord,z_coord):points.append(label+": "+str(x)+', '+str(y)+', '+str(z))forpointinpoints:print(point)
輸出如下：
F: 23, 677, 4 J: 53, 233, 16 A: 2, 405, -6 Q: -12, 433, -42 Y: 95, 905, 3 B: 103, 376, -6 W: 14, 432, 23 X: -5, 445, -1
使用 zip 創建一個欄位 cast，該字典使用 names 作為鍵，並使用 heights 作為值。
參考答案：
cast_names=["Barney","Robin","Ted","Lily","Marshall"]cast_heights=[72,68,72,66,76]cast=dict(zip(cast_names,cast_heights))print(cast)
輸出：
{'Barney': 72, 'Ted': 72, 'Robin': 68, 'Lily': 66, 'Marshall': 76}
將 cast 元組拆封成兩個 names 和 heights 元組。
參考答案：
cast=(("Barney",72),("Robin",68),("Ted",72),("Lily",66),("Marshall",76))# define names and heights herenames,heights=zip(*cast)print(names)# ('Barney', 'Robin', 'Ted', 'Lily', 'Marshall')print(heights)# (72, 68, 72, 66, 76)
使用 zip 將 data 從 4x3 矩陣轉置成 3x4 矩陣。
參考答案：
data=((0,1,2),(3,4,5),(6,7,8),(9,10,11))data_transpose=tuple(zip(*data))print(data_transpose)# ((0, 3, 6, 9), (1, 4, 7, 10), (2, 5, 8, 11))
使用 enumerate 修改列表 cast，使每個元素都包含姓名，然後是角色的對應身高。例如，cast 的第一個元素應該從 「Barney Stinson」 更改為 "Barney Stinson 72」。
參考答案：
cast=["Barney Stinson","Robin Scherbatsky","Ted Mosby","Lily Aldrin","Marshall Eriksen"]heights=[72,68,72,66,76]fori,cinenumerate(cast):cast[i]+=' '+str(heights[i])print(cast)# ['Barney Stinson 72', 'Robin Scherb
推導式
推導式comprehensions（又稱解析式），是Python的一種獨有特性。推導式是可以從一個數據序列構建另一個新的數據序列的結構體。 共有三種推導，在Python2和3中都有支持：
列表(list)推導式字典(dict)推導式集合(set)推導式列表推導式
1、使用[]生成list
例一：
multiples=[iforiinrange(20)ifi%5is0]print(multiples)# Output:[0, 5, 10, 15]
例二：
defsd(x):returnx*xmultiples=[sd(i)foriinrange(20)ifi%5is0]print(multiples)# Output: [0, 25, 100, 225]
字典推導式
字典推導和列表推導的使用方法是類似的，只不過中括號該改成大括號。直接舉例說明：
m={'a':200,'b':56}ma={v:kfork,vinm.items()}print(ma)# Output: {200: 'a', 56: 'b'}
集合推導式
它們跟列表推導式也是類似的。 唯一的區別在於它使用大括號{}。
例一：
squared={x**2forxin[1,1,2,2]}print(squared)# Output: set([1, 4])
集合推導式有一個好處就是可以做到去重
collections模塊的Counter類
Python標準庫——collections模塊的Counter類
collections模塊包含了dict、set、list、tuple以外的一些特殊的容器類型，分別是：
OrderedDict類：排序字典，是字典的子類。namedtuple()函數：命名元組，是一個工廠函數。Counter類：為hashable對象計數，是字典的子類。deque：雙向隊列。defaultdict：使用工廠函數創建字典，使不用考慮缺失的字典鍵。
Counter類
Counter類的目的是用來跟蹤值出現的次數。它是一個無序的容器類型，以字典的鍵值對形式存儲，其中元素作為key，其計數作為value。計數值可以是任意的Interger（包括0和負數）。Counter類和其他語言的bags或multisets很相似。
創建
下面的代碼說明了Counter類創建的四種方法：
Counter類的創建
Python
c = Counter() # 創建一個空的Counter類c = Counter('gallahad') # 從一個可iterable對象（list、tuple、dict、字符串等）創建>c = Counter({'a': 4, 'b': 2}) # 從一個字典對象創建 c = Counter(a=4, b=2) # 從一組鍵值對創建
計數值的訪問與缺失的鍵
當所訪問的鍵不存在時，返回0，而不是KeyError；否則返回它的計數。
計數值的訪問
c = Counter("abcdefgab")
c["a"] 2
c["c"] 1
c["h"] 0
計數器的更新（update和subtract）
可以使用一個iterable對象或者另一個Counter對象來更新鍵值。
計數器的更新包括增加和減少兩種。其中，增加使用update()方法：
計數器的更新（update）
c = Counter('which')
c.update('witch') # 使用另一個iterable對象更新
c['h']3
d = Counter('watch')
c.update(d) # 使用另一個Counter對象更新
c['h'] 4
減少則使用subtract()方法：
計數器的更新（subtract）
Python
c = Counter('which')
c.subtract('witch') # 使用另一個iterable對象更新
c['h']1
d = Counter('watch')
c.subtract(d) # 使用另一個Counter對象更新
c['a']-1
鍵的刪除
當計數值為0時，並不意味著元素被刪除，刪除元素應當使用
del
。
鍵的刪除
Python
c = Counter("abcdcba")
c=Counter({'a': 2, 'c': 2, 'b': 2, 'd': 1})
c["b"] = 0
c=Counter({'a': 2, 'c': 2, 'd': 1, 'b': 0})
del c["a"]
c=Counter({'c': 2, 'b': 2, 'd': 1})
elements()
返回一個迭代器。元素被重複了多少次，在該迭代器中就包含多少個該元素。元素排列無確定順序，個數小於1的元素不被包含。
elements()方法
c = Counter(a=4, b=2, c=0, d=-2)
list(c.elements())['a', 'a', 'a', 'a', 'b', 'b']
most_common([n])
返回一個TopN列表。如果n沒有被指定，則返回所有元素。當多個元素計數值相同時，排列是無確定順序的。
most_common()方法
Python
c = Counter('abracadabra')
c.most_common()[('a', 5), ('r', 2), ('b', 2), ('c', 1), ('d', 1)]
c.most_common(3)[('a', 5), ('r', 2), ('b', 2)]
淺拷貝copy
淺拷貝copy
Python
c = Counter("abcdcba")
cCounter({'a': 2, 'c': 2, 'b': 2, 'd': 1})
d = c.copy()>>> dCounter({'a': 2, 'c': 2, 'b': 2, 'd': 1})
算術和集合操作
+、-、&、|操作也可以用於Counter。其中&和|操作分別返回兩個Counter對象各元素的最小值和最大值。需要注意的是，得到的Counter對象將刪除小於1的元素。
Counter對象的算術和集合操作
Python
c = Counter(a=3, b=1)
d = Counter(a=1, b=2)
c + d # c[x] + d[x]Counter({'a': 4, 'b': 3})
c - d # subtract（只保留正數計數的元素）Counter({'a': 2}
c & d # 交集: min(c[x], d[x])Counter({'a': 1, 'b': 1})
c \| d # 併集: max(c[x], d[x])Counter({'a': 3, 'b': 2})
常用操作
下面是一些Counter類的常用操作，來源於Python官方文檔
Counter類常用操作
sum(c.values()) # 所有計數的總數
c.clear() # 重置Counter對象，注意不是刪除
list(c) # 將c中的鍵轉為列表
set(c) #將c中的鍵轉為set
dict(c) # 將c中的鍵值對轉為字典
c.items() # 轉為(elem, cnt)格式的列表
Counter(dict(list_of_pairs)) # 從(elem, cnt)格式的列錶轉換為Counter類對象
c.most_common()[:-n:-1] # 取出計數最少的n-1個元素
c += Counter() # 移除0和負值