import numpy as np
import pandas as pd
一、关系型连接
1. 连接的基本概念
把两张相关的表按照某一个或某一组键连接起来是一种常见操作，例如学生期末考试各个科目的成绩表按照 姓名 和 班级 连接成总的成绩表，又例如对企业员工的各类信息表按照 员工ID号 进行连接汇总。由此可以看出，在关系型连接中， 键 是十分重要的，往往用 on 参数表示。
另一个重要的要素是连接的形式。在 pandas 中的关系型连接函数 merge 和 join 中提供了 how 参数来代表连接形式，分为左连接 left 、右连接 right 、内连接 inner 、外连接 outer ，它们的区别可以用如下示意图表示：
从图中可以看到，所谓左连接即以左边的键为准，如果右边表中的键于左边存在，那么就添加到左边，否则则处理为缺失值，右连接类似处理。内连接只负责合并两边同时出现的键，而外连接则会在内连接的基础上包含只在左边出现以及只在右边出现的值，因此外连接又叫全连接。
上面这个简单的例子中，同一个表中的键没有出现重复的情况，那么如果出现重复的键应该如何处理？只需把握一个原则，即只要两边同时出现的值，就以笛卡尔积的方式加入，如果单边出现则根据连接形式进行处理。其中，关于笛卡尔积可用如下例子说明：设左表中键 张三 出现两次，右表中的 张三 也出现两次，那么逐个进行匹配，最后产生的表必然包含 2*2 个姓名为 张三 的行。下面是一个对应例子的示意图：
显然在不同的场合应该使用不同的连接形式。其中左连接和右连接是等价的，由于它们的结果中的键是被一侧的表确定的，因此常常用于有方向性地添加到目标表。内外连接两侧的表，经常是地位类似的，想取出键的交集或者并集，具体的操作还需要业务的需求来判断。
2. 值连接
在上面示意图中的例子中，两张表根据某一列的值来连接，事实上还可以通过几列值的组合进行连接，这种基于值的连接在 pandas 中可以由 merge 函数实现，例如第一张图的左连接：
如果两个表中想要连接的列不具备相同的列名，可以通过left_on和right_on指定：
如果两个表中的列出现了重复的列名，那么可以通过suffixes参数指定。例如合并考试成绩的时候，第一个表记录了语文成绩，第二个是数学成绩：
在某些时候出现重复元素是麻烦的，例如两位同学来自不同的班级，但是姓名相同，这种时候就要指定on参数为多个列使得正确连接：
从上面的例子来看，在进行基于唯一性的连接下，如果键不是唯一的，那么结果就会产生问题。举例中的行数很少，但如果实际数据中有几十万到上百万行的进行合并时，如果想要保证唯一性，除了用duplicated检查是否重复外，merge中也提供了validate参数来检查连接的唯一性模式。这里共有三种模式，即一对一连接1:1，一对多连接1:m，多对一连接m:1连接，第一个是指左右表的键都是唯一的，后面两个分别指左表键唯一和右表键唯一。
【练一练1】
上面以多列为键的例子中，错误写法显然是一种多对多连接，而正确写法是一对一连接，请修改原表，使得以多列为键的正确写法能够通过validate='1:m'的检验，但不能通过validate='m:1'的检验。
【解答】
df1 = pd.DataFrame({'Name':['San Zhang', 'San Zhang'],
'Age':[20, 21],
'Class':['one', 'two']})
df2 = pd.DataFrame({'Name':['San Zhang', 'San Zhang','San Zhang'],
'Gender':['F', 'M','F'],
'Class':['two', 'one','one']})
df1.merge(df2, on=['Name', 'Class'], how='left',validate='1:m') #不报错
df1.merge(df2, on=['Name', 'Class'], how='left',validate='m:1') #报错
【END】
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')
仿照第2小节的例子，写出语文和数学分数合并的join版本(merge中的suffix参数直接传入[‘A’,‘B’])：
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')
如果想要进行类似于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')))
print(df1)
print(df2)
df1.join(df2)
二、方向连接
1. concat
前面介绍了关系型连接，其中最重要的参数是on和how，但有时候用户并不关心以哪一列为键来合并，只是希望把两个表或者多个表按照纵向或者横向拼接，为这种需求，pandas中提供了concat函数来实现。
在concat中，最常用的有三个参数，它们是axis, join, keys，分别表示拼接方向，连接形式，以及在新表中指示来自于哪一张旧表的名字。这里需要特别注意，join和keys与之前提到的join函数和键的概念没有任何关系。
在默认状态下的axis=0，表示纵向拼接多个表，常常用于多个样本的拼接；而axis=1表示横向拼接多个表，常用于多个字段或特征的拼接。
例如，纵向合并各表中人的信息：
横向合并各表中的字段：
虽然说concat是处理关系型合并的函数，但是它仍然是关于索引进行连接的。纵向拼接会根据列索引对其，默认状态下join=outer，表示保留所有的列，并将不存在的值设为缺失；join=inner，表示保留两个表都出现过的列。横向拼接则根据行索引对齐，join参数可以类似设置。
因此，当确认要使用多表直接的方向合并时，尤其是横向的合并，可以先用reset_index方法恢复默认整数索引再进行合并，防止出现由索引的误对齐和重复索引的笛卡尔积带来的错误结果。
最后，keys参数的使用场景在于多个表合并后，用户仍然想要知道新表中的数据来自于哪个原表，这时可以通过keys参数产生多级索引进行标记。例如，第一个表中都是一班的同学，而第二个表中都是二班的同学，可以使用如下方式合并：
2. 序列与表的合并
利用concat可以实现多个表之间的方向拼接，如果想要把一个序列追加到表的行末或者列末，则可以分别使用append和assign方法。
在append中，如果原表是默认整数序列的索引，那么可以使用ignore_index=True对新序列对应索引的自动标号，否则必须对Series指定name属性。
可以看到，Series的name属性值是合并后的index，所以不使用ignore_index=True，也不指定name属性就会报错。
对于assign而言，虽然可以利用其添加新的列，但一般通过df['new_col'] = ...的形式就可以等价地添加新列。同时，使用[]修改的缺点是它会直接在原表上进行改动，而assign返回的是一个临时副本：
三、类连接操作
除了上述介绍的若干连接函数之外，pandas中还设计了一些函数能够对两个表进行某些操作，这里把它们统称为类连接操作。
1. 比较
compare是在1.1.0后引入的新函数，它能够比较两个表或者序列的不同处并将其汇总展示：
结果中返回了不同值所在的行列，如果相同则会被填充为缺失值NaN，其中other和self分别指代传入的参数表和被调用的表自身。
如果想要完整显示表中所有元素的比较情况，可以设置keep_shape=True：
2. 组合
combine函数能够让两张表按照一定的规则进行组合，在进行规则比较时会自动进行列索引的对齐。对于传入的函数而言，每一次操作中输入的参数是来自两个表的同名Series，依次传入的列是两个表列名的并集，例如下面这个例子会依次传入A,B,C,D四组序列，每组为左右表的两个序列。同时，进行A列比较的时候，s2指代的就是一个全空的序列，因为它在被调用的表中并不存在，并且来自第一个表的序列索引会被reindex成两个索引的并集。具体的过程可以通过在传入的函数中插入适当的print方法查看。
下面的例子表示选出对应索引位置较小的元素：
def choose_min(s1, s2):
print('reindex之前')
print(s1)
print(s2)
s2 = s2.reindex_like(s1)
print('reindex之后')
print(s2)
res = s1.where(s1<s2, s2)
res = res.mask(s1.isna())# isna表示是否为缺失值，返回布尔序列
print(res)
print('------------')
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)
reindex之前
0 1.0
1 2.0
2 NaN
Name: A, dtype: float64
0 NaN
1 NaN
2 NaN
Name: A, dtype: float64
reindex之后
0 NaN
1 NaN
2 NaN
Name: A, dtype: float64
0 NaN
1 NaN
2 NaN
Name: A, dtype: float64
------------
reindex之前
0 3.0
1 4.0
2 NaN
Name: B, dtype: float64
0 NaN
1 5.0
2 6.0
Name: B, dtype: float64
reindex之后
0 NaN
1 5.0
2 6.0
Name: B, dtype: float64
0 NaN
1 4.0
2 NaN
Name: B, dtype: float64
------------
reindex之前
0 5.0
1 6.0
2 NaN
Name: C, dtype: float64
0 NaN
1 7.0
2 8.0
Name: C, dtype: float64
reindex之后
0 NaN
1 7.0
2 8.0
Name: C, dtype: float64
0 NaN
1 6.0
2 NaN
Name: C, dtype: float64
------------
reindex之前
0 NaN
1 NaN
2 NaN
Name: D, dtype: float64
0 NaN
1 9.0
2 10.0
Name: D, dtype: float64
reindex之后
0 NaN
1 9.0
2 10.0
Name: D, dtype: float64
0 NaN
1 NaN
2 NaN
Name: D, dtype: float64
------------
A B C D
0 NaN NaN NaN NaN
1 NaN 4.0 6.0 NaN
2 NaN NaN NaN NaN
【练一练2】
请在上述代码的基础上修改，保留df2中4个未被df1替换的相应位置原始值。
【解答】
def choose_df2(s1, s2):
s2 = s2.reindex_like(s1)
res = s1.where(s1<s2, s2)
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_df2)
将例子中的res = res.mask(s1.isna()删掉便可
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
【END】
此外，设置overtwrite参数为False可以保留被调用表被调用表中未出现在传入的参数表中的列，而不会设置未缺失值：
【练一练3】
除了combine之外，pandas中还有一个combine_first方法，其功能是在对两张表组合时，若第二张表中的值在第一张表中对应索引位置的值不是缺失状态，那么就使用第一张表的值填充。下面给出一个例子，请用combine函数完成相同的功能。
【解答】
【END】
四、练习
Ex1：美国疫情数据集
现有美国4月12日至11月16日的疫情报表，请将New York的Confirmed, Deaths, Recovered, Active合并为一张表，索引为按如下方法生成的日期字符串序列：
date = pd.date_range('20200412', '20201116').to_series()
date = date.dt.month.astype('string').str.zfill(2) +'-'+ date.dt.day.astype('string').str.zfill(2) +'-'+ '2020'
date = date.tolist()
date[:5]
['04-12-2020', '04-13-2020', '04-14-2020', '04-15-2020', '04-16-2020']
list1=[]
for d in date:
df = pd.read_csv('../data/us_report/' + d + '.csv', index_col='Province_State')
data = df.loc['New York',['Confirmed', 'Deaths', 'Recovered', 'Active']]
list1.append(pd.DataFrame(data).T)
df_all = pd.concat(list1)
df_all = df_all.reset_index().rename(columns={'index':'City'})
df_all.index=pd.Series(date)
df_all
City Confirmed Deaths Recovered Active
04-12-2020 New York 189033 9385 23887 179648
04-13-2020 New York 195749 10058 23887 185691
04-14-2020 New York 203020 10842 23887 192178
04-15-2020 New York 214454 11617 23887 202837
04-16-2020 New York 223691 14832 23887 208859
... ... ... ... ... ...
11-12-2020 New York 545762 33975 81198 430589
11-13-2020 New York 551163 33993 81390 435780
11-14-2020 New York 556551 34010 81585 440956
11-15-2020 New York 560200 34032 81788 444380
11-16-2020 New York 563690 34054 81908 447728
219 rows × 5 columns
Ex2：实现join函数
请实现带有how参数的join函数
- 假设连接的两表无公共列
- 调用方式为
join(df1, df2, how="left") - 给出测试样例
def join(df1, df2, how='left'):
res_col = df1.columns.tolist() + df2.columns.tolist()
dup = df1.index.unique().intersection(df2.index.unique())
res_df = pd.DataFrame(columns = res_col)
for label in dup:
cartesian=[]
if isinstance(df1.loc[label], pd.DataFrame)&isinstance(df2.loc[label], pd.Series):
for i in df1.loc[label].values:
for j in df2.loc[label].values:
cartesian.append([*i]+[j])
if isinstance(df2.loc[label], pd.DataFrame)&isinstance(df1.loc[label], pd.Series):
for i in df1.loc[label].to_frame().T.values:
for j in df2.loc[label].values:
cartesian.append([*i]+[*j])
if isinstance(df2.loc[label], pd.DataFrame)&isinstance(df1.loc[label], pd.DataFrame):
for i in df1.loc[label].values:
for j in df2.loc[label].values:
cartesian.append([*i]+[*j])
if isinstance(df1.loc[label], pd.Series)&isinstance(df2.loc[label], pd.Series):
for i in df1.loc[label].to_frame().T.values:
for j in df2.loc[label].to_frame().T.values:
cartesian.append([*i]+[*j])
dup_df = pd.DataFrame(cartesian, index = [label]*len(cartesian), columns = res_col)
res_df = pd.concat([res_df,dup_df])
if how in ['left', 'outer']:
for label in df1.index.unique().difference(dup):
if isinstance(df1.loc[label], pd.DataFrame):
cat = []
for i in df1.loc[label].values:
cat.append(list(i)+[np.nan]*df2.shape[1])
else:
cat=[]
for i in df1.loc[label].to_frame().T.values:
cat.append(list(i)+[np.nan]*df2.shape[1])
dup_df = pd.DataFrame(cat, index = [label]*len(cat), columns = res_col)
res_df = pd.concat([res_df,dup_df])
if how in ['right', 'outer']:
for label in df2.index.unique().difference(dup):
if isinstance(df2.loc[label], pd.DataFrame):
cat = []
for i in df2.loc[label].values:
cat.append([np.nan]*df1.shape[1]+list(i))
else:
cat=[]
for i in df2.loc[label].to_frame().T.values:
cat.append([np.nan]*df1.shape[1]+list(i))
dup_df = pd.DataFrame(cat, index = [label]*len(cat), columns = res_col)
res_df = pd.concat([res_df,dup_df])
return res_df.rename_axis(index={None:df1.index.name})
测试1:
df1 = pd.DataFrame({'Age':[20,'30',40],'home':['beijing','shanghai','wuhan']},index=pd.Series(['San Zhang','Si Li','mara'],name='Name'))
print(df1)
df2 = pd.DataFrame({'Gender':['Fh','M','M']},index=pd.Series(['Si Li','San Zhang','lafa'],name='Name'))
print(df2)
print(join(df1,df2,'right'))
Age home
Name
San Zhang 20 beijing
Si Li 30 shanghai
mara 40 wuhan
Gender
Name
Si Li Fh
San Zhang M
lafa M
Age home Gender
Name
San Zhang 20 beijing M
Si Li 30 shanghai Fh
lafa NaN NaN M
测试2:
df1 = pd.DataFrame({'col1':[0,1,2,3,4,5],'col3':list('567898')}, index=list('AABCDD'))
print(df1)
df2 = pd.DataFrame({'col2':list('opqrst')}, index=list('ABBCEE'))
print(df2)
print(join(df1,df2,'right'))
col1 col3
A 0 5
A 1 6
B 2 7
C 3 8
D 4 9
D 5 8
col2
A o
B p
B q
C r
E s
E t
col1 col3 col2
A 0 5 o
A 1 6 o
B 2 7 p
B 2 7 q
C 3 8 r
E NaN NaN s
E NaN NaN t
参考答案只支持单列合并，在参考答案的基础做了修改可以适合两个不重复多列合并。
思路：
1.首先先计算出inner,在计算出left、right,最后计算出outer。outer其实是inner+left+right。
2.利用索引运算法则(交集和差集),与1中的思路类比,inner就是交集。left就是df1.index-df2.index。
3.注意loc取出来的可能是Series或者DataFrame。若取出的是DataFrame则很好办,直接利用循环就可以一层一层取出来(可以利用列表推导式)。Series则有点麻烦，我的思路是变成DataFrame(这里要转置一下！！)也能直接一层一层取出来～。
所以计算inner时就有四个组合。逐一考虑就行～
left和right只有两种情况,因为nan是自己构建的～
五、总结
1.两个关系型连接
merge()：重要参数(on(可传入列表,根据什么连),how(怎么连？),suffix,validate(检验连接的唯一性))
join():(how(怎么连),on(根据什么连),lsuffix(),rsuffix())
联系：merge包含了join操作，支持两个df间列方向的拼接操作，join只是简化了merge的列拼接的操作(参数少一些，默认左连接)
2.方向连接
concat()：可以传入列表达到多个合并的效果，axis=0时上下合并，axis=1时左右合并。
join参数表示连接形式，keys参数指示来自于哪张旧表。
append()在行末添加，不使用 ignore_index=True 的时候要对 Series 指定 name 属性。
assign()在列末添加，与使用 [] 原地修改不同的是，这个返回一个副本。
3.类连接操作
compare():(形式为df1.compare(df2)，返回了不同值所在的行列，如果相同则会被填充为缺失值 NaN ，其中 other 和 self 分别指代传入的参数表和被调用的表自身)
combine():(让两张表按照一定的规则进行组合，在进行规则比较时会自动进行列索引的对齐。对于传入的函数而言,按并集的列索引，每次传入两个序列。overtwrite 参数为 False 可以保留 被调用表 中未出现在传入的参数表中的列，而不会设置未缺失值)
combine_first():(功能是在对两张表组合时，若第二张表中的值在第一张表中对应索引位置的值不是缺失状态，那么就使用第一张表的值填充,可以看成combine的特例)
1180
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
