pandas之数据合并

在数据处理中，不免会遇到数据之间的合并。学过关系数据库的童鞋应该都清楚数据表之间的连接。今天要说的数据合并其实和数据表之间的连接有很多相似之处。由于 pandas 库在数据分析中比较方便而且用者较多，我们就说pandas中的数据合并方式。

pandas 中数据合并常用的方法有三种：pandas.merge(), pandas.concat(), 以及实例方法 combine_first()

1）pandas.merge()

merge函数的参数：

left, right	参与合并的左、右侧Dataframe
how	inner、outer、left、right之一，默认是 inner
on	指定用于连接的列名。如果未指定，则会自动选取要合并数据中相同的列名
left_on, right_on	左、右侧Dataframe用于连接键的列
left_index, right_index	将左 \ 右侧的行索引用作连接键
sort	根据连接键对合并后的数据进行排序，默认True。在处理大数据集的时候，禁用此功能能会有很好的性能提升
suffixes	字符串元组，用于追加到重复列名的末尾，默认('_x', '_y')
copy	设置为False，可以在某些特殊情况下避免将数据复制到结果数据结构中。默认总是复制。

看几个简单的例子：

In [10]: df1 = pd.DataFrame({'k':['s','s','w','x','x','n','f','c'],'data1':range(8)})
In [11]: df2 = pd.DataFrame({'k':['w','w','s','s','x','f'],'data2':range(6)})
In [12]: pd.merge(df1,df2)  # 未指定合并的列，默认选取两者重复的列 k， 也可以指定 pd.merge(df1,df2，on='k')
Out[12]: data1  k  data2
0      0  s      2
1      0  s      3
2      1  s      2
3      1  s      3
4      2  w      0
5      2  w      1
6      3  x      4
7      4  x      4
8      6  f      5

从上面的结果中会发现有些行消失了，这是因为默认使用的是 inner 连接方式，结果做的交集。可以指定其他的连接方式(参见上面的 how 参数值)。例如：

In [13]: pd.merge(df1,df2,how='outer')
Out[13]: data1  k  data2
0       0  s    2.0
1       0  s    3.0
2       1  s    2.0
3       1  s    3.0
4       2  w    0.0
5       2  w    1.0
6       3  x    4.0
7       4  x    4.0
8       5  n    NaN
9       6  f    5.0
10      7  c    NaN

合并的列名不同时，手动指定要合并的列：

In [14]: df2 = pd.DataFrame({'k_1':['w','w','s','s','x','f'] ,'data2':range(6)})
In [17]: pd.merge(df1,df2,left_on='k',right_on='k_1',how='outer')
Out[17]: data1  k  data2  k_1
0       0  s    2.0    s
1       0  s    3.0    s
2       1  s    2.0    s
3       1  s    3.0    s
4       2  w    0.0    w
5       2  w    1.0    w
6       3  x    4.0    x
7       4  x    4.0    x
8       5  n    NaN  NaN
9       6  f    5.0    f
10      7  c    NaN  NaN

根据多个键进行合并，只需要在 on 关键字传入一个列名组成的列表即可：

In [25]: left = pd.DataFrame({'key1': ['foo', 'foo', 'bar'],...: 'key2': ['one', 'two', 'one'],'val': [1, 2, 3]})
In [26]: right = pd.DataFrame({'key1': ['foo', 'foo','bar','bar'],...: 'key2': ['one', 'one', 'one','two'],'val': [4,5,6,7]})In [27]: pd.merge(left, right, on=['key1', 'key2'], how='outer')
Out[27]: key1 key2  val_x  val_y
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

从上面的例子中还可以看到，当合并的数据有相同的列时，结果会默认在后面添加_x, _y来区分。也可以手动指定：

In [31]: pd.merge(left, right, on='key1', how='outer',suffixes=('_left','_right'))
Out[31]: key1 key2_left  val_left key2_right  val_right
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

索引作为连接键的合并

有的时候我们要合并的连接键在索引中，这种情况我们就要通过 left_index = True  \ right_index = True 来明确索引作为连接键。
In [35]: df3 = pd.DataFrame({'data3':[5,2,0]},index=list('sxn'))
In [36]: df3
Out[36]: data3
s      5
x      2
n      0
In [37]: pd.merge(df1,df3,left_on='k',right_index=True,how='outer')
Out[37]: data1  k  data3
0      0  s    5.0
1      1  s    5.0
2      2  w    NaN
3      3  x    2.0
4      4  x    2.0
5      5  n    0.0
6      6  f    NaN
7      7  c    NaN

合并层次化索引的数据，必须以列表的形式指明用作合并的列：

In [49]:  lefth = pd.DataFrame({'key1': ['sxn', 'sxn', 'sxn', 'wfc', 'wfc'],
'key2': [2000, 2001, 2002, 2001, 2002],...: 'data': np.arange(5.)})
In [50]: righth = pd.DataFrame(np.arange(12).reshape((6, 2)) ,...: index=[['wfc', 'wfc', 'sxn', 'sxn', 'sxn', 'snx'],...: [2001, 2000, 2000, 2000, 2001, 2002]],...: columns=['event1', 'event2'])
In [51]: pd.merge(lefth, righth, left_on=['key1', 'key2'],right_index=True, how='outer')
Out[51]: data key1  key2  event1  event2
0   0.0  sxn  2000     4.0     5.0
0   0.0  sxn  2000     6.0     7.0
1   1.0  sxn  2001     8.0     9.0
2   2.0  sxn  2002     NaN     NaN
3   3.0  wfc  2001     0.0     1.0
4   4.0  wfc  2002     NaN     NaN
4   NaN  wfc  2000     2.0     3.0
4   NaN  snx  2002    10.0    11.0

Dataframe 的 join 方法更为方便的实现索引上面的合并

In [62]: df1 = pd.DataFrame({'data1':range(8)},index=['s','s','w','x','x','n','f','c'])
In [63]: df2 = pd.DataFrame({'data2':range(4)},index=['s','n','f','c'])In [64]: df1.join(df2)
Out[64]: data1  data2
c      7    3.0
f      6    2.0
n      5    1.0
s      0    0.0
s      1    0.0
w      2    NaN
x      3    NaN
x      4    NaNIn [65]: df3 = pd.DataFrame({'data3':[5,2,0]},index=list('sx...: n'))...:
In [66]: df1.join([df2,df3])
Out[66]: data1  data2  data3
c      7    3.0    NaN
f      6    2.0    NaN
n      5    1.0    0.0
s      0    0.0    5.0
s      1    0.0    5.0
w      2    NaN    NaN
x      3    NaN    2.0
x      4    NaN    2.0

2）pandas.concat()

这种连接也是轴向连接，也叫连接，绑定，堆叠。

numpy 中 concatenation函数。

In [68]: arr = np.arange(12).reshape(3,4)
In [69]: np.concatenate([arr,arr],axis=1)   # 指定连接轴，axis=1

Out[69]:
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]])
In [70]: np.concatenate([arr,arr],axis=0)  # 指定连接轴，axis=0Out[70]:
array([[ 0,  1,  2,  3],[ 4,  5,  6,  7],[ 8,  9, 10, 11],[ 0,  1,  2,  3],[ 4,  5,  6,  7],[ 8,  9, 10, 11]])

concat的参数：

objs	参与连接的pandas的列表或字典，唯一必须的参数
axis	指明连接的轴向，默认axis=0
join	inner、outer之一
join_axes	指明用于其他n-1条轴上的索引，不执行并集交集运算
keys	用于形成连接轴上的层次化索引
levels	指定用于层次化索引各级别上的索引，如果设置了的keys的话
names	用于创建分级别的名称，如果设置了levels和keys 的话
verify_integrity	检查结果对象新轴上的重复情况，如果发现引发异常，默认可以重复
ignore_index	不保留连接轴上的索引，产生一组新索引

下面是一些例子说明以上参数的使用情况:

In [77]: s1 = pd.Series([0,1],index=['a','b'])
In [78]: s2 = pd.Series([2,3,4],index=['c','d','e'])
In [79]: s3 = pd.Series([5,6],index=['f','g'])
In [80]: pd.concat([s1,s2,s3])      # 默认 axis=0
Out[80]:
a    0
b    1
c    2
d    3
e    4
f    5
g    6
dtype: int64
In [81]: pd.concat([s1,s2,s3],axis=1)    # 按照 axis=1 进行连接，产生一个Dataframe 对象
Out[81]:  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

In [90]: s4 = pd.concat([s1*5,s3])
In [91]: pd.concat([s1,s4])
Out[91]:
a    0
b    1
a    0
b    5
f    5
g    6
dtype: int64
In [94]: pd.concat([s1,s4],keys=['s1','s4'])  # 可以区分合并后的结果
Out[94]:
s1  a    0b    1
s4  a    0b    5f    5g    6
dtype: int64
In [97]: pd.concat([s1,s4],axis=1,keys=['s1','s4'])  # 沿着 axis=1 合并，指定的 keys 就会变成Dataframe的列名
Out[97]: s1  s4
a  0.0   0
b  1.0   5
f  NaN   5
g  NaN   6

In [92]: pd.concat([s1,s4],axis=1)  # 按照 axis=1 进行连接，产生一个Dataframe 对象
Out[92]: 0  1
a  0.0  0
b  1.0  5
f  NaN  5
g  NaN  6

In [93]: pd.concat([s1,s4],axis=1,join='inner')   # join='inner' 产生交集Out[93]: 0  1
a  0  0
b  1  5

In [96]: pd.concat([s1,s4],axis=1,join_axes=[['a','c','b','f']])  # 指定要在其他轴上使用的索引
Out[96]: 0    1
a  0.0  0.0
c  NaN  NaN
b  1.0  5.0
f  NaN  5.0

对于Dataframe的合并，逻辑差不多类似：

In [98]: df1 = pd.DataFrame(np.arange(6).reshape(3, 2), index=['a', 'b', 'c'],columns=['one', 'two'])
In [99]:  df2 = pd.DataFrame(5 + np.arange(4).reshape(2, 2), index=['a', 'c'],columns=['three', 'four'])
In [100]: pd.concat([df1, df2], axis=1, keys=['level1', 'level2'])
Out[100]: level1     level2one two  three four
a      0   1    5.0  6.0
b      2   3    NaN  NaN
c      4   5    7.0  8.0

In [102]: pd.concat([df1, df2], axis=1)
Out[102]: one  two  three  four
a    0    1    5.0   6.0
b    2    3    NaN   NaN
c    4    5    7.0   8.0

In [101]: pd.concat([df1, df2])  # 不指定轴向。默认axis=0
Out[101]: four  one  three  two
a   NaN  0.0    NaN  1.0
b   NaN  2.0    NaN  3.0
c   NaN  4.0    NaN  5.0
a   6.0  NaN    5.0  NaN
c   8.0  NaN    7.0  NaN
In [103]: pd.concat([df1, df2],keys=['level1', 'level2'])
Out[103]: four  one  three  two
level1 a   NaN  0.0    NaN  1.0b   NaN  2.0    NaN  3.0c   NaN  4.0    NaN  5.0
level2 a   6.0  NaN    5.0  NaNc   8.0  NaN    7.0  NaN

In [104]: pd.concat([df1, df2], axis=1, keys=['level1', 'level2'],names=['up','down'])  # 用 names 为各分层级别命名
Out[104]:
up   level1     level2
down    one two  three four
a         0   1    5.0  6.0
b         2   3    NaN  NaN
c         4   5    7.0  8.0

实例方法 combine_first()

还有一种数据组合，简单的说就是数据合并的时候，我有值用我的，我没有值(NA)用你的，都没有那就没有吧。。。这种数据合并，我们先用numpy的where函数解决一下，就知道我上句说的啥意思了。

In [105]: s1 = pd.Series([np.nan, 2.5, np.nan, 3.5, 4.5, np.nan],index=['f', 'e', 'd', 'c', 'b', 'a'])
In [107]: s2 = pd.Series(np.arange(len(s1), dtype=np.float64),index=['f', 'e', 'd', 'c', 'b', 'a'])In [108]: s2[-1] = np.nan
In [110]: s1
Out[110]:
f    NaN
e    2.5
d    NaN
c    3.5
b    4.5
a    NaN
dtype: float64In [111]: s2
Out[111]:
f    0.0
e    1.0
d    2.0
c    3.0
b    4.0
a    NaN
dtype: float64In [113]: np.where(pd.isnull(s1),s2,s1)
Out[113]: array([0. , 2.5, 2. , 3.5, 4.5, nan])In [114]: s3 = pd.Series(np.where(pd.isnull(s1),s2,s1),index=s1.index)
In [115]: s3
Out[115]:
f    0.0
e    2.5
d    2.0
c    3.5
b    4.5
a    NaN
dtype: float64

嗯，看到没，大概就是上面这个样子的......

combine_first() 也是实现一样的功能：

In [118]: s2[:-2].combine_first(s1[2:])
Out[118]:
a    NaN
b    4.5
c    3.0
d    2.0
e    1.0
f    0.0
dtype: float64

看看Dataframe的 combine_first():

In [119]: df1 = pd.DataFrame({'a': [1., np.nan, 5., np.nan],'b': [np.nan, 2., np.nan, 6.],
     ...: 'c': range(2, 18, 4)})
In [120]: df2 = pd.DataFrame({'a': [5., 4., np.nan, 3., 7.],'b': [np.nan, 3., 4., 6., 8.]})

In [121]: df1.combine_first(df2)
Out[121]:
     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