一.合並數據集
pandas對象中的數據可以通過一些內置的方式進行合並:
1)pandas.merge可根據一個或多個鍵將不同DataFrame中的行連接起來。SQL或其他關系型數據庫的用戶對此應該會比較熟悉，因為它實現的就是數據庫的連接操作。
2)pandas.concat可以沿着一條軸將多個對象堆疊到一起。
3)實例方法combine_first可以將重復數據編接在一起，用一個對象中的值填充另一個對象中的缺失值。
下面分別對它們進行講解，並給出一些例子。
1.數據庫風格的DataFrame合並
數據集的合並(merge)或連接(join)運算是通過一個或多個鍵將行鏈接起來的。這些運算時關系型數據庫的核心。pandas的merge函數是對數據應用這些算法的主要切入點。
下面一個簡單的例子開始:
In [1]: from pandas import DataFrame
In [2]: import pandas as pd
In [3]: df1=DataFrame({'key':['b','b','a','c','a','a','b'],'data1':range(7)})
In [4]: df2=DataFrame({'key':['a','b','d'],'data2':range(3)})
In [5]: df1
Out[5]:
key data1
0 b 0
1 b 1
2 a 2
3 c 3
4 a 4
5 a 5
6 b 6
In [6]: df2
Out[6]:
key data2
0 a 0
1 b 1
2 d 2
這是一種多對一的合並。df1中的數據有多個被標記為a和b的行，而df2中key列的每個值則僅對應一行。對這些對象調用merge即可得到:
In [7]: pd.merge(df1,df2)
Out[7]:
key data1 data2
0 b 0 1
1 b 1 1
2 b 6 1
3 a 2 0
4 a 4 0
5 a 5 0
注意，這里並沒有指明要用哪個列進行連接。如果沒有指定，merge就會將重疊列的列名當做鍵。不過，最好顯式指定一下:
In [8]: pd.merge(df1,df2,on='key')
Out[8]:
key data1 data2
0 b 0 1
1 b 1 1
2 b 6 1
3 a 2 0
4 a 4 0
5 a 5 0
如果兩個對象的列名不同，也可以分別進行指定:
In [9]: df3=DataFrame({'lkey':['b','b','a','c','a','a','b'],'data1':range(7)})
In [10]: df4=DataFrame({'rkey':['a','b','d'],'data2':range(3)})
In [11]: pd.merge(df3,df4,left_on='lkey',right_on='rkey')
Out[11]:
lkey data1 rkey data2
0 b 0 b 1
1 b 1 b 1
2 b 6 b 1
3 a 2 a 0
4 a 4 a 0
5 a 5 a 0
可以看到，結果里面c和d以及與之相關的數據消失了。默認情況下，merge做的是"inner"連接；結果中的鍵是交集。其他方式還有"left"、“right”以及"outer"。外連接求取的是鍵的並集，組合了左連接和右連接的效果:
In [14]: pd.merge(df1,df2,how='outer')
Out[14]:
key data1 data2
0 b 0.0 1.0
1 b 1.0 1.0
2 b 6.0 1.0
3 a 2.0 0.0
4 a 4.0 0.0
5 a 5.0 0.0
6 c 3.0 NaN
7 d NaN 2.0
多對多的合並操作非常簡單，無需額外的工作。如下所示:
In [15]: df1=DataFrame({'key':['b','b','a','c','a','b'],'data1':range(6)})
In [16]: df2=DataFrame({'key':['a','b','a','b','d'],'data2':range(5)})
In [17]: df1
Out[17]:
key data1
0 b 0
1 b 1
2 a 2
3 c 3
4 a 4
5 b 5
In [18]: df2
Out[18]:
key data2
0 a 0
1 b 1
2 a 2
3 b 3
4 d 4
In [19]: pd.merge(df1,df2,on='key',how='left')
Out[19]:
key data1 data2
0 b 0 1.0
1 b 0 3.0
2 b 1 1.0
3 b 1 3.0
4 a 2 0.0
5 a 2 2.0
6 c 3 NaN
7 a 4 0.0
8 a 4 2.0
9 b 5 1.0
10 b 5 3.0
多對多連接產生的是行的笛卡爾積。由於左邊的DataFrame有3個"b"行，右邊的有2個，所以最終結果中就有6個"b"行。連接方式只影響出現在結果中的鍵:
In [20]: pd.merge(df1,df2,how='inner')
Out[20]:
key data1 data2
0 b 0 1
1 b 0 3
2 b 1 1
3 b 1 3
4 b 5 1
5 b 5 3
6 a 2 0
7 a 2 2
8 a 4 0
9 a 4 2
要根據多個鍵進行合並，傳入一個由列名組成的列表即可:
In [21]: left=DataFrame({'key1':['calvin','calvin','kobe'],'key2':['one','two',
...: 'one'],'lval':[1,2,3]})
In [22]: right=DataFrame({'key1':['calvin','calvin','kobe','kobe'],'key2':['one
...: ','one','one','two'],'rval':[4,5,6,7]})
In [23]: pd.merge(left,right,on=['key1','key2'],how='outer')
Out[23]:
key1 key2 lval rval
0 calvin one 1.0 4.0
1 calvin one 1.0 5.0
2 calvin two 2.0 NaN
3 kobe one 3.0 6.0
4 kobe two NaN 7.0
結果中會出現哪些鍵組合取決於所選的合並方式，我們可以這樣來理解：多個鍵形成一系列元組，並將其當做單個連接鍵（當然，實際上並不是這么回事）。
注意：在進行列-列連接時，DataFrame對象中的索引會被丟棄。
對於合並運算需要考慮的最后一個問題是對重復列名的處理。雖然我們可以手工處理列名重疊的問題，但merge有一個更實用的suffixes選項，用於指定附加到左右兩個DataFrame對象的重疊列名上的字符串：
In [8]: pd.merge(left,right,on='key1')
Out[8]:
key1 key2_x lval key2_y rval
0 calvin one 1 one 4
1 calvin one 1 one 5
2 calvin two 2 one 4
3 calvin two 2 one 5
4 kobe one 3 one 6
5 kobe one 3 two 7
In [9]: pd.merge(left,right,on='key1',suffixes=('_left','_right'))
Out[9]:
key1 key2_left lval key2_right rval
0 calvin one 1 one 4
1 calvin one 1 one 5
2 calvin two 2 one 4
3 calvin two 2 one 5
4 kobe one 3 one 6
5 kobe one 3 two 7
merge的參數見下表，索引的連接將在下一節中講解
merge函數的參數
參數 說明
left 參與合並的左側DataFrame
right 參與合並的右側DataFrame
how "inner”、“outer”、“left”、“right”其中之一。默認為“inner”
on 用於連接的列名。必須存在於左右兩個DataFrame對象中。如果未指定，且其他連接鍵也未指定，則以left和right列名的交集作為連接鍵
left_on 左側DataFrame中用作連接鍵的列
right_on 右側DataFrame中用作連接鍵的列
left_index 將左側的行索引用作其連接鍵
right_index 類似於left_index
sort 根據連接鍵對合並后的數據進行排序，默認為True。有時處理大數據集時，禁用該選項可獲得更好的性能
suffixes 字符串值元組，用於追加到重疊列名的末尾，默認為('_x','_y')。例如，如果左右兩個DataFrame對象都有"data",則結果中就會出現“data_x”和“data_y”
copy 設置為False,可以在某些特殊情況下避免將數據復制到結果數據結構中。默認為復制
2.索引上的合並
有時候，DataFrame中的連接鍵位於其索引中。在這種情況下，我們可以傳入left_index=True或right_index=True(或兩個都傳）以說明索引應該被用作連接鍵：
In [10]: left1=DataFrame({'key':['a','b','a','a','b','c'],'value':range(6)})
In [11]: right1=DataFrame({'group_val':[3.5,7]},index=['a','b'])
In [12]: left1
Out[12]:
key value
0 a 0
1 b 1
2 a 2
3 a 3
4 b 4
5 c 5
In [13]: right1
Out[13]:
group_val
a 3.5
b 7.0
In [14]: pd.merge(left1,right1,left_on='key',right_index=True)
Out[14]:
key value group_val
0 a 0 3.5
2 a 2 3.5
3 a 3 3.5
1 b 1 7.0
4 b 4 7.0
由於默認的merge方法是求取連接鍵的交集，因此我們可以通過外鏈接的方式得到它們的並集：
In [15]: pd.merge(left1,right1,left_on='key',right_index=True,how='outer')
Out[15]:
key value group_val
0 a 0 3.5
2 a 2 3.5
3 a 3 3.5
1 b 1 7.0
4 b 4 7.0
5 c 5 NaN
對於層次化索引的數據，事情就有點復雜了：
In [18]: import numpy as np
In [19]: lefth=DataFrame({'key1':['Kobe','Kobe','Kobe','Calvin','Calvin'],'key2
...: ':[2008,2009,2010,2009,2010],'data':np.arange(5)})
In [20]: righth=DataFrame(np.arange(12).reshape((6,2)),index=[['Calvin','Calvin
...: ','Kobe','Kobe','Kobe','Kobe'],[2009,2008,2008,2008,2009,2010]],column
...: s=['event1','event2'])
In [21]: lefth
Out[21]:
key1 key2 data
0 Kobe 2008 0
1 Kobe 2009 1
2 Kobe 2010 2
3 Calvin 2009 3
4 Calvin 2010 4
In [22]: righth
Out[22]:
event1 event2
Calvin 2009 0 1
2008 2 3
Kobe 2008 4 5
2008 6 7
2009 8 9
2010 10 11
這種情況下，我們必須以列表的形式指明用作合並鍵的多個列（注意對重復索引值的處理）：
In [23]: pd.merge(lefth,righth,left_on=['key1','key2'],right_index=True)
Out[23]:
key1 key2 data event1 event2
0 Kobe 2008 0 4 5
0 Kobe 2008 0 6 7
1 Kobe 2009 1 8 9
2 Kobe 2010 2 10 11
3 Calvin 2009 3 0 1
In [24]: pd.merge(lefth,righth,left_on=['key1','key2'],right_index=True,how='ou
...: ter')
Out[24]:
key1 key2 data event1 event2
0 Kobe 2008 0.0 4.0 5.0
0 Kobe 2008 0.0 6.0 7.0
1 Kobe 2009 1.0 8.0 9.0
2 Kobe 2010 2.0 10.0 11.0
3 Calvin 2009 3.0 0.0 1.0
4 Calvin 2010 4.0 NaN NaN
4 Calvin 2008 NaN 2.0 3.0
同時使用合並雙方的索引也沒問題：
In [27]: left2=DataFrame([[1,2],[3,4],[5,6]],index=['a','c','e'],columns=['Ohio
...: ','Nevada'])
In [28]: right2=DataFrame([[7,8],[9,10],[11,12],[13,14]],index=['b','c','d','e'
...: ],columns=['Los Angle','Miami'])
In [29]: left2
Out[29]:
Ohio Nevada
a 1 2
c 3 4
e 5 6
In [30]: right2
Out[30]:
Los Angle Miami
b 7 8
c 9 10
d 11 12
e 13 14
In [31]: pd.merge(left2,right2,how='outer',left_index=True,right_index=True)
Out[31]:
Ohio Nevada Los Angle Miami
a 1.0 2.0 NaN NaN
b NaN NaN 7.0 8.0
c 3.0 4.0 9.0 10.0
d NaN NaN 11.0 12.0
e 5.0 6.0 13.0 14.0
DataFrame還有一個join實例方法，它能更方便地實現按索引合並。它還可用於合並多個帶有相同或相似索引的DataFrame對象，而不管它們之間有沒有重疊的列。在上面的那個例子中，我們可以編寫：
In [33]: left2.join(right2,how='outer')
Out[33]:
Ohio Nevada Los Angle Miami
a 1.0 2.0 NaN NaN
b NaN NaN 7.0 8.0
c 3.0 4.0 9.0 10.0
d NaN NaN 11.0 12.0
e 5.0 6.0 13.0 14.0
由於一些歷史原因（早期版本的pandas），DataFrame的join方法是在連接鍵上做左連接。它還支持參數DataFrame的索引跟調用者DataFrame的某個列之間的連接：
In [34]: left1.join(right1,on='key')
Out[34]:
key value group_val
0 a 0 3.5
1 b 1 7.0
2 a 2 3.5
3 a 3 3.5
4 b 4 7.0
5 c 5 NaN
最后，對於簡單的索引合並，我們還可以向join傳入一組DataFrame（后面介紹更為通用的concat函數，它也能實現此功能）：
In [41]: left2.join([right2,another],how='outer')
d:\python3.6\lib\site-packages\pandas\core\frame.py:6369: FutureWarning: Sorting
because non-concatenation axis is not aligned. A future version
of pandas will change to not sort by default.
To accept the future behavior, pass 'sort=False'.
To retain the current behavior and silence the warning, pass 'sort=True'.
verify_integrity=True)
Out[41]:
Ohio Nevada Los Angle Miami NY LA
a 1.0 2.0 NaN NaN 7.0 8.0
b NaN NaN 7.0 8.0 NaN NaN
c 3.0 4.0 9.0 10.0 9.0 10.0
d NaN NaN 11.0 12.0 NaN NaN
e 5.0 6.0 13.0 14.0 11.0 12.0
f NaN NaN NaN NaN 16.0 17.0
3.軸向連接
另一種數據合並運算也被稱作連接（concatenation）、綁定（binding）或堆疊(stacking)。NumPy有一個用於合並原始NumPy數組的concatenation函數：
In [42]: arr=np.arange(12).reshape((3,4))
In [43]: arr
Out[43]:
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
In [44]: np.concatenate([arr,arr],axis=1)
Out[44]:
array([[ 0, 1, 2, 3, 0, 1, 2, 3],
[ 4, 5, 6, 7, 4, 5, 6, 7],
[ 8, 9, 10, 11, 8, 9, 10, 11]])
對於pandas對象(如Series和DataFrame），帶有標簽的軸使我們能夠進一步推廣數組的連接運算。具體點說，我們還需要考慮一下這些東西：
1）如果各對象其他軸上的索引不同，那些軸應該是做並集還是交集？
2）結果對象中的分組需要各不相同嗎？
3）用於連接的軸重要嗎？
pandas的concat函數提供了一種能夠解決這些問題的可靠方式。下面給出一些例子來講解其使用方式。假設有三個沒有重疊索引的Series:
In [45]: from pandas import Series
In [46]: s1=Series([0,1],index=['a','b'])
In [47]: s2=Series([2,3,4],index=['c','d','e'])
In [48]: s3=Series([5,6],index=['f','g'])
對這些對象調用concat可以將值和索引粘合在一起：
In [49]: pd.concat([s1,s2,s3])
Out[49]:
a 0
b 1
c 2
d 3
e 4
f 5
g 6
dtype: int64
默認情況下，concat是在axis=0上工作的，最終產生一個新的Series.如果傳入axis=1,結果就會變成一個DataFrame（axis=1是列）：
In [51]: pd.concat([s1,s2,s3],axis=1,sort=True)
Out[51]:
0 1 2
a 0.0 NaN NaN
b 1.0 NaN NaN
c NaN 2.0 NaN
d NaN 3.0 NaN
e NaN 4.0 NaN
f NaN NaN 5.0
g NaN NaN 6.0
這種情況下，另外一條軸上沒有重疊，從索引的有序並集（外鏈接）上就可以看出來。
傳入join='inner'即可得到它們的交集：
In [54]: pd.concat([s1,s4],axis=1,sort=True)
Out[54]:
0 1
a 0.0 0
b 1.0 5
f NaN 5
g NaN 6
In [55]: pd.concat([s1,s4],axis=1,join='inner')
Out[55]:
0 1
a 0 0
b 1 5
In [56]: s4
Out[56]:
a 0
b 5
f 5
g 6
dtype: int64
我們可以通過join_axes指定要在其他軸上使用的索引：
In [57]: pd.concat([s1,s4],axis=1,join_axes=[['a','c','b','e']])
Out[57]:
0 1
a 0.0 0.0
c NaN NaN
b 1.0 5.0
e NaN NaN
不過有個問題，參與連接的片段在結果中區分不開。假設我們想要在連接軸上創建一個層次化索引。使用keys參數即可達到這個目的：
In [58]: result=pd.concat([s1,s2,s3],keys=['one','two','three'])
In [59]: result
Out[59]:
one a 0
b 1
two c 2
d 3
e 4
three f 5
g 6
dtype: int64
#后面將詳細講解unstack函數
In [60]: result.unstack()
Out[60]:
a b c d e f g
one 0.0 1.0 NaN NaN NaN NaN NaN
two NaN NaN 2.0 3.0 4.0 NaN NaN
three NaN NaN NaN NaN NaN 5.0 6.0
如果沿着axis=1對Series進行合並，則keys就會成為DataFrame的列頭：
In [62]: pd.concat([s1,s2,s3],axis=1,keys=['one','two','three'],sort=True)
Out[62]:
one two three
a 0.0 NaN NaN
b 1.0 NaN NaN
c NaN 2.0 NaN
d NaN 3.0 NaN
e NaN 4.0 NaN
f NaN NaN 5.0
g NaN NaN 6.0
同樣的邏輯對DataFrame對象也是一樣：
In [63]: df1=DataFrame(np.arange(6).reshape(3,2),index=['a','b','c'],columns=['
...: one','two'])
In [64]: df2=DataFrame(5+np.arange(4).reshape(2,2),index=['a','c'],columns=['th
...: ree','four'])
In [65]: pd.concat([df1,df2],axis=1,keys=['level1','level2'],sort=True)
Out[65]:
level1 level2
one two three four
a 0 1 5.0 6.0
b 2 3 NaN NaN
c 4 5 7.0 8.0
如果傳入的不是列表而是一個字典，則字典的鍵就會被當做keys選項的值：
In [67]: pd.concat({'level1':df1,'level2':df2},axis=1,sort=True)
Out[67]:
level1 level2
one two three four
a 0 1 5.0 6.0
b 2 3 NaN NaN
c 4 5 7.0 8.0
此外還有兩個用於管理層次化索引創建方式的參數
In [70]: pd.concat([df1,df2],axis=1,keys=['level1','level2'],names=['upper','lo
...: wer'],sort=True)
Out[70]:
upper level1 level2
lower one two three four
a 0 1 5.0 6.0
b 2 3 NaN NaN
c 4 5 7.0 8.0
最后一個需要考慮的問題是，跟當前分析工作無關的DataFrame行索引：
In [71]: df1=DataFrame(np.random.randn(3,4),columns=['a','b','c','d'])
In [72]: df2=DataFrame(np.random.randn(2,3),columns=['b','d','a'])
In [73]: df1
Out[73]:
a b c d
0 1.063786 0.119253 0.143501 0.169069
1 -1.825730 -0.406440 -0.505858 0.181967
2 0.023236 0.829552 0.401033 -0.365971
In [74]: df2
Out[74]:
b d a
0 -0.101389 -1.745123 1.739812
1 0.866487 1.324343 0.695858
在這種情況下，傳入ignore_index=True即可：
In [77]: pd.concat([df1,df2],ignore_index=True,sort=True)
Out[77]:
a b c d
0 1.063786 0.119253 0.143501 0.169069
1 -1.825730 -0.406440 -0.505858 0.181967
2 0.023236 0.829552 0.401033 -0.365971
3 1.739812 -0.101389 NaN -1.745123
4 0.695858 0.866487 NaN 1.324343
concat函數的參數
參數 說明
objs 參與連接的pandas對象的列表或字典。唯一必須的參數
axis 指明連接的軸向，默認為0
join "inner"、“outer”其中之一，默認為“outer”.指明其他軸向上的索引是按交集(inner)還是並集(outer)進行合並
join_axes 指明用於其他n-1條軸的索引，不執行並集/交集運算
keys 與連接對象有關的值，用於形成連接軸向上的層次化索引。可以是任意值得列表或數組、元組數組、數組列表（如果levels設置成多級數組的話）
levels 指定用作層次化索引各級別上的索引，如果設置了keys的話，用於創建分層級別的名稱，如果設置了keys和(或）levels的話
verify_integrity 檢查結果對象新軸上的重復情況，如果發現則引發異常。默認（False）允許重復
ignore_index 不保留連接軸上的索引，產生一組新索引range(total_length)
4.合並重疊數據
還有一種數據組合問題不能用簡單的合並(merge)或連接(concatenation)運算來處理。比如說，我們可能有索引全部或部分重疊的數據集。給這個例子增加一點啟發性，我們使用NumPy的where函數，它用於表達一種矢量化的if-else:
In [1]: import pandas as pd
In [2]: import numpy as np
In [3]: from pandas import DataFrame
In [4]: from pandas import Series
In [5]: a=Series([np.nan,6.6,np.nan,7.7,8.8,np.nan],index=['f','e','d','c','b',
...: 'a'])
In [7]: b=Series(np.arange(len(a),dtype=np.float64),index=['f','e','d','c','b',
...: 'a'])
In [8]: b[-1]=np.nan
In [9]: a
Out[9]:
f NaN
e 6.6
d NaN
c 7.7
b 8.8
a NaN
dtype: float64
In [10]: b
Out[10]:
f 0.0
e 1.0
d 2.0
c 3.0
b 4.0
a NaN
dtype: float64
In [11]: np.where(pd.isnull(a),b,a)
Out[11]: array([0. , 6.6, 2. , 7.7, 8.8, nan])
Series有一個combine_first方法，實現的也是一樣的功能，而且會進行數據對齊：
In [17]: b[:-2].combine_first(a[2:])
Out[17]:
a NaN
b 8.8
c 3.0
d 2.0
e 1.0
f 0.0
dtype: float64
對於DataFrame,combine_first自然也會在列上做同樣的事情，因此我們可以將其看做：用參數對象中的數據為調用者對象的缺失數據“打補丁”：
In [18]: df1=DataFrame({'a':[1,np.nan,5,np.nan],'b':[np.nan,2,np.nan,6],'c':ran
...: ge(2,18,4)})
In [19]: df2=DataFrame({'a':[5,4,np.nan,3,7],'b':[np.nan,3,4,6,8]})
In [20]: df1.combine_first(df2) #df2填充df1對應的NaN值
Out[20]:
a b c
0 1.0 NaN 2.0
1 4.0 2.0 6.0
2 5.0 4.0 10.0
3 3.0 6.0 14.0
4 7.0 8.0 NaN