第六章 连接

一、关系型连接

1、连接的基本概念

把两张相关的表按照某一个或某一组键连接起来是一种常见操作，这个键十分重要，往往用on参数表示。

另一个重要的要素是连接的形式，连接函数merge和join中提供了how参数来代表连接方式，分为左连接left、右连接right、内连接inner、外连接outer，它们的区别可以用如下示意图表示：

左连接：以左边的键为准，如果右边表中的键存在于左边，则将该键在右边中的值添加到左表中，否则处理为缺失值。

右连接：以右边的键为准。

内连接：只合并两边同时出现的键。

外连接：包含在左边和右边出现的键。

如果两边出现部分重复的情况，就以笛卡尔积的方式加入，如上图所示，左表中张三出现两次，右表中张三也出现两次，那么逐个匹配，最后产生的表必然包含2*2个姓名为张三的行。

2、值连接

在上面示意图中的例子中，两张表根据某一列的值来连接，事实上也可以通过几列值的组合进行连接。

df1 = pd.DataFrame({'Name':['San Zhang','Si Li'], 'Age':[20,30]})
df2 = pd.DataFrame({'Name':['Si Li','Wu Wang'], 'Gender':['F','M']})
df1.merge(df2, on='Name', how='left')
# 			Name	Age	Gender
# 0	San Zhang	20	NaN
# 1	Si Li	30	F

如果两个表中想要连接的列不具备相同的列名，可以通过left_on和right_on指定：

df1 = pd.DataFrame({'df1_name':['San Zhang','Si Li'], 'Age':[20,30]})
df2 = pd.DataFrame({'df2_name':['Si Li','Wu Wang'], 'Gender':['F','M']})
df1.merge(df2, left_on='df1_name', right_on='df2_name', how='left')
#   	 df1_name  Age df2_name Gender
# 0  San Zhang   20      NaN    NaN
# 1      Si Li   30    Si Li      F

如果两个表中的列出现了重复的列名，那么可以通过suffixes参数指定。例如合并考试成绩的时候，第一个表记录了语文成绩，第二个是数学成绩：

df1 = pd.DataFrame({'Name':['San Zhang'],'Grade':[70]})
df2 = pd.DataFrame({'Name':['San Zhang'],'Grade':[80]})
df1.merge(df2, on='Name', how='left', suffixes=['_Chinese','_Math'])
#         Name  Grade_Chinese  Grade_Math
# 0  San Zhang             70          80

在某些时候出现重复元素是麻烦的，例如两位同学来自不同的班级，但是姓名相同，这种时候就要指定on参数为多个列使得正确连接：

df1 = pd.DataFrame({'Name':['San Zhang', 'San Zhang'],
                    'Age':[20, 21],
                    'Class':['one', 'two']})
df2 = pd.DataFrame({'Name':['San Zhang', 'San Zhang'],
                    'Gender':['F', 'M'],
                    'Class':['two', 'one']})
df1
#   			 Name  Age Class
# 0  San Zhang   20   one
# 1  San Zhang   21   two

df2
# 				Name Gender Class
# 0  San Zhang      F   two
# 1  San Zhang      M   one

df1.merge(df2, on='Name', how='left') # 错误的结果
# 	Name			Age	Class_x	Gender	Class_y
# 0	San Zhang	20	one			F				two
# 1	San Zhang	20	one			M				one
# 2	San Zhang	21	two			F				two
# 3	San Zhang	21	two			M				one

df1.merge(df2, on=['Name', 'Class'], how='left') # 正确的结果
# 	Name			Age	Class	Gender
# 0	San Zhang	20	one		M
# 1	San Zhang	21	two		F

从上面的例子来看，在进行基于唯一性的连接下，如果键不是唯一的，那么结果就会产生问题。举例中的行数很少，但如果实际数据中有几十万到上百万行的进行合并时，如果想要保证唯一性，除了用duplicated检查是否重复外，merge中也提供了validate参数来检查连接的唯一性模式。这里共有三种模式，即一对一连接1:1，一对多连接1:m，多对一连接m:1连接，第一个是指左右表的键都是唯一的，后面两个分别指左表键唯一和右表键唯一。

【练一练】

上面以多列为键的例子中，错误写法显然是一种多对多连接，而正确写法是一对一连接，请修改原表，使得以多列为键的正确写法能够通过validate='1:m'的检验，但不能通过validate='m:1'的检验。

能够通过validate='1:m'的检验，但不能通过validate='m:1'的检验，说明左表键唯一但右表键不唯一。

df2 = pd.DataFrame({'Name':['San Zhang', 'San Zhang'],
                    'Gender':['F', 'M'],
                    'Class':['one', 'one']})

df1.merge(df2, on=['Name', 'Class'], how='left',validate='1:m')
# 	Name			Age	Class	Gender
# 0	San Zhang	20	one		F
# 1	San Zhang	20	one		M
# 2	San Zhang	21	two		NaN

df1.merge(df2, on=['Name', 'Class'], how='left',validate='m:1')
# Merge keys are not unique in right dataset; not a many-to-one merge

3、索引连接

所谓索引连接，就是把索引当作键，因此这和值连接本质上没有区别，pandas中利用join函数来处理索引连接，它的参数选择要少于merge，除了必须的on和how之外，可以对重复的列指定左右后缀lsuffix和rsuffix。其中，on参数指索引名，单层索引时省略参数表示按照当前索引连接。

df1 = pd.DataFrame({'Age':[20,30]}, index=pd.Series(['San Zhang','Si Li'],name='Name'))
df2 = pd.DataFrame({'Gender':['F','M']}, index=pd.Series(['Si Li','Wu Wang'],name='Name'))
df1.join(df2, how='left')
#    			  Age	Gender
# Name		
# San Zhang	20	NaN
# Si Li	    30	F

仿照第二小节的例子，写出语文和数学分数合并的join版本：

df1 = pd.DataFrame({'Grade':[70]}, index=pd.Series(['San Zhang'], name='Name'))
df2 = pd.DataFrame({'Grade':[80]}, index=pd.Series(['San Zhang'], name='Name'))
df1.join(df2, how='left', lsuffix='_Chinese', rsuffix='_Math')
#				 		Grade_Chinese	Grade_Math
# Name		
# San Zhang	70						80

如果想要进行类似于merge中以多列为键的操作的时候，join需要使用多级索引，例如在merge中的最后一个例子可以如下写出：

df1 = pd.DataFrame({'Age':[20,21]}, index=pd.MultiIndex.from_arrays([['San Zhang', 'San Zhang'],['one', 'two']], names=('Name','Class')))
df2 = pd.DataFrame({'Gender':['F', 'M']}, index=pd.MultiIndex.from_arrays([['San Zhang', 'San Zhang'],['two', 'one']], names=('Name','Class')))
df1
#										 Age
# 	Name      Class     
# 	San Zhang one     20
#             two     21
df2
#                 Gender
# Name      Class       
# San Zhang two        F
#           one        M
df1.join(df2)
# 								Age	Gender
# Name			Class		
# San Zhang	one		20	M
# 					two		21	F

二、方向连接

1、concat

有时候用户并不关心噫哪一列为键来合并，只是希望把两个表或多个表按照纵向或横向进行拼接，pandas中提供了concat函数来实现。

在concat中，最常用的有三个参数，它们是axis, join, keys，分别表示拼接方向，连接形式，以及在新表中指示来自于哪一张旧表的名字。这里需要特别注意，join和keys与之前提到的join函数和键的概念没有任何关系。

在默认状态下的axis=0，表示纵向拼接多个表，常常用于多个样本的拼接；而axis=1表示横向拼接多个表，常用于多个字段或特征的拼接。

例如，纵向合并各表中人的信息：

df1 = pd.DataFrame({'Name':['San Zhang','Si Li'], 'Age':[20,30]})
df2 = pd.DataFrame({'Name':['Wu Wang'], 'Age':[40]})
pd.concat([df1, df2])
# 	Name			Age
# 0	San Zhang	20
# 1	Si Li			30
# 0	Wu Wang		40

横向合并各表中的字段：

df2 = pd.DataFrame({'Grade':[80, 90]})
df3 = pd.DataFrame({'Gender':['M', 'F']})
pd.concat([df1, df2, df3], 1)
# 	Name			Age	Grade	Gender
# 0	San Zhang	20	80		M
# 1	Si Li			30	90		F

concat仍然是关于索引进行连接的。纵向拼接会根据列索引对齐，默认状态下join=outer，表示保留所有的列，并将不存在的值设为缺失；

join=inner，表示保留两个表都出现过的列。横向拼接则根据行索引进行对齐，join参数可以类似设置。

df2 = pd.DataFrame({'Name':['Wu Wang'], 'Gender':['M']})
pd.concat([df1, df2])
# 	Name			Age		Gender
# 0	San Zhang	20.0	NaN
# 1	Si Li			30.0	NaN
# 0	Wu Wang		NaN		M

df2 = pd.DataFrame({'Grade':[80, 90]}, index=[1, 2])
pd.concat([df1, df2], 1)
#		Name			Age	  Grade
# 0	San Zhang	20.0	NaN
# 1	Si Li			30.0	80.0
# 2	NaN				NaN		90.0

pd.concat([df1, df2], axis=1, join='inner')
# 	Name	Age	Grade
# 1	Si Li	30	80

因此，当确认要使用多表直接的方向合并时，尤其是横向的合并，可以先用reset_index方法恢复默认整数索引再进行合并，防止出现由索引的误对齐和重复索引的笛卡尔积带来的错误结果。

最后，keys参数的使用场景在于多个表合并后，用户仍然想要知道新表中的数据来自于哪个原表，这时可以通过keys参数产生多级索引进行标记。例如，第一个表中都是一班的同学，而第二个表中都是二班的同学，可以使用如下方式合并：

df1 = pd.DataFrame({'Name':['San Zhang','Si Li'], 'Age':[20,21]})
df2 = pd.DataFrame({'Name':['Wu Wang'],'Age':[21]})
pd.concat([df1, df2], keys=['one', 'two'])
# 			Name			Age
#	one	0	San Zhang	20
# 		1	Si Li			21
# two	0	Wu Wang		21

2. 序列与表的合并

利用concat可以实现多个表之间的方向拼接，如果想要把一个序列追加到表的行末或者列末，则可以分别使用append和assign方法。

在append中，如果原表是默认整数序列的索引，那么可以使用ignore_index=True对新序列对应索引的自动标号，否则必须对Series指定name属性。

s = pd.Series(['Wu Wang', 21], index = df1.columns)
df1.append(s, ignore_index=True)
# 	Name			Age
# 0	San Zhang	20
# 1	Si Li			21
# 2	Wu Wang		21

对于assign而言，虽然可以利用其添加新的列，但一般通过df['new_col'] = ...的形式就可以等价地添加新列。同时，使用[]修改的缺点是它会直接在原表上进行改动，而assign返回的是一个临时副本：

s = pd.Series([80, 90])
df1.assign(Grade=s)
# 	Name			Age	Grade
# 0	San Zhang	20	80
# 1	Si Li			21	90

df1['Grade'] = s
df1
# 	Name			Age	Grade
# 0	San Zhang	20	80
# 1	Si Li			21	90

三、类连接操作

除了上述介绍的若干连接函数之外，pandas中还设计了一些函数能够对两个表进行某些操作，这里把它们统称为类连接操作。

1. 比较

compare是在1.1.0后引入的新函数，它能够比较两个表或者序列的不同处并将其汇总展示：

df1 = pd.DataFrame({'Name':['San Zhang', 'Si Li', 'Wu Wang'],
                    'Age':[20, 21 ,21],
                    'Class':['one', 'two', 'three']})
df2 = pd.DataFrame({'Name':['San Zhang', 'Li Si', 'Wu Wang'],
                    'Age':[20, 21 ,21],
                    'Class':['one', 'two', 'Three']})
df1.compare(df2)
# 			   Name				Class
#   self	other	self	other
# 1	Si Li	Li Si	NaN		NaN
# 2	NaN		NaN	  three	Three

结果中返回了不同值所在的行列，如果相同则会被填充为缺失值NaN，其中other和self分别指代传入的参数表和被调用的表自身。

如果想要完整显示表中所有元素的比较情况，可以设置keep_shape=True：

df1.compare(df2, keep_shape=True)
#  				  Name         Age        Class       
#     self  other self other   self  other
# 0    NaN    NaN  NaN   NaN    NaN    NaN
# 1  Si Li  Li Si  NaN   NaN    NaN    NaN
# 2    NaN    NaN  NaN   NaN  three  Three

2. 组合

combine函数能够让两张表按照一定的规则进行组合，在进行规则比较时会自动进行列索引的对齐。对于传入的函数而言，每一次操作中输入的参数是来自两个表的同名Series，依次传入的列是两个表列名的并集，例如下面这个例子会依次传入A,B,C,D四组序列，每组为左右表的两个序列。同时，进行A列比较的时候，s1指代的就是一个全空的序列，因为它在被调用的表中并不存在，并且来自第一个表的序列索引会被reindex成两个索引的并集。具体的过程可以通过在传入的函数中插入适当的print方法查看。

下面的例子表示选出对应索引位置较小的元素：

def choose_min(s1, s2):
    s2 = s2.reindex_like(s1)
    res = s1.where(s1<s2, s2)
    res = res.mask(s1.isna()) # isna表示是否为缺失值，返回布尔序列
    return res
df1 = pd.DataFrame({'A':[1,2], 'B':[3,4], 'C':[5,6]})
df2 = pd.DataFrame({'B':[5,6], 'C':[7,8], 'D':[9,10]}, index=[1,2])
df1.combine(df2, choose_min)
# A    B    C   D
# 0 NaN  NaN  NaN NaN
# 1 NaN  4.0  6.0 NaN
# 2 NaN  NaN  NaN NaN

【练一练】

请在上述代码的基础上修改，保留df2中4个未被df1替换的相应位置原始值。

def choose_min(s1, s2):
    s2 = s2.reindex_like(s1)
    res = s1.where(s1<s2, s2)
#    res = res.mask(s1.isna()) # isna表示是否为缺失值，返回布尔序列
    return res
df1 = pd.DataFrame({'A':[1,2], 'B':[3,4], 'C':[5,6]})
df2 = pd.DataFrame({'B':[5,6], 'C':[7,8], 'D':[9,10]}, index=[1,2])
df1.combine(df2, choose_min)
# A    B    C     D
# 0 NaN  NaN  NaN   NaN
# 1 NaN  4.0  6.0   9.0
# 2 NaN  6.0  8.0  10.0

此外，设置overtwrite参数为False可以保留被调用表被调用表中未出现在传入的参数表中的列，而不会设置未缺失值：

# 	A 	B 	C 	D
# 0	1.0	NaN	NaN	NaN
# 1	2.0	4.0	6.0	9.0
# 2	NaN	6.0	8.0	10.0

【练一练】

除了combine之外，pandas中还有一个combine_first方法，其功能是在对两张表组合时，若第二张表中的值在第一张表中对应索引位置的值不是缺失状态，那么就使用第一张表的值填充。下面给出一个例子，请用combine函数完成相同的功能。

df1 = pd.DataFrame({'A':[1,2], 'B':[3,np.nan]})
df2 = pd.DataFrame({'A':[5,6], 'B':[7,8]}, index=[1,2])
df1.combine_first(df2)
# 	A		B
# 0	1.0	3.0
# 1	2.0	7.0
# 2	6.0	8.0