编程实践（Pandas）Task06

一、关系型连接

1. 连接的基本概念

把两张相关的表按照某一个或某一组键连接起来是一种常见操作，在关系型连接中， 键 是十分重要的，往往用 on 参数表示。另一个重要的要素是连接的形式。在 pandas 中的关系型连接函数 merge 和 join 中提供了 how 参数来代表连接形式，分为左连接 left 、右连接 right 、内连接 inner 、外连接 outer 。

2. 值连接

两张表可以根据某一列的值来连接，还可以通过几列值的组合进行连接，这种基于值的连接在 pandas 中可以由 merge 函数实现

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.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 连接，第一个是指左右表的键都是唯一的，后面两个分别指左表键唯一和右表键唯一。

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

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.join(df2)

					Age	Gender
Name		Class		
San Zhang	one		20	M
			two		21	F

二、方向连接

1. concat

前面介绍了关系型连接，其中最重要的参数是 on 和 how ，但有时候用户并不关心以哪一列为键来合并，只是希望把两个表或者多个表按照纵向或者横向拼接，为这种需求， pandas 中提供了 concat 函数来实现。

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

# 纵向合并各表中人的信息：
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

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

虽然说 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

# join=inner ，表示保留两个表都出现过的列。
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

序列与表的合并

利用 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 返回的是一个临时副本：

# df1并没有改变
s = pd.Series([80, 90])
df1.assign(Grade=s)

	Name		Age	Grade
0	San Zhang	20	80
1	Si Li		21	90

# df1发生改变
df1['Grade'] = s
df1

	Name		Age	Grade
0	San Zhang	20	80
1	Si Li		21	90

三、练一练

练一练1

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

df2 = pd.DataFrame({'Name':['San Zhang', 'San Zhang', 'San Zhang'],
                    'Grade':[90, 80, 85],
                    'Class':['two', 'one', 'one']})

df2

	Name	Grade	Class
0	San Zhang	90	two
1	San Zhang	80	one
2	San Zhang	85	one

df1.merge(df2, on = ['Name', 'Class'], how = 'left', validate='1:m')

	Name	Age	Class	Grade
0	San Zhang	20	one	80
1	San Zhang	20	one	85
2	San Zhang	21	two	90

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

参考文献

1. https://blog.youkuaiyun.com/tcy23456/article/details/85494615