Pandas学习总结——5. 合并（append与assign、combine与update、concat、merge与join）
内容概览
- 1 append与assign
- 1.1append方法
- 1.2 assign方法
- 2 combine与update
- 2.1 combine方法
- 2.2 update方法
- 3 concat方法
- 4 merge与join
- 4.1 merge函数
- 4.2 join函数
- 5 问题与练习
- 5.1 问题
- 5.2 练习
- 练习一：公司员工信息
- 练习二：课程分数表
Pandas的合并操作可以概括为以下四类方法：
- append与assign
- combine与update
- concat方法
- merge与join
1 append与assign
1.1append方法
append方法主要在行操作
- 用Series添加行，必须指定name；
- 用DataFrame添加表。
# 用Series添加行
df_append = df.loc[:3,['Gender','Height']].copy()
s = pd.Series({'Gender':'F','Height':188},name='new_row')
df_append.append(s)
# 用DataFrame添加表
df_temp = pd.DataFrame({'Gender':['F','M'],'Height':[188,176]},index=['new_1','new_2'])
df_append.append(df_temp)
1.2 assign方法
assign方法主要在列操作。列名由参数指定，索引自动对齐。
# 新列名为 Letter
s = pd.Series(list('abcd'),index=range(4))
df_append.assign(Letter=s)
# 一次添加多列（新列名为col1、col2）
df_append.assign(col1=lambda x:x['Gender']*2, col2=s)
2 combine与update
comine和update都是用于表的填充函数，可以根据某种规则填充。
2.1 combine方法
（1）填充对象
combine方法是按照表的顺序轮流进行逐列循环的，而且自动索引对齐，缺失值为NaN。
df_combine_1 = df.loc[:1,['Gender','Height']].copy()
df_combine_2 = df.loc[10:11,['Gender','Height']].copy()
print(df_combine_1)
print(df_combine_2, '\n')
df_combine_1.combine(df_combine_2,lambda x,y:print(x,y))
运行结果：
0 M
1 F
10 NaN
11 NaN
Name: Gender, dtype: object 0 NaN
1 NaN
10 M
11 F
Name: Gender, dtype: object
0 173.0
1 192.0
10 NaN
11 NaN
Name: Height, dtype: float64 0 NaN
1 NaN
10 161.0
11 175.0
Name: Height, dtype: float64
由结果可以看出，combine的循环是按照下图所示的顺序进行的。
（2）例子
# 根据列均值的大小填充
df1 = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
df2 = pd.DataFrame({'A': [8, 7], 'B': [6, 5]})
df1.combine(df2,lambda x,y:x if x.mean()>y.mean() else y)
# 索引对齐特性（默认状态下，后面的表没有的行列都会设置为NaN）
df2 = pd.DataFrame({'B': [8, 7], 'C': [6, 5]},index=[1,2])
df1.combine(df2,lambda x,y:x if x.mean()>y.mean() else y)
# 使得df1原来符合条件的值不会被覆盖
df1.combine(df2,lambda x,y:x if x.mean()>y.mean() else y,overwrite=False)
# 在新增匹配df2的元素位置填充-1
df1.combine(df2,lambda x,y:x if x.mean()>y.mean() else y,fill_value=-1)
（3）combine_first方法
df1.combine_first(df2)
用df2填补df1的缺失值，功能比较简单，但比combine更常用。
2.2 update方法
（1）三个特点
- 返回的框索引只会与被调用框的一致
- 第二个框中的nan元素不会起作用
- 没有返回值，直接在df上操作
（2）例子
# 索引完全对齐的情况。df2 的 B 覆盖 df1 的 B
df1 = pd.DataFrame({'A': [1, 2, 3],
'B': [400, 500, 600]})
df2 = pd.DataFrame({'B': [4, 5, 6],
'C': [7, 8, 9]})
df1.update(df2)
# 部分填充（按索引填充）
df1 = pd.DataFrame({'A': ['a', 'b', 'c'],
'B': ['x', 'y', 'z']})
df2 = pd.DataFrame({'B': ['d', 'e']}, index=[1,2])
df1.update(df2)
# NaN值不填充，保留原来的值
df1 = pd.DataFrame({'A': [1, 2, 3],
'B': [400, 500, 600]})
df2 = pd.DataFrame({'B': [4, np.nan, 6]})
df1.update(df2)
3 concat方法
- 在行或列两个方向拼接，默认纵向（axis=0）
- 默认外连接（拼接方向的并集）
join='inner为内连接（拼接方向的交集）
df1 = pd.DataFrame({'A': ['A0', 'A1'],
'B': ['B0', 'B1']},
index = [0,1])
df2 = pd.DataFrame({'A': ['A2', 'A3'],
'B': ['B2', 'B3']},
index = [2,3])
df3 = pd.DataFrame({'A': ['A1', 'A3'],
'D': ['D1', 'D3'],
'E': ['E1', 'E3']},
index = [1,3])
# 默认状态拼接
pd.concat([df1,df2])
# axis=1时沿列方向拼接
pd.concat([df1,df2],axis=1)
# join设置为内连接（由于axis=0，因此列取交集）
pd.concat([df3,df1],join='inner')
# join设置为外链接
pd.concat([df3,df1],join='outer',sort=True) #sort设置列排序，默认为False
# verify_integrity检查列是否唯一
# 若 df6 的 index=['b'] 则会报错
df5 = pd.DataFrame([1], index=['a'])
df6 = pd.DataFrame([2], index=['b'])
pd.concat([df5, df6], axis=0, verify_integrity=True)
# 可以添加Series
s = pd.Series(['X0', 'X1'], name='X')
pd.concat([df1,s],axis=1)
# key参数用于对不同的数据框增加一个标号，便于索引
print(pd.concat([df1,df2], keys=['x', 'y']))
pd.concat([df1,df2], keys=['x', 'y']).index
4 merge与join
4.1 merge函数
- 将两个pandas对象横向合并，遇到重复的index时会使用笛卡尔积，默认
inner连接，可选left、outer、right连接。 - 左连接：以第一个表的index为基准，右边表的index不在左边则不加入，若在则用笛卡尔积方式加入。
- merge/join与concat的不同之处在于on参数，可以指定某一个对象为key来进行连接
（注：以下例子读者可以自行运行，并适当改变条件观察结果，以便理解。）
left = pd.DataFrame({'key1': ['K0', 'K0', 'K1', 'K2'],
'key2': ['K0', 'K1', 'K0', 'K1'],
'A': ['A0', 'A1', 'A2', 'A3'],
'B': ['B0', 'B1', 'B2', 'B3']})
right = pd.DataFrame({'key1': ['K0', 'K1', 'K1', 'K2'],
'key2': ['K0', 'K0', 'K0', 'K0'],
'C': ['C0', 'C1', 'C2', 'C3'],
'D': ['D0', 'D1', 'D2', 'D3']})
right2 = pd.DataFrame({'key1': ['K0', 'K1', 'K1', 'K2'],
'key2': ['K0', 'K0', 'K0', 'K0'],
'C': ['C0', 'C1', 'C2', 'C3']})
# key1 为准则连接。如果具有相同的列，则默认suffixes=('_x','_y')
pd.merge(left, right, on='key1')
# 以多组键连接
pd.merge(left, right, on=['key1','key2'])
# 默认使用inner连接。若使用out：
pd.merge(left, right, how='outer', on=['key1','key2'])
# 左连接
pd.merge(left, right, how='left', on=['key1', 'key2'])
# 右连接
pd.merge(left, right, how='right', on=['key1', 'key2'])
# validate检验的是到底哪一边出现了重复索引
# 如果是“one_to_one”则两侧索引都是唯一
# 如果"one_to_many"则左侧唯一
pd.merge(left, right, on='B', how='outer',validate='one_to_one')
# 这个例子可以尝试将 left 的 'B' 改为[2, 1]试试
# indicator参数指示了，合并后该行索引的来源
df1 = pd.DataFrame({'col1': [0, 1], 'col_left': ['a', 'b']})
df2 = pd.DataFrame({'col1': [1, 2, 2], 'col_right': [2, 2, 2]})
pd.merge(df1, df2, on='col1', how='outer', indicator=True)
#indicator='indicator_column'也是可以的
4.2 join函数
- join函数作用是将多个pandas对象横向拼接，遇到重复的索引项时会使用笛卡尔积
- 默认左连接，可选inner、outer、right连接。
- 对于
many_to_one模式下的合并，往往join更为方便
left = pd.DataFrame({'A': ['A0', 'A1', 'A2'],
'B': ['B0', 'B1', 'B2']},
index=['K0', 'K1', 'K2'])
right = pd.DataFrame({'C': ['C0', 'C2', 'C3'],
'D': ['D0', 'D2', 'D3']},
index=['K0', 'K2', 'K3'])
left.join(right)
也可以进行多层key拼接：
left = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
'B': ['B0', 'B1', 'B2', 'B3'],
'key1': ['K0', 'K0', 'K1', 'K2'],
'key2': ['K0', 'K1', 'K0', 'K1']})
index = pd.MultiIndex.from_tuples([('K0', 'K0'), ('K1', 'K0'),
('K2', 'K0'), ('K2', 'K1')],names=['key1','key2'])
right = pd.DataFrame({'C': ['C0', 'C1', 'C2', 'C3'],
'D': ['D0', 'D1', 'D2', 'D3']},
index=index)
left.join(right, on=['key1','key2'])
5 问题与练习
以下仅是本人的观点，如有不正确的地方，欢迎指正。
5.1 问题
（1）请思考什么是append/assign/combine/update/concat/merge/join各自最适合使用的场景，并举出相应的例子。
- append：可以利用Series或DataFrame添加行。例子可以见上文说明。
- assign：添加列。例子同上。
- combine：利用规则在表中填充另一个表的数据。同上。
- update：按索引来覆盖更新数据
- concat：行/列两个方向拼接两个表。
- merge：横向拼接（笛卡尔积方式），适用于多级索引的情况
- join：同上。
（2）merge_ordered和merge_asof的作用是什么？和merge是什么关系？
- merge_ordered：拼接类似时间序列数据等的有序数据
- merge_asof：类似于left join，但匹配的是最近的键而不是相等的键
（3）请构造一个多级索引与多级索引合并的例子，尝试使用不同的合并函数。
（4）上文提到了连接的笛卡尔积，那么当连接方式变化时（inner/outer/left/right），这种笛卡尔积规则会相应变化吗？请构造相应例子。
不会。分别改变how的值为inner/outer/left/right，可以发现key1：K1与key2：K0的笛卡尔积规则一样。但合并方式会有些不一样，具体表现参照上文所述例子。
left = pd.DataFrame({'key1': ['K0', 'K0', 'K1', 'K2'],
'key2': ['K0', 'K1', 'K0', 'K1'],
'A': ['A0', 'A1', 'A2', 'A3'],
'B': ['B0', 'B1', 'B2', 'B3']})
right = pd.DataFrame({'key1': ['K0', 'K1', 'K1', 'K2'],
'key2': ['K0', 'K0', 'K0', 'K0'],
'C': ['C0', 'C1', 'C2', 'C3'],
'D': ['D0', 'D1', 'D2', 'D3']})
print(left, '\n')
print(right, '\n')
print(pd.merge(left, right, how='right', on=['key1', 'key2']))
5.2 练习
练习一：公司员工信息
有2张公司的员工信息表，每个公司共有16名员工，共有五个公司，请解决如下问题：
(a) 每个公司有多少员工满足如下条件：既出现第一张表，又出现在第二张表。
# a 答案
E1 = pd.read_csv('data/Employee1.csv')
E2 = pd.read_csv('data/Employee2.csv')
Name = []
for name in E1['Name']:
if name in list(E2['Name']):
Name.append(name)
Name
['a1',
'a3',
'a6',
'b1',
'b3',
'b7',
'b15',
'c3',
'c10',
'c12',
'c13',
'd5',
'd10',
'e8',
'e10',
'e11']
(b) 将所有不符合(a)中条件的行筛选出来，合并为一张新表，列名与原表一致。
# b 答案
E1_b = E1[~E1['Name'].isin(Name)]
E2_b = E2[~E2['Name'].isin(Name)]
E_b = pd.concat([E1_b, E2_b], axis=0)
E_b.head()
© 现在需要编制所有80位员工的信息表，对于(b)中的员工要求不变，对于满足(a)条件员工，它们在某个指标的数值，取偏离它所属公司中满足(b)员工的均值数较小的哪一个，例如：P公司在两张表的交集为{p1}，并集扣除交集为{p2,p3,p4}，那么如果后者集合的工资均值为1万元，且p1在表1的工资为13000元，在表2的工资为9000元，那么应该最后取9000元作为p1的工资，最后对于没有信息的员工，利用缺失值填充。
练习二：课程分数表
有2张课程的分数表（分数随机生成），但专业课（学科基础课、专业必修课、专业选修课）与其他课程混在一起，请解决如下问题：
(a) 将两张表分别拆分为专业课与非专业课（结果为四张表）。
# a 答案
C1 = pd.read_csv('data/Course1.csv')
C2 = pd.read_csv('data/Course2.csv')
# query用法参考索引 https://blog.csdn.net/KF_Guan/article/details/105804854
C1_1 = C1.query('课程类别 in ["学科基础课","专业必修课","专业选修课"]')
C1_2 = C1.query('课程类别 not in ["学科基础课","专业必修课","专业选修课"]')
C2_1 = C2.query('课程类别 in ["学科基础课","专业必修课","专业选修课"]')
C2_2 = C2.query('课程类别 not in ["学科基础课","专业必修课","专业选修课"]')
display(C1_1.head(1))
display(C1_2.head(1))
display(C2_1.head(1))
display(C2_2.head(1))
(b) 将两张专业课的分数表和两张非专业课的分数表分别合并。
# b 答案
zhuanyeke = pd.concat([C1_1, C2_1])
feizhuanyeke = pd.concat([C1_2, C2_2])
© 不使用(a)中的步骤，请直接读取两张表合并后拆分。
# c 答案
all_ = pd.concat([C1, C2])
zhuanyeke2 = all_.query('课程类别 in ["学科基础课","专业必修课","专业选修课"]')
feizhuanyeke2 = all_.query('课程类别 not in ["学科基础课","专业必修课","专业选修课"]')
(d) 专业课程中有缺失值吗，如果有的话请在完成(3)的同时，用组内（3种类型的专业课）均值填充缺失值后拆分。
# d 答案
print(all_.isnull().sum(), '\n')
all_['分数'] = all_.groupby('课程类别').transform(lambda x: x.fillna(x.mean()))['分数']
print(all_.isnull().sum())
zhuanyeke3 = all_.query('课程类别 in ["学科基础课","专业必修课","专业选修课"]')
feizhuanyeke3 = all_.query('课程类别 not in ["学科基础课","专业必修课","专业选修课"]')
如果您觉得文章对您有用，请给我点个赞吧！
您的肯定是对我最大的鼓励。