合併資料集

資料分析和建模方面的大量程式設計工作都是用在資料準備上的：載入、清理、轉換以及重塑。有時候，存放在檔案或資料庫中的資料並不能滿足你的資料處理應用的要求。pandas物件中的資料可以通過一些內建的方式進行合併：
pandas.merge可根據一個或多個鍵將不同DataFrame中的行連線起來。

資料庫風格的DataFrame合併

資料集的合併（merge）或連線（join）運算是通過一個或多個鍵將行連結起來的。這些運算是關係型資料庫的核心。pandas的merge函式是對資料應用這些演算法的主要切入點。

In [1]: from pandas import Series,DataFrame

In [2
 
]: import pandas as pd

In [3]: import numpy as np

In [6]: df1=DataFrame({'key':['b', 'b', 'a', 'c', 'a', 'a', 'b'],
   ...: 'data1':range(7)})

In [7]: df2=DataFrame({'key': ['a', 'b', 'd'],'data2':range(3)})

In [8]: df1
Out[8]: 
data1 key
0 0 b
1 1 b
2 2 a
3 3 c
4 4 a
5 5 a
6 6 b

In [9]: df2
Out[9
 
]: 
data2 key
0 0 a
1 1 b
2 2 d

這是一種多對一的合併。df1中的資料有多個被標記為a和b的行，而df2中key列的每個值則僅對應一行。對這些物件呼叫merge即可得到

In [10]: pd.merge(df1,df2)
Out[10]: 
data1 key data2
0 0 b 1
1 1 b 1
2 6 b 1
3 2 a 0
4 4 a 0
5 5 a 0

並沒有指明要用哪個列進行連線。如果沒有指定，merge就會將重疊列的列名當做鍵。不過，最好顯式指定一下

In [11]: pd.merge(df1, df2, on='key')
Out[11]: 
data1 key data2
0
 
 0 b 1
1 1 b 1
2 6 b 1
3 2 a 0
4 4 a 0
5 5 a 0

如果兩個物件的列名不同，也可以分別進行指定

In [12]: df3 = DataFrame({'lkey': ['b', 'b', 'a', 'c', 'a', 'a', 'b'],
    ...: 'data1': range(7)})

In [13]: df4 = DataFrame({'rkey': ['a', 'b', 'd'],
    ...: 'data2': range(3)})

In [14]: df3
Out[14]: 
data1 lkey
0 0 b
1 1 b
2 2 a
3 3 c
4 4 a
5 5 a
6 6 b

In [15]: df4
Out[15]: 
data2 rkey
0 0 a
1 1 b
2 2 d

In [16]: pd.merge(df3, df4, left_on='lkey', right_on='rkey')
Out[16]: 
data1 lkey data2 rkey
0 0 b 1 b
1 1 b 1 b
2 6 b 1 b
3 2 a 0 a
4 4 a 0 a
5 5 a 0 a

已經注意到了，結果裡面c和d以及與之相關的資料消失了。預設情況下，merge做的是”inner”連線；結果中的鍵是交集。其他方式還有”left”、”right”以及”outer”。外連線求取的是鍵的並集，組合了左連線和右連線的效果

In [17]: pd.merge(df1, df2, how='outer')
Out[17]: 
data1 key data2
0 0.0 b 1.0
1 1.0 b 1.0
2 6.0 b 1.0
3 2.0 a 0.0
4 4.0 a 0.0
5 5.0 a 0.0
6 3.0 c NaN
7 NaN d 2.0

多對多的合併操作比較簡單，如下所示

In [18]: df1 = DataFrame({'key': ['b', 'b', 'a', 'c', 'a', 'b'],
    ...: 'data1': range(6)})

In [19]: df2 = DataFrame({'key': ['a', 'b', 'a', 'b', 'd'],
    ...: 'data2': range(5)})

In [20]: df1
Out[20]: 
data1 key
0 0 b
1 1 b
2 2 a
3 3 c
4 4 a
5 5 b

In [21]: df2
Out[21]: 
data2 key
0 0 a
1 1 b
2 2 a
3 3 b
4 4 d

In [22]: pd.merge(df1, df2, on='key', how='left')
Out[22]: 
data1 key data2
0 0 b 1.0
1 0 b 3.0
2 1 b 1.0
3 1 b 3.0
4 2 a 0.0
5 2 a 2.0
6 3 c NaN
7 4 a 0.0
8 4 a 2.0
9 5 b 1.0
10 5 b 3.0

多對多連線產生的是行的笛卡爾積。由於左邊的DataFrame有3個”b”行，右邊的有2個，所以最終結果中就有6個”b”行。連線方式隻影響出現在結果中的鍵

In [23]: pd.merge(df1, df2, how='inner')
Out[23]: 
data1 key data2
0 0 b 1
1 0 b 3
2 1 b 1
3 1 b 3
4 5 b 1
5 5 b 3
6 2 a 0
7 2 a 2
8 4 a 0
9 4 a 2

In [24]: left = DataFrame({'key1': ['foo', 'foo', 'bar'],
    ...: 'key2': ['one', 'two', 'one'],
    ...: 'lval': [1, 2, 3]})

要根據多個鍵進行合併，傳入一個由列名組成的列表即可

In [25]: right = DataFrame({'key1': ['foo', 'foo', 'bar', 'bar'],
    ...: 'key2': ['one', 'one', 'one', 'two'],
    ...: 'rval': [4, 5, 6, 7]})

In [26]: left
Out[26]: 
key1 key2 lval
0 foo one 1
1 foo two 2
2 bar one 3

In [27]: right
Out[27]: 
key1 key2 rval
0 foo one 4
1 foo one 5
2 bar one 6
3 bar two 7

In [28]: pd.merge(left, right, on=['key1', 'key2'], how='outer')
Out[28]: 
key1 key2 lval rval
0 foo one 1.0 4.0
1 foo one 1.0 5.0
2 foo two 2.0 NaN
3 bar one 3.0 6.0
4 bar two NaN 7.0

警告： 在進行列－列連線時，DataFrame物件中的索引會被丟棄。

對於合併運算需要考慮的最後一個問題是對重複列名的處理。雖然你可以手工處理列名重疊的問題（稍後將會介紹如何重新命名軸標籤），但merge有一個更實用的suffixes選項，用於指定附加到左右兩個DataFrame物件的重疊列名上的字串

In [29]: pd.merge(left, right, on='key1')
Out[29]: 
key1 key2_x lval key2_y rval
0 foo one 1 one 4
1 foo one 1 one 5
2 foo two 2 one 4
3 foo two 2 one 5
4 bar one 3 one 6
5 bar one 3 two 7

In [30]: pd.merge(left, right, on='key1', suffixes=('_left', '_right'))
Out[30]: 
key1 key2_left lval key2_right rval
0 foo one 1 one 4
1 foo one 1 one 5
2 foo two 2 one 4
3 foo two 2 one 5
4 bar one 3 one 6
5 bar one 3 two 7

merge的引數請參見表7-1

索引上的合併

有時候，DataFrame中的連線鍵位於其索引中。在這種情況下，你可以傳入left_index=True或right_index=True（或兩個都傳）以說明索引應該被用作連線鍵

In [4]: left1 = DataFrame({'key': ['a', 'b', 'a', 'a', 'b', 'c'],
   ...: 'value': range(6)})

In [5]: left1
Out[5]: 
key value
0 a 0
1 b 1
2 a 2
3 a 3
4 b 4
5 c 5

In [6]: right1 = DataFrame({'group_val': [3.5, 7]}, index=['a', 'b'])

In [7]: right1
Out[7]: 
group_val
a 3.5
b 7.0

In [8]: pd.merge(left1, right1, left_on='key', right_index=True)
Out[8]: 
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 [9]: pd.merge(left1, right1, left_on='key', right_index=True, how='outer')
Out[9]: 
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 [10]: lefth = DataFrame({'key1': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada'],
    ...: 'key2': [2000, 2001, 2002, 2001, 2002],
    ...: 'data': np.arange(5)})

In [11]: righth = DataFrame(np.arange(12).reshape((6, 2)),
    ...: index=[['Nevada', 'Nevada', 'Ohio', 'Ohio', 'Ohio', 'Ohio'],
    ...: [2001, 2000, 2000, 2000, 2001, 2002]],
    ...: columns=['event1', 'event2'])

In [12]: lefth
Out[12]: 
data key1 key2
0 0 Ohio 2000
1 1 Ohio 2001
2 2 Ohio 2002
3 3 Nevada 2001
4 4 Nevada 2002

In [13]: righth
Out[13]: 
event1 event2
Nevada 2001 0 1
2000 2 3
Ohio 2000 4 5
2000 6 7
2001 8 9
2002 10 11

對於層次索引，以列表的形式指明用作合併鍵的多個列（注意對重複索引值的處理）

In [14]: pd.merge(lefth, righth, left_on=['key1', 'key2'], right_index=True)
Out[14]: 
data key1 key2 event1 event2
0 0 Ohio 2000 4 5
0 0 Ohio 2000 6 7
1 1 Ohio 2001 8 9
2 2 Ohio 2002 10 11
3 3 Nevada 2001 0 1

In [15]: pd.merge(lefth, righth, left_on=['key1', 'key2'],
    ...: right_index=True, how='outer')
Out[15]: 
data key1 key2 event1 event2
0 0.0 Ohio 2000 4.0 5.0
0 0.0 Ohio 2000 6.0 7.0
1 1.0 Ohio 2001 8.0 9.0
2 2.0 Ohio 2002 10.0 11.0
3 3.0 Nevada 2001 0.0 1.0
4 4.0 Nevada 2002 NaN NaN
4 NaN Nevada 2000 2.0 3.0

同時使用合併雙方的索引也沒問題

In [16]: left2 = DataFrame([[1, 2], [3, 4], [5, 6]], index=['a', 'c', 'e'],
    ...: columns=['Ohio', 'Nevada'])

In [17]: right2 = DataFrame([[7, 8], [9, 10], [11, 12], [13, 14]],
    ...: index=['b', 'c', 'd', 'e'], columns=['Missouri', 'Alabama'])

In [18]: left2
Out[18]: 
Ohio Nevada
a 1.0 2.0
c 3.0 4.0
e 5.0 6.0

In [19]: right2
Out[19]: 
Missouri Alabama
b 7.0 8.0
c 9.0 10.0
d 11.0 12.0
e 13.0 14.0

In [20]: pd.merge(left2, right2, how='outer', left_index=True, right_index=True)
Out[20]: 
Ohio Nevada Missouri Alabama
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 [21]: left2.join(right2, how='outer')
Out[21]: 
Ohio Nevada Missouri Alabama
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 [22]: left1.join(right1, on='key')
Out[22]: 
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 [23]: another = DataFrame([[7., 8], [9, 10], [11, 12], [16, 17]],
    ...: index=['a', 'c', 'e', 'f'], columns=['New York', 'Oregon'])

In [24]: left2.join([right2, another])
Out[24]: 
Ohio Nevada Missouri Alabama New York Oregon
a 1.0 2.0 NaN NaN 7.0 8.0
c 3.0 4.0 9.0 10.0 9.0 10.0
e 5.0 6.0 13.0 14.0 11.0 12.0

In [25]: left2.join([right2, another], how='outer')
Out[25]: 
Ohio Nevada Missouri Alabama New York Oregon
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

接下來練習軸向連線和資料轉換。