合并数据集

数据分析和建模方面的大量编程工作都是用在数据准备上的：加载、清理、转换以及重塑。有时候，存放在文件或数据库中的数据并不能满足你的数据处理应用的要求。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

接下来练习轴向连接和数据转换。