pandas第五章——合并

最新推荐文章于 2021-04-21 00:53:49 发布

陈述c

最新推荐文章于 2021-04-21 00:53:49 发布

阅读量191

点赞数

本文链接：https://blog.csdn.net/weixin_44617944/article/details/109074892

版权

一、append和assign

append方法

主要用于添加行

利用Series添加

df_append = df.loc[:3,['Gender','Height']].copy()

  Gender  Height
0      M     173
1      F     192
2      M     186
3      F     167

s=pd.Series({'Gender':'F','Height':188},name='4')
print(df_append.append(s))

  Gender  Height
0      M     173
1      F     192
2      M     186
3      F     167
4      F     188

利用Dataframe添加

df_temp = pd.DataFrame({'Gender':['F','M'],'Height':[188,176]},index=['4','5'])
print(df_append.append(df_temp))

  Gender  Height
0      M     173
1      F     192
2      M     186
3      F     167
4      F     188
5      M     176

assign方法

主要用于添加列，列名由assign中的参数指定

添加单列

s = pd.Series(list('abcd'),index=range(4))
print(df_append.assign(Letter=s))

  Gender  Height Letter
0      M     173      a
1      F     192      b
2      M     186      c
3      F     167      d

添加多列

df_append.assign(col1=lambda x:x['Gender']*2,col2=lambda x:x['Height']*2)

  Gender  Height col1  col2
0      M     173   MM   346
1      F     192   FF   384
2      M     186   MM   372
3      F     167   FF   334

二、combine与update

combine方法

主要用于填充

填充对象

按照表的顺序逐列循环，自动索引对齐，缺失值为NaN

df_combine_1 = df.loc[:1,['Gender','Height']].copy()
df_combine_2 = df.loc[10:11,['Gender','Height']].copy()
df_combine_1.combine(df_combine_2,lambda x,y:print(x,'\n',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

 Gender Height
 0  NaN    NaN
 1  NaN    NaN
10  NaN    NaN
11  NaN    NaN

根据大小填充

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)

   A  B
0  8  6
1  7  5

索引对齐特性

df2 = pd.DataFrame({'B': [8, 7], 'C': [6, 5]},index=[1,2])
df1 = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
print(df1.combine(df2,lambda x,y:x if x.mean()>y.mean() else y))

    A    B    C
0 NaN  NaN  NaN
1 NaN  8.0  6.0
2 NaN  7.0  5.0

使df1的值不被覆盖

df1.combine(df2,lambda x,y:x if x.mean()>y.mean() else y,overwrite=False)

     A    B    C
0  1.0  NaN  NaN
1  2.0  8.0  6.0
2  NaN  7.0  5.0

NaN处用其他值填充

df1.combine(df2,lambda x,y:x if x.mean()>y.mean() else y,fill_value=-1)

     A    B    C
0  1.0 -1.0 -1.0
1  2.0  8.0  6.0
2 -1.0  7.0  5.0

combine_first方法

用df2填补df1的缺失值

df1 = pd.DataFrame({'A': [None, 0], 'B': [None, 4]})
df2 = pd.DataFrame({'A': [1, 1], 'B': [3, 3]})
df1.combine_first(df2)

     A    B
0  1.0  3.0
1  0.0  4.0

update方法

返回的框索引只会与被调用框的一致（默认使用左连接）
第二个框中的NaN不起作用
没有返回值，直接在df上操作

索引对齐

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)
print(df1)

部分填充

df1 = pd.DataFrame({'A': ['a', 'b', 'c'],'B': ['x', 'y', 'z']})
df2 = pd.DataFrame({'B': ['d', 'e']}, index=[1,2])
df1.update(df2)
print(df1)

   A  B
0  a  x
1  b  d
2  c  e

缺失值不填充

df1 = pd.DataFrame({'A': [1, 2, 3],'B': [400, 500, 600]})
df2 = pd.DataFrame({'B': [4, np.nan, 6]})
df1.update(df2)
df1

   A      B
0  1    4.0
1  2  500.0
2  3    6.0

三、contact方法

可以在两个维度上拼接，默认纵向拼接（axis=0），拼接方式为外连接

axis=0

df1 = pd.DataFrame({'A': ['A0', 'A1'],'B': ['B0', 'B1']},index = [0,1])
df2 = pd.DataFrame({'A': ['A2', 'A3'],'B': ['B2', 'B3']},index = [2,3])
pd.concat([df1,df2])

    A   B
0  A0  B0
1  A1  B1
2  A2  B2
3  A3  B3

axis=1

按列方向拼接

pd.concat([df1,df2]，axis=1)

     A    B    A    B
0   A0   B0  NaN  NaN
1   A1   B1  NaN  NaN
2  NaN  NaN   A2   B2
3  NaN  NaN   A3   B3

join

设置为内连接，取交集

df3 = pd.DataFrame({'A': ['A1', 'A3'],'D': ['D1', 'D3'],'E': ['E1', 'E3']},index = [1,3])
pd.concat([df3,df1],join='inner')

verify_integrity检列是否唯⼀

四、merge与join

merge

将两个pandas对象横向合并，遇到重复的索引项使用笛卡尔积。默认内连接，可选left、outer、right连接。merge还有一个‘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']})
pd.merge(left, right, on='key1')

  key1 key2_x   A   B key2_y   C   D
0   K0     K0  A0  B0     K0  C0  D0
1   K0     K1  A1  B1     K0  C0  D0
2   K1     K0  A2  B2     K0  C1  D1
3   K1     K0  A2  B2     K0  C2  D2
4   K2     K1  A3  B3     K0  C3  D3

多组建

内连接，取交集

pd.merge(left, right, on=['key1','key2'])

  key1 key2   A   B   C   D
0   K0   K0  A0  B0  C0  D0
1   K1   K0  A2  B2  C1  D1
2   K1   K0  A2  B2  C2  D2

how=outer

pd.merge(left, right, how='outer', on=['key1','key2'])

  key1 key2    A    B    C    D
0   K0   K0   A0   B0   C0   D0
1   K0   K1   A1   B1  NaN  NaN
2   K1   K0   A2   B2   C1   D1
3   K1   K0   A2   B2   C2   D2
4   K2   K1   A3   B3  NaN  NaN
5   K2   K0  NaN  NaN   C3   D3

左连接

how=left

pd.merge(left, right, how='left', on=['key1', 'key2'])

  key1 key2   A   B    C    D
0   K0   K0  A0  B0   C0   D0
1   K0   K1  A1  B1  NaN  NaN
2   K1   K0  A2  B2   C1   D1
3   K1   K0  A2  B2   C2   D2
4   K2   K1  A3  B3  NaN  NaN

join

将多个pandas对象横向合并，遇到重复的索引项使用笛卡尔积。默认左连接，可选left、outer、right连接。

基本链接

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)

     A   B    C    D
K0  A0  B0   C0   D0
K1  A1  B1  NaN  NaN
K2  A2  B2   C2   D2

对于many_to_one模式下的合并，往往join更为方便

left = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
 'B': ['B0', 'B1', 'B2', 'B3'],
 'key': ['K0', 'K1', 'K0', 'K1']})
right = pd.DataFrame({'C': ['C0', 'C1'],
 'D': ['D0', 'D1']},
 index=['K0', 'K1'])
left.join(right, on='key')

    A   B key   C   D
0  A0  B0  K0  C0  D0
1  A1  B1  K1  C1  D1
2  A2  B2  K0  C0  D0
3  A3  B3  K1  C1  D1

多个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'])

    A   B key1 key2    C    D        
0  A0  B0   K0   K0   C0   D0
1  A1  B1   K0   K1  NaN  NaN
2  A2  B2   K1   K0   C1   D1
3  A3  B3   K2   K1   C3   D3

练习

在这里插入图片描述

a

df1 = pd.read_csv('data/Course1.csv')
df2 = pd.read_csv('data/Course2.csv')

df11= df1.query('课程类别 in ["学科基础课","专业必修课","专业选修课"]')
df12= df1.query('课程类别 not in ["学科基础课","专业必修课","专业选修课"]')
df21= df2.query('课程类别 in ["学科基础课","专业必修课","专业选修课"]')
df22= df2.query('课程类别 not in ["学科基础课","专业必修课","专业选修课"]')

df11

       课程名字   课程类别  学分    分数
6   数据结构与算法  学科基础课   5  82.0
12  高等数学（二）  学科基础课   4  92.0
15     离散数学  学科基础课   4  82.0
17     程序设计  学科基础课   4  84.0
19     线性代数  学科基础课   3  97.0

b

major=pd.concat([df11,df21])
common=pd.concat([df12,df22])
major.head()

       课程名字   课程类别  学分    分数
1  云计算应用与开发  专业选修课   3  96.0
2      社会计算  专业选修课   3  78.0
3      深度学习  专业选修课   3  75.0
4    人工智能导论  专业必修课   3  84.0
6   数据结构与算法  学科基础课   5  82.0

c

df = pd.concat([df1,df2])
major2 = df.query('课程类别 in ["学科基础课","专业必修课","专业选修课"]')
common2 = df.query('课程类别 not in ["学科基础课","专业必修课","专业选修课"]')

print((major.equals(major2),common.equals(common2)))

(True, True)

d

df.isnull().all()

课程名字    False
课程类别    False
学分      False
分数      False
dtype: bool

陈述c

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
pandas第五章——合并

一、append和assignappend方法主要用于添加行利用Series添加df_append = df.loc[:3,['Gender','Height']].copy() Gender Height0 M 1731 F 1922 M 1863 F 167s=pd.Series({'Gender':'F','Height':188},name='4')print(df_append.append(s)
复制链接

扫一扫