【12月DW打卡】joyful-pandas - 06 - joyful-pands - pandas连接（join、concat、compare连接、combine连接）
作者：互联网
第六章 pandas连接
小结
- 原文指路：joyful-pandas
- jupyter nbconvert --to markdown E:\PycharmProjects\TianChiProject\00_山枫叶纷飞\competitions\008_joyful-pandas\06_pandas连接.ipynb
import numpy as np
import pandas as pd
1. 连接的基本概念 (说白了就是SQL的join)
在 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']})
# 实现left join
left_df = df1.merge(df2, on='Name', how='left')
left_df
| 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 连接，第一个是指左右表的键都是唯一的，后面两个分别指左表键唯一和右表键唯一。
练一练
上面以多列为键的例子中，错误写法显然是一种多对多连接，而正确写法是一对一连接，请修改原表，使得以多列为键的正确写法能够通过 validate='1:m' 的检验，但不能通过 validate='m:1' 的检验。
# 错误的写法
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 |
# 加 validate='1:1' 的检验的写法
try:
df1.merge(df2, on='Name', how='left', validate='1:1')
except Exception as e:
print(e)
Merge keys are not unique in either left or right dataset; not a one-to-one merge
df1.merge(df2, on=['Name', 'Class'], how='left', validate='1:m')
不用修改原表，使得以多列为键的正确写法能够通过`validate='1:m'`的检验
print('不用修改原表，使得以多列为键的正确写法能够通过`validate=\'1:m\'`的检验')
3. 索引连接
所谓索引连接，就是把索引当作键，因此这和值连接本质上没有区别，pandas中利用join函数来处理索引连接，它的参数选择要少于merge，除了必须的on和how之外，可以对重复的列指定左右后缀lsuffix和rsuffix。其中，on参数指索引名，单层索引时省略参数表示按照当前索引连接。
如果想要进行类似于merge中以多列为键的操作的时候，join需要使用多级索引。
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 |
仿照第2小节的例子，写出语文和数学分数合并的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, on='Name', how='left', lsuffix='_Chinese', rsuffix='_Math')
| Grade_Chinese | Grade_Math | |
|---|---|---|
| Name | ||
| San Zhang | 70 | 80 |
二、方向连接
1. concat
前面介绍了关系型连接，其中最重要的参数是on和how，但有时候用户并不关心以哪一列为键来合并，只是希望把两个表或者多个表按照纵向或者横向拼接，为这种需求，pandas中提供了concat函数来实现。
在concat中，最常用的有三个参数，它们是axis, join, keys，分别表示拼接方向，连接形式，以及在新表中指示来自于哪一张旧表的名字。这里需要特别注意，join和keys与之前提到的join函数和键的概念没有任何关系。
在默认状态下的axis=0，表示纵向拼接多个表，常常用于同特征的多个样本的直接拼接；而axis=1表示横向拼接多个表，常用于多个字段或特征的拼接。
concat仍然是关于索引进行连接的。
纵向拼接会根据列索引对齐，默认状态下join=outer，表示保留所有的列，并将不存在的值设为缺失；join=inner，表示保留两个表都出现过的列。横向拼接则根据行索引对齐，join参数可以类似设置。
df1 = pd.DataFrame({'Name':['San Zhang','Si Li'], 'Age':[20,30]})
df1
| Name | Age | |
|---|---|---|
| 0 | San Zhang | 20 |
| 1 | Si Li | 30 |
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属性。
df1
| Name | Age | |
|---|---|---|
| 0 | San Zhang | 20 |
| 1 | Si Li | 21 |
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([666, 999])
df1.assign(Grade=s)
| Name | Age | Grade | |
|---|---|---|---|
| 0 | San Zhang | 20 | 666 |
| 1 | Si Li | 21 | 999 |
三、类连接操作
除了上述介绍的若干连接函数之外，pandas中还设计了一些函数能够对两个表进行某些操作，这里把它们统称为类连接操作。
1. 比较 compare
compare是在1.1.0后引入的新函数，它能够比较两个表或者序列的不同处并将其汇总展示：
结果中返回了不同值所在的行列，如果相同则会被填充为缺失值NaN，其中other和self分别指代传入的参数表和被调用的表自身。
如果想要完整显示表中所有元素的比较情况，可以设置keep_shape=True：
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 |
如果想要完整显示表中所有元素的比较情况，可以设置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) # #返回一个同样shape的df，当满足条件为TRUE时，从本身返回结果，否则从返回其他df的结果 (也就是条件不符合再进行替换)
# print('res,:\n', res)
# print('s1.isna():\n', s1.isna())
res = res.mask(s1.isna()) # isna表示是否为缺失值，返回布尔序列; mask是条件符合进行替换
print(res)
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)
0 NaN
1 NaN
2 NaN
Name: A, dtype: float64
0 NaN
1 4.0
2 NaN
Name: B, dtype: float64
0 NaN
1 6.0
2 NaN
Name: C, 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 |
【练一练】
请在上述代码的基础上修改，保留df2中4个未被df1替换的相应位置原始值。
def choose_min_plus(s1, s2):
s2 = s2.reindex_like(s1)
res = s1.where(s1<s2, s2) # #返回一个同样shape的df，当满足条件为TRUE时，从本身返回结果，否则从返回其他df的结果 (也就是条件不符合再进行替换)
# print('res,:\n', res)
# print('s1.isna():\n', s1.isna())
res = res.mask(s1.isna(), s2) # isna表示是否为缺失值，返回布尔序列; mask是条件符合进行替换
# print(res)
return res
df1 = pd.DataFrame({'A':[1,2], 'B':[3,4], 'C':[5,6]}) # index=[0,1]
df2 = pd.DataFrame( {'B':[5,6], 'C':[7,8], 'D':[9,10]}, index=[1,2])
df1.combine(df2, choose_min_plus)
| 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可以保留\(\color{red}{被调用表}\)中未出现在传入的参数表中的列，而不会设置未缺失值：
df1.combine(df2, choose_min, overwrite=False)
0 NaN
1 4.0
2 NaN
Name: B, dtype: float64
0 NaN
1 6.0
2 NaN
Name: C, dtype: float64
0 NaN
1 NaN
2 NaN
Name: D, dtype: float64
| A | B | C | D | |
|---|---|---|---|---|
| 0 | 1.0 | NaN | NaN | NaN |
| 1 | 2.0 | 4.0 | 6.0 | NaN |
| 2 | NaN | NaN | NaN | NaN |
【练一练】
除了combine之外，pandas中还有一个combine_first方法，其功能是在对两张表组合时，若第二张表中的值在第一张表中对应索引位置的值不是缺失状态，那么就使用第一张表的值填充。下面给出一个例子，请用combine函数完成相同的功能。
【END】
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 |
print('用`combine`函数完成相同的功能')
def choose_plus_ultra(s1, s2):
s2 = s2.reindex_like(s1) # index: [1,2] => [0,1,2]
print(s2)
# res = s1.where(s1<s2, s2) # #返回一个同样shape的df，当满足条件为TRUE时，从本身返回结果，否则从返回其他df的结果 (也就是条件不符合再进行替换)
# print('res,:\n', res)
# print('s1.isna():\n', s1.isna())
res = s1.mask(s1.isna(), s2) # isna表示是否为缺失值，返回布尔序列; mask是条件符合进行替换
# print(res)
return res
df1 = pd.DataFrame({'A':[1,2], 'B':[3,4], 'C':[5,6]}) # index=[0,1]
df2 = pd.DataFrame( {'B':[5,6], 'C':[7,8], 'D':[9,10]}, index=[1,2])
df1.combine(df2, choose_plus_ultra)
用`combine`函数完成相同的功能
0 NaN
1 NaN
2 NaN
Name: A, dtype: float64
0 NaN
1 5.0
2 6.0
Name: B, dtype: float64
0 NaN
1 7.0
2 8.0
Name: C, dtype: float64
0 NaN
1 9.0
2 10.0
Name: D, dtype: float64
| A | B | C | D | |
|---|---|---|---|---|
| 0 | 1.0 | 3.0 | 5.0 | NaN |
| 1 | 2.0 | 4.0 | 6.0 | 9.0 |
| 2 | NaN | 6.0 | 8.0 | 10.0 |
四、练习
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']
dfs=[]
for a_date in date:
one_df = pd.read_csv('E:\\PycharmProjects\\DatawhaleChina\\joyful-pandas\\data\\us_report\\{}.csv'.format(str(a_date)))
dfs.append(one_df)
one_df['Last_Update'] = a_date
batch_df = pd.concat(dfs)
batch_df.columns
Index(['Province_State', 'Country_Region', 'Last_Update', 'Lat', 'Long_',
'Confirmed', 'Deaths', 'Recovered', 'Active', 'FIPS', 'Incident_Rate',
'People_Tested', 'People_Hospitalized', 'Mortality_Rate', 'UID', 'ISO3',
'Testing_Rate', 'Hospitalization_Rate', 'Total_Test_Results',
'Case_Fatality_Ratio'],
dtype='object')
batch_df.set_index('Last_Update', inplace=True)
end_df = batch_df[batch_df['Province_State']=='New York'][['Confirmed', 'Deaths', 'Recovered', "Active"]]
end_df.tail()
| Confirmed | Deaths | Recovered | Active | |
|---|---|---|---|---|
| Last_Update | ||||
| 11-12-2020 | 545762 | 33975 | 81198.0 | 430589.0 |
| 11-13-2020 | 551163 | 33993 | 81390.0 | 435780.0 |
| 11-14-2020 | 556551 | 34010 | 81585.0 | 440956.0 |
| 11-15-2020 | 560200 | 34032 | 81788.0 | 444380.0 |
| 11-16-2020 | 563690 | 34054 | 81908.0 | 447728.0 |
Ex2：实现join函数
请实现带有how参数的join函数
- 假设连接的两表无公共列
- 调用方式为
join(df1, df2, how="left") - 给出测试样例
df1 = pd.DataFrame({'A':[1,2], 'B':[3,4], 'C':[5,6]}, index=[0,1]) # index=[0,1]
df2 = pd.DataFrame({'D':[5,6], 'E':[7,8], 'F':[9,10]}, index=[1,2])
print('标准')
df1.join(df2, how="left")
标准
| A | B | C | D | E | F | |
|---|---|---|---|---|---|---|
| 0 | 1 | 3 | 5 | NaN | NaN | NaN |
| 1 | 2 | 4 | 6 | 5.0 | 7.0 | 9.0 |
个人设想的思路
- how有多类参数,如left/right/inner/outer等
标签：Name,NaN,df1,pandas,joyful,pd,df2,连接,San 来源： https://www.cnblogs.com/zhazhaacmer/p/14208951.html