Pandas操作数据集非常的方便，其中体现在就是有些在SQL语句中常用的方法，比如在合并数据集、left join、right join、full join、inner join，在Pandas中都可以使用concat和merge简单的实现
concat参数
pd.concat(objs, axis=0, join='outer', join_axes=None,
ignore_index=False,keys=None,levels=None,
names=None,verify_integrity=False,
copy=True)
1、objs : #输入,DataFrame格式或list(多个合并).
2、axis: {0, 1, ...}, default 0. #控制连接的方向,0代表列纵向,1代表行横向
3、join : {‘inner’, ‘outer’}, default ‘outer’. #控制连接的索引,inner表示取表索引之间的交集,outer表示取索引的并集
4、ignore_index: boolean, default False. #是否使用原索引，选舍弃便对新表重新进行索引排序。
5、join_axes : list of Index objects. #设定使用的索引,例以df1的索引为标准,join_axes=[df1.index]
6、keys : sequence, default None. #类似Multiindex,设立另一层索引
merge的参数
merge(left, right, how='inner', on=None, left_on=None, right_on=None,
left_index=False, right_index=False, sort=True,
suffixes=('_x', '_y'), copy=True, indicator=False)
1、on：列名，join用来对齐的那一列的名字，用到这个参数的时候一定要保证左表和右表用来对齐的那一列都有相同的列名。
2、left_on：左表对齐的列，可以是列名，也可以是和dataframe同样长度的arrays。
3、right_on：右表对齐的列，可以是列名，也可以是和dataframe同样长度的arrays。
4、left_index/ right_index: 如果是True的haunted以index作为对齐的key
5、how：数据融合的方法。
6、sort：根据dataframe合并的keys按字典顺序排序，默认是，如果置false可以提高表现。
1. 纵向合并数据集
纵向合并数据的方法concat和append，类似SQL中的union
#样集1
In [9]:df1 = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
'B': ['B0', 'B1', 'B2', 'B3'],
'C': ['C0', 'C1', 'C2', 'C3'],
'D': ['D0', 'D1', 'D2', 'D3']},
index=[0, 1, 2, 3])
In [9]:df1
Out[9]:
A B C D
0 A0 B0 C0 D0
1 A1 B1 C1 D1
2 A2 B2 C2 D2
3 A3 B3 C3 D3
# 样集2
In [10]:df2 = pd.DataFrame({'A': ['A4', 'A5', 'A6', 'A7'],
'B': ['B4', 'B5', 'B6', 'B7'],
'C': ['C4', 'C5', 'C6', 'C7'],
'D': ['D4', 'D5', 'D6', 'D7']},
index=[4, 5, 6, 7])
In [10]:df2
Out[10]:
A B C D
4 A4 B4 C4 D4
5 A5 B5 C5 D5
6 A6 B6 C6 D6
7 A7 B7 C7 D7
#样集3
In [11]:df3 = pd.DataFrame({'A': ['A8', 'A9', 'A10', 'A11'],
'B': ['B8', 'B9', 'B10', 'B11'],
'C': ['C8', 'C9', 'C10', 'C11'],
'D': ['D8', 'D9', 'D10', 'D11']},
index=[8, 9, 10, 11])
In [11]:df3
Out[11]:
A B C D
8 A8 B8 C8 D8
9 A9 B9 C9 D9
10 A10 B10 C10 D10
11 A11 B11 C11 D11
#样集4
In [12]:df4 = pd.DataFrame({'B': ['B2', 'B3', 'B6', 'B7'],
'D': ['D2', 'D3', 'D6', 'D7'],
'F': ['F2', 'F3', 'F6', 'F7']},
index=[2, 3, 6, 7])
In [12]:df4
Out[12]:
B D F
2 B2 D2 F2
3 B3 D3 F3
6 B6 D6 F6
7 B7 D7 F7
1.1 使用concat
concat的语法形式
pd.concat(objs, axis=0, join='outer', join_axes=None, ignore_index=False,
keys=None, levels=None, names=None, verify_integrity=False)
#纵向合并df1、df2、df3
In [13]:frames = [df1, df2, df3]
In [14]:pd.concat(frames)
Out[14]:
A B C D
0 A0 B0 C0 D0
1 A1 B1 C1 D1
2 A2 B2 C2 D2
3 A3 B3 C3 D3
4 A4 B4 C4 D4
5 A5 B5 C5 D5
6 A6 B6 C6 D6
7 A7 B7 C7 D7
8 A8 B8 C8 D8
9 A9 B9 C9 D9
10 A10 B10 C10 D10
11 A11 B11 C11 D11
#使用key为每个数据集指定块标记
In [15]: pd.concat(frames,keys=['x','y','z'])
Out[15]:
A B C D
x 0 A0 B0 C0 D0
1 A1 B1 C1 D1
2 A2 B2 C2 D2
3 A3 B3 C3 D3
y 4 A4 B4 C4 D4
5 A5 B5 C5 D5
6 A6 B6 C6 D6
7 A7 B7 C7 D7
z 8 A8 B8 C8 D8
9 A9 B9 C9 D9
10 A10 B10 C10 D10
11 A11 B11 C11 D11
#使用块标记提取数据子集
In [16]:result.ix['y']
Out[16]:
A B C D
4 A4 B4 C4 D4
5 A5 B5 C5 D5
6 A6 B6 C6 D6
7 A7 B7 C7 D7
#concat默认join='outer'，所以纵向合并，没有值补缺失值，索引可以为重复
In [17]:result = pd.concat([df1,df4])
In [18]:result
Out[18]:
A B C D F
0 A0 B0 C0 D0 NaN
1 A1 B1 C1 D1 NaN
2 A2 B2 C2 D2 NaN
3 A3 B3 C3 D3 NaN
2 NaN B2 NaN D2 F2
3 NaN B3 NaN D3 F3
6 NaN B6 NaN D6 F6
7 NaN B7 NaN D7 F7
#concat默认join='outer'，把重复的索引合并，索引没有重复
In [19]:result = pd.concat([df1,df4],axis=1)
In [20]:result
Out[20]:
A B C D B D F
0 A0 B0 C0 D0 NaN NaN NaN
1 A1 B1 C1 D1 NaN NaN NaN
2 A2 B2 C2 D2 B2 D2 F2
3 A3 B3 C3 D3 B3 D3 F3
6 NaN NaN NaN NaN B6 D6 F6
7 NaN NaN NaN NaN B7 D7 F7
#concat修改join='inner'，只保留重复的索引合并
In [21]:result = pd.concat([df1,df4],axis=1,join='inner')
In [22]:result
Out[22]:
A B C D B D F
2 A2 B2 C2 D2 B2 D2 F2
3 A3 B3 C3 D3 B3 D3 F3
#concat按照其中一个索引合并，只保留重复的索引合并
In [23]:result = pd.concat([df1,df4],axis=1,join_axes=[df1.index])
In [24]:result
Out[24]:
A B C D B D F
0 A0 B0 C0 D0 NaN NaN NaN
1 A1 B1 C1 D1 NaN NaN NaN
2 A2 B2 C2 D2 B2 D2 F2
3 A3 B3 C3 D3 B3 D3 F3
1.2 使用append
#等价于result = pd.concat([df1,df2])
In [25]:result = df1.append(df2)
In [26]:result
Out[26]:
A B C D
0 A0 B0 C0 D0
1 A1 B1 C1 D1
2 A2 B2 C2 D2
3 A3 B3 C3 D3
4 A4 B4 C4 D4
5 A5 B5 C5 D5
6 A6 B6 C6 D6
7 A7 B7 C7 D7
#等价于result = pd.concat([df1,df4])
In [27]:result = df1.append(df4)
In [28]:result
Out[28]:
A B C D F
0 A0 B0 C0 D0 NaN
1 A1 B1 C1 D1 NaN
2 A2 B2 C2 D2 NaN
3 A3 B3 C3 D3 NaN
2 NaN B2 NaN D2 F2
3 NaN B3 NaN D3 F3
6 NaN B6 NaN D6 F6
7 NaN B7 NaN D7 F7
#等价于result = pd.concat([df1,df2,df3])
In [29]:result = df1.append([df2,df3])
In [30]:result
Out[30]:
A B C D
0 A0 B0 C0 D0
1 A1 B1 C1 D1
2 A2 B2 C2 D2
3 A3 B3 C3 D3
4 A4 B4 C4 D4
5 A5 B5 C5 D5
6 A6 B6 C6 D6
7 A7 B7 C7 D7
8 A8 B8 C8 D8
9 A9 B9 C9 D9
10 A10 B10 C10 D10
11 A11 B11 C11 D11
1.2.1 横向合并连接一个DataFrame和一个Series
In [31]:s1 = pd.Series(['X0', 'X1', 'X2', 'X3'], name='X')
In [32]:result = pd.concat([df1,s1],axis=1)
Out[32]: result
A B C D X
0 A0 B0 C0 D0 X0
1 A1 B1 C1 D1 X1
2 A2 B2 C2 D2 X2
3 A3 B3 C3 D3 X3
1.2.2 纵向合并连接一个DataFrame和一个Series
In [33]:s1 = pd.Series(['X0', 'X1', 'X2', 'X3'], index=['A', 'B', 'C', 'D'])
In [34]:s2
Out[34]:
A X0
B X1
C X2
D X3
dtype: object
result = df1.append(s1)
In [35]:result = df1.append(s2,ignore_index=True)
In [36]:result
Out[36]:
A B C D
0 A0 B0 C0 D0
1 A1 B1 C1 D1
2 A2 B2 C2 D2
3 A3 B3 C3 D3
4 X0 X1 X2 X3
2. 连接数据集
merge的语法形式
merge(left, right, how='inner', on=None, left_on=None, right_on=None,
left_index=False, right_index=False, sort=True,
suffixes=('_x', '_y'), copy=True, indicator=False)
Merge方法与SQL方法比较
Merge SQL join 说明
left LEFT OUTER JOIN 左连接
right RIGHT OUTER JOIN 右连接
outer FULL OUTER JOIN 全连接
inner INNER JOIN 内连接
2.1 按照一列标签名相同（列Key）连接
# 数据样集1，只有一列key
In [37]:left = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
'A': ['A0', 'A1', 'A2', 'A3'],
'B': ['B0', 'B1', 'B2', 'B3']})
In [38]:left
Out[38]:
A B key
0 A0 B0 K0
1 A1 B1 K1
2 A2 B2 K2
3 A3 B3 K3
# 数据样集2，只有一列名均为key
In [39]:right = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
'C': ['C0', 'C1', 'C2', 'C3'],
'D': ['D0', 'D1', 'D2', 'D3']})
In [40]:right
Out[40]:
C D key
0 C0 D0 K0
1 C1 D1 K1
2 C2 D2 K2
3 C3 D3 K3
#merge默认为inner join
In [41]:result = pd.merge(left, right, on='key')
In [42]:result
Out[42]:
A B key C D
0 A0 B0 K0 C0 D0
1 A1 B1 K1 C1 D1
2 A2 B2 K2 C2 D2
3 A3 B3 K3 C3 D3
2.2 按照不同列标签名（两列Key1和Key2）连接
#数据样集1
In [43]:left = pd.DataFrame({'key1': ['K0', 'K0', 'K1', 'K2'],
'key2': ['K0', 'K1', 'K0', 'K1'],
'A': ['A0', 'A1', 'A2', 'A3'],
'B': ['B0', 'B1', 'B2', 'B3']})
In [44]:left
Out[44]:
A B key1 key2
0 A0 B0 K0 K0
1 A1 B1 K0 K1
2 A2 B2 K1 K0
3 A3 B3 K2 K1
#数据样集2
In [45]:right = pd.DataFrame({'key1': ['K0', 'K1', 'K1', 'K2'],
'key2': ['K0', 'K0', 'K0', 'K0'],
'C': ['C0', 'C1', 'C2', 'C3'],
'D': ['D0', 'D1', 'D2', 'D3']})
In [46]:right
Out[46]:
C D key1 key2
0 C0 D0 K0 K0
1 C1 D1 K1 K0
2 C2 D2 K1 K0
3 C3 D3 K2 K0
2.2.1 inner内连接
#等价于result = pd.merge(left,right,how='inner',on=['key1','key2'])
In [47]:result = pd.merge(left,right,on=['key1','key2'])
In [48]:result
Out[48]:
A B key1 key2 C D
0 A0 B0 K0 K0 C0 D0
1 A2 B2 K1 K0 C1 D1
2 A2 B2 K1 K0 C2 D2
2.2.2 left左连接
In [49]:result = pd.merge(left,right,how='left',on=['key1','key2'])
In [50]:result
Out[50]:
A B key1 key2 C D
0 A0 B0 K0 K0 C0 D0
1 A1 B1 K0 K1 NaN NaN
2 A2 B2 K1 K0 C1 D1
3 A2 B2 K1 K0 C2 D2
4 A3 B3 K2 K1 NaN NaN
2.2.3 right右连接
In [49]:result = pd.merge(left,right,how='right',on=['key1','key2'])
In [50]:result
Out[50]:
A B key1 key2 C D
0 A0 B0 K0 K0 C0 D0
1 A2 B2 K1 K0 C1 D1
2 A2 B2 K1 K0 C2 D2
3 NaN NaN K2 K0 C3 D3
2.2.4 outer右连接
In [51]:result = pd.merge(left,right,how='outer',on=['key1','key2'])
In [52]:result
Out[52]:
A B key1 key2 C D
0 A0 B0 K0 K0 C0 D0
1 A1 B1 K0 K1 NaN NaN
2 A2 B2 K1 K0 C1 D1
3 A2 B2 K1 K0 C2 D2
4 A3 B3 K2 K1 NaN NaN
5 NaN NaN K2 K0 C3 D3
2.3 按照索引连接，格式如A.join(B)
#样本数据集1
In [53]:left = pd.DataFrame({'A': ['A0', 'A1', 'A2'],
'B': ['B0', 'B1', 'B2']},
index=['K0', 'K1', 'K2'])
In [54]:left
Out[54]:
A B
K0 A0 B0
K1 A1 B1
K2 A2 B2
#样本数据集2
In [55]: right = pd.DataFrame({'C': ['C0', 'C2', 'C3'],
'D': ['D0', 'D2', 'D3']},
index=['K0', 'K2', 'K3'])
In [56]:right
Out[56]:
C D
K0 C0 D0
K2 C2 D2
K3 C3 D3
2.3.1 A.join(B)
In [57]:result = left.join(right)
In [58]:result
Out[58]:
A B C D
K0 A0 B0 C0 D0
K1 A1 B1 NaN NaN
K2 A2 B2 C2 D2
2.3.2 A.join(B,how='outer')
#等价于 result = pd.merge(left, right, left_index=True, right_index=True, how='outer')
In [59]:result = left.join(right,how='outer')
In [60]:result
Out[60]:
A B C D
K0 A0 B0 C0 D0
K1 A1 B1 NaN NaN
K2 A2 B2 C2 D2
K3 NaN NaN C3 D3
2.3.3 A.join(B,how='inner')
#等价于 result = pd.merge(left, right, left_index=True, right_index=True, how='inner')
In [61]:result = left.join(right,how='inner')
In [62]:result
Out[62]:
A B C D
K0 A0 B0 C0 D0
K2 A2 B2 C2 D2
2.4 连接时一个是列一个是索引
#样本数据集1
In [63]:left = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
'B': ['B0', 'B1', 'B2', 'B3'],
'key': ['K0', 'K1', 'K0', 'K1']})
In [64]:left
Out[64]:
A B key
0 A0 B0 K0
1 A1 B1 K1
2 A2 B2 K0
3 A3 B3 K1
#样本数据集2
In [65]:right = pd.DataFrame({'C': ['C0', 'C1'],
'D': ['D0', 'D1']},
index=['K0', 'K1'])
In [66]:right
Out[66]:
C D
K0 C0 D0
K1 C1 D1
In [67]:result = left.join(right,on='key')
In [68]:result
Out[68]:
A B key C D
0 A0 B0 K0 C0 D0
1 A1 B1 K1 C1 D1
2 A2 B2 K0 C0 D0
3 A3 B3 K1 C1 D1
#等价于
result = pd.merge(left, right, left_on='key', right_index=True,
how='left', sort=False);