python資料處理工具 pandas包常用方法總結（持續更新）
阿新 • • 發佈：2019-01-18
========================
INTRODUCTION TO PANDAS
========================
圓括號是函式，方括號是索引
#Series data can be numpy array,or a python dict
#定義的方法：s = Series(data, index) #先指定數值再指定索引
無論選取何種方式都需要指定序列的長度，即元素的個數
s=Series(randn(5))
s = Series(randn(5), index=['a', 'b', 'c', 'd', 'e']) #索引的數量需要等於元素的數量，否則報錯
d={'a':1,'b':2,'c':3}
s=Series(data=d,index=['b', 'c', 'd', 'a'])#顯式地指定序列的索引值，輸出的資料中，列已經排序。同時在資料中沒有對應的鍵d則記為NULL
s=Series(5., index=['a', 'b', 'c', 'd', 'e'])#全部元素只有一個值
#序列元素的選取，索引始終保留
s[:3]
s[s > s.median()] #支援numpy的函式
s[s>3] #邏輯運算，取出大於3的元素
s[[1,2,4]] #由列表指定的元素
s[['a','b']] #由列表指定索引的元素
np.exp(s) #對序列元素進行計算
s*2
s+3
#當輸入一個字典生成一個序列時，顯式地指定index，若返回字典中與鍵index相對應的值，
沒有對應的鍵值對，則返回null。字典長度與index的長度可以不一致
>>>dictionary={'a':2,'b':3,'c':4,'d':6,'e':8}
>>>temp=pd.Series(dictionary,index=['a','t','c','f'])
>>>temp
a 2
t NaN
c 4
f NaN
#可以就地修改序列的索引值index，此時需要保證輸入的新的Index長度等於序列的長度，否則報錯
dictionary={'a':1,'b':2}
obj=Series(dictionary)
obj.index=['c','d'] #將索引修改為c d
#DataFrame
The result index will be the union of the indexes of the various Series.
If there are any nested dicts, these will be first converted to Series.
If no columns are passed, the columns will be the sorted list of dict keys.
#通過字典生成，鍵值對形式指定列名及資料。key=columnname,value=value
col1=Series([1., 2., 3., 4.], index=['a', 'b', 'c', 'd'])#序列
col2=Series([1., 2., 3.], index=['a', 'b', 'c'])
k={'col1':col1,'col2':col2} #由字典生成資料框。字典的鍵作為列名，對應的序列作為資料輸入，序列的索引就是資料框的行索引
DataFrame(k)
DataFrame(k, index=['d', 'b', 'a'], columns=['col1','col3']) #在建立資料框時候，允許對輸入的行和列進行篩選。在資料中沒有對應鍵的列將顯示為null
-------------------
two three
d 4 NaN
b 2 NaN
a 1 NaN
---------------------
為某列進行賦值操作
>>>frm2
State year debt
1 Texas 2001 5
2 Oregon 2002 5
3 Utah 2003 5
4 California 2004 5
5 Ohio 2005 5
>>>debtval=Series([3.6,2.4,3.3],index=[1,3,5]) #debt列的值由一個序列指定，包含索引
>>>frm2['debt']=debtval#未能通過索引匹配的，沒有值，返回NA
>>>frm2
State year debt
1 Texas 2001 3.6
2 Oregon 2002 NaN
3 Utah 2003 2.4
4 California 2004 NaN
5 Ohio 2005 3.3
為不存在的列賦值，則建立一個列
刪除列：
del frm2['debt'] # del frm.debt 將會報錯
d = {'one' : [1., 2., 3., 4.],'two' : [4., 3., 2., 1.]} #由列表指定各列的數值
DataFrame(d)
DataFrame(d,index=['a','b','c','d']) 此時需要保證顯式指定的Index長度等於序列的長度，否則報錯
DataFrame(data, columns=['C', 'A', 'B'])
#通過多個字典組成的列表生成
data2 = [{'a': 1, 'b': 2}, {'a': 5, 'b': 10, 'c': 20}]
DataFrame(data2, index=['first', 'second'])
-------------------
a b c
first 1 2 NaN
second 5 10 20
-------------------
#通過巢狀的字典定義
>>> dictionary={'Texas':{'year':2011,'debt':200},'Oregon':{'year':2011,'debt':300}}
>>> frm3=DataFrame(dictionary)
>>> frm3
Oregon Texas
debt 300 200
year 2011 2011
>>> frm3.T
debt year
Oregon 300 2011
Texas 200 2011
此時也可以顯式地指定索引：
>>> frm3=DataFrame(dictionary,index=['year','debt','pop'])
>>> frm3
Oregon Texas
year 2011 2011
debt 300 200
pop NaN NaN
#從資料記錄直接指定。資料記錄的形式可以是元組tuple或者ndarray
DataFrame.from_records
data=array([(1, 2.0, 'Hello'), (2, 3.0, 'World')])
DataFrame.from_records(data,columns=['c','b','a'])
-----------------------
c b a
0 1 2.0 Hello
1 2 3.0 World
-----------------------
DataFrame.from_items
DataFrame.from_items([('A', [1, 2, 3]), ('B', [4, 5, 6])]) #生成A B為列名的兩列。orient='columns'
DataFrame.from_items([('A', [1, 2, 3]), ('B', [4, 5, 6])],orient='index', columns=['one', 'two', 'three']) #以A B為索引，通過columns指定列名，不指定將報錯
#對列進行操作：匯出、新增、刪除
df['three'] = df['one'] * df['two']
df['flag'] = df['one'] > 2
del df['two'] #通過del刪除
three = df.pop('three')#通過pop刪除
df['foo'] = 'bar' #一列取相同的值'bar‘
df['one_trunc'] = df['one'][:2] #取出one列的前兩個值插入到新列one_trunc
#使用assign將會建立一個新的copy，原有資料框不會發生改變
iris.assign(sepal_ratio = iris['SepalWidth'] / iris['SepalLength'])#sepal_ratio通過SepalWidth/SepalLength計算而來
iris.assign(sepal_ratio = lambda x: (x['SepalWidth'] /x['SepalLength'])
EX:
iris.query('SepalLength > 5').assign(SepalRatio = lambda x: x.SepalWidth / x.SepalLength,PetalRatio = lambda x: x.PetalWidth / x.PetalLength)
#先取出SepalLength > 5的行，並且計算兩個新列
NOTES：
# 無法完成，缺少對C的引用
df.assign(C = lambda x: x['A'] + x['B'],
D = lambda x: x['A'] + x['C'])
# 可以完成，先生成C再生成D
(df.assign(C = lambda x: x['A'] + x['B'])
.assign(D = lambda x: x['A'] + x['C']))
#資料框的連線和追加操作
>>>df_l=pd.DataFrame({'key':['a','a','b','b','c','d','d'],'value1':[1,2,3,4,6,7,9]})
>>>df_r=pd.DataFrame({'key':['a','a','b','c','e'],'value1':[9,12,3,8,5]})
>>> pd.merge(df_l,df_r,how='inner',on='key')
指定連線方式為內連線；
連線鍵為列‘key’,不顯式指定此引數，將使用兩個資料框中名稱相同的列作為鍵；
返回的資料，僅包含左右資料中鍵的交集（即左右資料都存在的鍵）a b c
左集a對應多個數值，返回的資料集中全部包含
key value1_x value1_y
0 a 1 9
1 a 1 12
2 a 2 9
3 a 2 12
4 b 3 3
5 b 4 3
6 c 6 8
>>>pd.merge(df_l,df_r,how='left',on='key')
指定連線方式為左連線；
連線鍵為列‘key’,不顯式指定此引數，將使用兩個資料框中名稱相同的列作為鍵；
返回的資料，僅包含左資料中鍵 a b c d，右集d沒有對應故返回NA
左集a對應2個值，右集a對應2個值，所以返回的資料集中，a有4條記錄（2*2）
key value1_x value1_y
0 a 1 9
1 a 1 12
2 a 2 9
3 a 2 12
4 b 3 3
5 b 4 3
6 c 6 8
7 d 7 NaN
8 d 9 NaN
指定多個連線鍵，使用列表指定引數on
>>> left=pd.DataFrame({'key1':[1,2,3],'key2':['a','b','c'],'val':[23,33,46]})
>>> right=pd.DataFrame({'key1':[1,2,2,3,4],'key2':['a','b','c','c','b'],'val':[22,46,89,29,88]})
>>> left
key1 key2 val
0 1 a 23
1 2 b 33
2 3 c 46
>>> right
key1 key2 val
0 1 a 22
1 2 b 46
2 2 c 89
3 3 c 29
4 4 b 88
>>> pd.merge(left,right,on=['key1','key2'],how='inner')
key1 key2 val_x val_y
0 1 a 23 22
1 2 b 33 46
2 3 c 46 29
>>> pd.merge(left,right,on=['key1','key2'],how='right')
key1 key2 val_x val_y
0 1 a 23 22
1 2 b 33 46
2 3 c 46 29
3 2 c NaN 89
4 4 b NaN 88
資料聚合運算（GROUP BY）
-------------------------------------------------------------------------------------
在傳統SQL語法中，在進行聚合操作時，欄位必須位於GROUP BY字句後或聚合函式內：
假設有如下邏輯的SQL語句：
select col1,col2,sum(data1),mean(data2) from df group by col1,col2
-------------------------------------------------------------------------------------
>>> df=pd.DataFrame({'col1':['a','a','b','b','a'],'col2':['one','two','one','one','two'],'data1':np.random.randn(5),'data2':np.random.randn(5)})
>>> df
col1 col2 data1 data2
0 a one 0.205309 -0.756663
1 a two 0.870956 0.756917
2 b one -0.026293 0.513525
3 b one 1.287029 -2.122978
4 a two 0.960200 1.937160
按col1和col2列進行聚合：
>>>grouped=df.groupby(['col1','col2']) #對col1和col2進行去重操作，得到唯一值
>>>grouped['data1','data2'].mean() #應用聚合函式，求data1和data2的平均值
data1 data2
col1 col2
a one 0.205309 -0.756663
two 0.915578 1.347038
b one 0.630368 -0.804727
>>>grouped=df.groupby(['col1','col2'])['data1'] #直接groupby之後指定要進行聚合計算的欄位
>>>grouped.mean() #指定聚合函式
>>>grouped.data1.mean() #另一種寫法
>>>grouped.size() #返回每個分組的計數，相當於count()聚合函式
col1 col2
a one 1
two 2
b one 2
還能通過某個列的函式值進行分組：
假設有資料
>>>df2=pd.DataFrame(np.random.randn(5),columns=['col1'],index=['a','bb','ccc','aa','c'])
col1
a 1.476153
bb -0.105215
ccc 1.749460
aa -1.359892
c -0.958026
>>>grouped=df2.groupby(len) #根據df2索引值的長度來進行分組
>>> grouped.mean()
col1
1 0.259064
2 -0.732554
3 1.749460
自定義聚合函式
def peak_2_peak(arr):
return arr.max()-arr.min()
grouped.agg(peak_2_peak)
聚合函式以字串形式傳入，針對不同列應用不同聚合函式
grouped.agg('mean')
grouped.agg(['mean','sum','std']) #不同的函式以列表形式傳入
grouped=df.groupby(['col1','col2'])
grouped.agg([('data1','mean'),('data2','std')]) #針對不同列應用不同的函式，欄位和函式名以元組方式傳入，不同欄位-函式的元組組成列表傳入agg
將分組結果變成DF的其中一列
INTRODUCTION TO PANDAS
========================
圓括號是函式，方括號是索引
#Series data can be numpy array,or a python dict
#定義的方法：s = Series(data, index) #先指定數值再指定索引
無論選取何種方式都需要指定序列的長度，即元素的個數
s=Series(randn(5))
s = Series(randn(5), index=['a', 'b', 'c', 'd', 'e']) #索引的數量需要等於元素的數量，否則報錯
d={'a':1,'b':2,'c':3}
s=Series(data=d,index=['b', 'c', 'd', 'a'])#顯式地指定序列的索引值，輸出的資料中，列已經排序。同時在資料中沒有對應的鍵d則記為NULL
s=Series(5., index=['a', 'b', 'c', 'd', 'e'])#全部元素只有一個值
#序列元素的選取，索引始終保留
s[:3]
s[s > s.median()] #支援numpy的函式
s[s>3] #邏輯運算，取出大於3的元素
s[[1,2,4]] #由列表指定的元素
s[['a','b']] #由列表指定索引的元素
np.exp(s) #對序列元素進行計算
s*2
s+3
#當輸入一個字典生成一個序列時，顯式地指定index，若返回字典中與鍵index相對應的值，
沒有對應的鍵值對，則返回null。字典長度與index的長度可以不一致
>>>dictionary={'a':2,'b':3,'c':4,'d':6,'e':8}
>>>temp=pd.Series(dictionary,index=['a','t','c','f'])
>>>temp
a 2
t NaN
c 4
f NaN
#可以就地修改序列的索引值index，此時需要保證輸入的新的Index長度等於序列的長度，否則報錯
dictionary={'a':1,'b':2}
obj=Series(dictionary)
obj.index=['c','d'] #將索引修改為c d
#DataFrame
The result index will be the union of the indexes of the various Series.
If there are any nested dicts, these will be first converted to Series.
If no columns are passed, the columns will be the sorted list of dict keys.
#通過字典生成，鍵值對形式指定列名及資料。key=columnname,value=value
col1=Series([1., 2., 3., 4.], index=['a', 'b', 'c', 'd'])#序列
col2=Series([1., 2., 3.], index=['a', 'b', 'c'])
k={'col1':col1,'col2':col2} #由字典生成資料框。字典的鍵作為列名，對應的序列作為資料輸入，序列的索引就是資料框的行索引
DataFrame(k)
DataFrame(k, index=['d', 'b', 'a'], columns=['col1','col3']) #在建立資料框時候，允許對輸入的行和列進行篩選。在資料中沒有對應鍵的列將顯示為null
-------------------
two three
d 4 NaN
b 2 NaN
a 1 NaN
---------------------
為某列進行賦值操作
>>>frm2
State year debt
1 Texas 2001 5
2 Oregon 2002 5
3 Utah 2003 5
4 California 2004 5
5 Ohio 2005 5
>>>debtval=Series([3.6,2.4,3.3],index=[1,3,5]) #debt列的值由一個序列指定，包含索引
>>>frm2['debt']=debtval#未能通過索引匹配的，沒有值，返回NA
>>>frm2
State year debt
1 Texas 2001 3.6
2 Oregon 2002 NaN
3 Utah 2003 2.4
4 California 2004 NaN
5 Ohio 2005 3.3
為不存在的列賦值，則建立一個列
刪除列：
del frm2['debt'] # del frm.debt 將會報錯
d = {'one' : [1., 2., 3., 4.],'two' : [4., 3., 2., 1.]} #由列表指定各列的數值
DataFrame(d)
DataFrame(d,index=['a','b','c','d']) 此時需要保證顯式指定的Index長度等於序列的長度，否則報錯
DataFrame(data, columns=['C', 'A', 'B'])
#通過多個字典組成的列表生成
data2 = [{'a': 1, 'b': 2}, {'a': 5, 'b': 10, 'c': 20}]
DataFrame(data2, index=['first', 'second'])
-------------------
a b c
first 1 2 NaN
second 5 10 20
-------------------
#通過巢狀的字典定義
>>> dictionary={'Texas':{'year':2011,'debt':200},'Oregon':{'year':2011,'debt':300}}
>>> frm3=DataFrame(dictionary)
>>> frm3
Oregon Texas
debt 300 200
year 2011 2011
>>> frm3.T
debt year
Oregon 300 2011
Texas 200 2011
此時也可以顯式地指定索引：
>>> frm3=DataFrame(dictionary,index=['year','debt','pop'])
>>> frm3
Oregon Texas
year 2011 2011
debt 300 200
pop NaN NaN
#從資料記錄直接指定。資料記錄的形式可以是元組tuple或者ndarray
DataFrame.from_records
data=array([(1, 2.0, 'Hello'), (2, 3.0, 'World')])
DataFrame.from_records(data,columns=['c','b','a'])
-----------------------
c b a
0 1 2.0 Hello
1 2 3.0 World
-----------------------
DataFrame.from_items
DataFrame.from_items([('A', [1, 2, 3]), ('B', [4, 5, 6])]) #生成A B為列名的兩列。orient='columns'
DataFrame.from_items([('A', [1, 2, 3]), ('B', [4, 5, 6])],orient='index', columns=['one', 'two', 'three']) #以A B為索引，通過columns指定列名，不指定將報錯
#對列進行操作：匯出、新增、刪除
df['three'] = df['one'] * df['two']
df['flag'] = df['one'] > 2
del df['two'] #通過del刪除
three = df.pop('three')#通過pop刪除
df['foo'] = 'bar' #一列取相同的值'bar‘
df['one_trunc'] = df['one'][:2] #取出one列的前兩個值插入到新列one_trunc
#使用assign將會建立一個新的copy，原有資料框不會發生改變
iris.assign(sepal_ratio = iris['SepalWidth'] / iris['SepalLength'])#sepal_ratio通過SepalWidth/SepalLength計算而來
iris.assign(sepal_ratio = lambda x: (x['SepalWidth'] /x['SepalLength'])
EX:
iris.query('SepalLength > 5').assign(SepalRatio = lambda x: x.SepalWidth / x.SepalLength,PetalRatio = lambda x: x.PetalWidth / x.PetalLength)
#先取出SepalLength > 5的行，並且計算兩個新列
NOTES：
# 無法完成，缺少對C的引用
df.assign(C = lambda x: x['A'] + x['B'],
D = lambda x: x['A'] + x['C'])
# 可以完成，先生成C再生成D
(df.assign(C = lambda x: x['A'] + x['B'])
.assign(D = lambda x: x['A'] + x['C']))
#資料框的連線和追加操作
>>>df_l=pd.DataFrame({'key':['a','a','b','b','c','d','d'],'value1':[1,2,3,4,6,7,9]})
>>>df_r=pd.DataFrame({'key':['a','a','b','c','e'],'value1':[9,12,3,8,5]})
>>> pd.merge(df_l,df_r,how='inner',on='key')
指定連線方式為內連線；
連線鍵為列‘key’,不顯式指定此引數，將使用兩個資料框中名稱相同的列作為鍵；
返回的資料，僅包含左右資料中鍵的交集（即左右資料都存在的鍵）a b c
左集a對應多個數值，返回的資料集中全部包含
key value1_x value1_y
0 a 1 9
1 a 1 12
2 a 2 9
3 a 2 12
4 b 3 3
5 b 4 3
6 c 6 8
>>>pd.merge(df_l,df_r,how='left',on='key')
指定連線方式為左連線；
連線鍵為列‘key’,不顯式指定此引數，將使用兩個資料框中名稱相同的列作為鍵；
返回的資料，僅包含左資料中鍵 a b c d，右集d沒有對應故返回NA
左集a對應2個值，右集a對應2個值，所以返回的資料集中，a有4條記錄（2*2）
key value1_x value1_y
0 a 1 9
1 a 1 12
2 a 2 9
3 a 2 12
4 b 3 3
5 b 4 3
6 c 6 8
7 d 7 NaN
8 d 9 NaN
指定多個連線鍵，使用列表指定引數on
>>> left=pd.DataFrame({'key1':[1,2,3],'key2':['a','b','c'],'val':[23,33,46]})
>>> right=pd.DataFrame({'key1':[1,2,2,3,4],'key2':['a','b','c','c','b'],'val':[22,46,89,29,88]})
>>> left
key1 key2 val
0 1 a 23
1 2 b 33
2 3 c 46
>>> right
key1 key2 val
0 1 a 22
1 2 b 46
2 2 c 89
3 3 c 29
4 4 b 88
>>> pd.merge(left,right,on=['key1','key2'],how='inner')
key1 key2 val_x val_y
0 1 a 23 22
1 2 b 33 46
2 3 c 46 29
>>> pd.merge(left,right,on=['key1','key2'],how='right')
key1 key2 val_x val_y
0 1 a 23 22
1 2 b 33 46
2 3 c 46 29
3 2 c NaN 89
4 4 b NaN 88
資料聚合運算（GROUP BY）
-------------------------------------------------------------------------------------
在傳統SQL語法中，在進行聚合操作時，欄位必須位於GROUP BY字句後或聚合函式內：
假設有如下邏輯的SQL語句：
select col1,col2,sum(data1),mean(data2) from df group by col1,col2
-------------------------------------------------------------------------------------
>>> df=pd.DataFrame({'col1':['a','a','b','b','a'],'col2':['one','two','one','one','two'],'data1':np.random.randn(5),'data2':np.random.randn(5)})
>>> df
col1 col2 data1 data2
0 a one 0.205309 -0.756663
1 a two 0.870956 0.756917
2 b one -0.026293 0.513525
3 b one 1.287029 -2.122978
4 a two 0.960200 1.937160
按col1和col2列進行聚合：
>>>grouped=df.groupby(['col1','col2']) #對col1和col2進行去重操作，得到唯一值
>>>grouped['data1','data2'].mean() #應用聚合函式，求data1和data2的平均值
data1 data2
col1 col2
a one 0.205309 -0.756663
two 0.915578 1.347038
b one 0.630368 -0.804727
>>>grouped=df.groupby(['col1','col2'])['data1'] #直接groupby之後指定要進行聚合計算的欄位
>>>grouped.mean() #指定聚合函式
>>>grouped.data1.mean() #另一種寫法
>>>grouped.size() #返回每個分組的計數，相當於count()聚合函式
col1 col2
a one 1
two 2
b one 2
還能通過某個列的函式值進行分組：
假設有資料
>>>df2=pd.DataFrame(np.random.randn(5),columns=['col1'],index=['a','bb','ccc','aa','c'])
col1
a 1.476153
bb -0.105215
ccc 1.749460
aa -1.359892
c -0.958026
>>>grouped=df2.groupby(len) #根據df2索引值的長度來進行分組
>>> grouped.mean()
col1
1 0.259064
2 -0.732554
3 1.749460
自定義聚合函式
def peak_2_peak(arr):
return arr.max()-arr.min()
grouped.agg(peak_2_peak)
聚合函式以字串形式傳入，針對不同列應用不同聚合函式
grouped.agg('mean')
grouped.agg(['mean','sum','std']) #不同的函式以列表形式傳入
grouped=df.groupby(['col1','col2'])
grouped.agg([('data1','mean'),('data2','std')]) #針對不同列應用不同的函式，欄位和函式名以元組方式傳入，不同欄位-函式的元組組成列表傳入agg
將分組結果變成DF的其中一列