一、merge
merge操作实现两个DataFrame之间的合并,类似于sql两个表之间的关联查询。merge的使用方法及参数解释如下:
pd.merge(left, right, on=None, how='inner', left_on=None, right_on=None, left_index=False, right_index=False,
sort=False, suffixes=('_x', '_y'), copy=True, indicator=False, validate=None)
- left和right:第一个DataFrame和第二个DataFrame对象,merge只能实现两个DataFrame的合并,无法一次实现多个合并
- on:指定参考column,要求两个df必须至少有一个相同的column,默认为None以最多相同的column为参考
- how:合并的方式,默认为inner取参考column的交集,outer取并集保留所有行;outer、left、right中的缺失值都以NaN填充;left按照左边对象为参考进行合并即保留左边的所有行,right按照右边对象为参考进行合并即保留右边所有行,
- left_on=None和right_on=None:以上on是在两个df有相同的column的情况下使用,如果两个df没有相同的column,使用left_on和right_on分别指明左边和右边的参考column
- left_index和right_index:指定是否以索引为参考进行合并
- sort:合并结果是否按on指定的参考进行排序
- suffixed:合并后如果有重复column,分别加上什么后缀
下面对每个参数进行演示
on:指定参考column,如果不指定默认为None,以两者相同列的最多数为参考;index重新生成为从0开始的整数。
df1 = pd.DataFrame({'key1':['a','b','c','d'],'key2':['e','f','g','h'],'key3':['i','j','k','l']},index=['k','l','m','n',]) df2 = pd.DataFrame({'key1':['a','B','c','d'],'key2':['e','f','g','H'],'key4':['i','j','K','L']},index = ['p','q','u','v']) print(df1) print(df2) print(pd.merge(df1,df2,on='key1')) print(pd.merge(df1,df2,on='key2')) print(pd.merge(df1,df2,on=['key1','key2'])) print(pd.merge(df1,df2)) #可以看到不加on参数,系统自动以个数最多的相同column为参考 # key1 key2 key3 # k a e i # l b f j # m c g k # n d h l # key1 key2 key4 # p a e i # q B f j # u c g K # v d H L # key1 key2_x key3 key2_y key4 # 0 a e i e i # 1 c g k g K # 2 d h l H L # key1_x key2 key3 key1_y key4 # 0 a e i a i # 1 b f j B j # 2 c g k c K # key1 key2 key3 key4 # 0 a e i i # 1 c g k K # key1 key2 key3 key4 # 0 a e i i # 1 c g k K
how:指定合并方式,如果不指定默认为inner
inner相当于sql中的=,outer相当于sql中的full join,left相当于sql中的left join,right相当于sql中的right join;index重新生成为从0开始的整数。
对于outer、left、right来说可能会出现缺失值,全部以NaN填充。
df1 = pd.DataFrame({'key1':['a','b','c','d'],'key2':['e','f','g','h'],'key3':['i','j','k','l']},index=['k','l','m','n',]) df2 = pd.DataFrame({'key1':['a','B','c','d'],'key2':['e','f','g','H'],'key4':['i','j','K','L']},index = ['p','q','u','v']) print(df1) print(df2) print(pd.merge(df1,df2,how='inner')) #默认方式,取交集 print(pd.merge(df1,df2,how='outer')) #取并集 print(pd.merge(df1,df2,how='left')) #以左边为参考,即保留左边所有行 print(pd.merge(df1,df2,how='right')) #以右边为参考,即保留右边所有行 # key1 key2 key3 # k a e i # l b f j # m c g k # n d h l # key1 key2 key4 # p a e i # q B f j # u c g K # v d H L # key1 key2 key3 key4 # 0 a e i i # 1 c g k K # key1 key2 key3 key4 # 0 a e i i # 1 b f j NaN # 2 c g k K # 3 d h l NaN # 4 B f NaN j # 5 d H NaN L # key1 key2 key3 key4 # 0 a e i i # 1 b f j NaN # 2 c g k K # 3 d h l NaN # key1 key2 key3 key4 # 0 a e i i # 1 c g k K # 2 B f NaN j # 3 d H NaN L
left_on和right_on:默认都为False,但是如果两个DataFrame没有相同的column而又需要对它们的按列合并,则需要使用left_on和right_on分别指明两边的参考列;index重新生成为从0开始的整数。
但是left_on和right_on不是必须成对出现,下面关于left_index和right_index会涉及到。
df1 = pd.DataFrame({'key1':['a','b','c','d'],'key2':['e','f','g','h'],'key3':['i','j','k','l']},index=['k','l','m','n']) df2 = pd.DataFrame({'key4':['a','B','c','d'],'key5':['e','f','g','H'],'key6':['i','j','K','L']},index = ['p','q','u','v']) print(df1) print(df2) # print(pd.merge(df1,df2,df1 = pd.DataFrame({'key1':['a','b','c','d'],'key2':['e','f','g','h'],'key3':['i','j','k','l']},index=['k','l','m','n']) df2 = pd.DataFrame({'key4':['a','B','c','d'],'key5':['e','f','g','H'],'key6':['i','j','K','L']},index = ['p','q','u','v']) print(df1) print(df2) # print(pd.merge(df1,df2,left_on='key1',right_on='key4')) # key1 key2 key3 # k a e i # l b f j # m c g k # n d h l # key4 key5 key6 # p a e i # q B f j # u c g K # v d H L # key1 key2 key3 key4 key5 key6 # 0 a e i a e i # 1 c g k c g K # 2 d h l d H L='key1',right_on='key4')) # key1 key2 key3 # k a e i # l b f j # m c g k # n d h l # key4 key5 key6 # p a e i # q B f j # u c g K # v d H L # key1 key2 key3 key4 key5 key6 # 0 a e i a e i # 1 c g k c g K # 2 d h l d H L
left_index和right_index:默认都为False,如果需要按索引进行合并,则需要使用left_index和right_index指明以index为参考。(on、left_on、right_on都是指定以column为参考)
如果使用了left_index或者right_index,必须指明另一方的参考键。
结果除了包含两个DataFrame的所有列,还会生成一个新的列,新列即以指定的两个参考进行合并后的结果。
如果是left_on = '**' 和right_index = True或者left_index = True 和right_on = '**',index取on所在的一方,如果是left_index = True和right_index = True,取两者相同的即可。
df1 = pd.DataFrame({'key1':['a','b','c','d'],'key2':['e','f','g','h']},index=['k','l','m','n']) df2 = pd.DataFrame({'key1':['k',6,'l']},index=['a','m','c']) print(df1) print(df2) print(pd.merge(df1,df2,left_on='key1',right_index=True)) #index取df1的 print(pd.merge(df1,df2,left_index=True,right_on='key1')) #index取df2的 print(pd.merge(df1,df2,left_index=True,right_index=True)) #index取两者交集 # key1 key2 # k a e # l b f # m c g # n d h # key1 # a k # m 6 # c l # key1 key1_x key2 key1_y # k a a e k # m c c g l # key1 key1_x key2 key1_y # a k a e k # c l b f l # key1_x key2 key1_y # m c g 6
sort:结果是否按照参考进行排序,默认不排序;数字按照大小排序,字符串按照A-Za-z排序。
merge结果的显示顺序默认是按照df1、df2的行顺序进行显示,
df1 = pd.DataFrame({'key1':['d','a','c','B'],'key2':[3,6,1,8]},index=['k','l','m','n']) df2 = pd.DataFrame({'key1':['c','B','a','d'],'key2':[3,8,2,1]},index = ['p','q','u','v']) print(df1) print(df2) print(pd.merge(df1,df2,on='key2',)) print(pd.merge(df1,df2,on='key1',sort=True)) # key1 key2 # k d 3 # l a 6 # m c 1 # n B 8 # key1 key2 # p c 3 # q B 8 # u a 2 # v d 1 # key1_x key2 key1_y # 0 d 3 c # 1 c 1 d # 2 B 8 B # key1 key2_x key2_y # 0 B 8 8 # 1 a 6 2 # 2 c 1 3 # 3 d 3 1
pandas自带的排序方法df.sort_index()、df.sort_values('column')
suffixes:如果两者相同的column未被指定为参考列,那么结果中这两个相同的column名称会被加上后缀,默认为左右分别为_x和_y
df1 = pd.DataFrame({'key1':['a','b','c','d'],'key2':['e','f','g','h']},index=['k','l','m','n',]) df2 = pd.DataFrame({'key1':['a','B','c','d'],'key2':['e','f','g','H']},index = ['p','q','u','v']) print(df1) print(df2) print(pd.merge(df1,df2,on='key1')) print(pd.merge(df1,df2,on='key2',suffixes=('_df1','_df2'))) # key1 key2_x key2_y # 0 a e e # 1 c g g # 2 d h H # key1_df1 key2 key1_df2 # 0 a e a # 1 b f B # 2 c g c
二、join
join是默认按照index、以left方式实现两个DataFrame的合并,即默认用法相当于merge的pd.merge(df1,df2,how = 'left',left_index = True,right_index = True),缺失值默认为NaN
df1.join(df2, on=None, how='left', lsuffix='', rsuffix='',sort=False)
由于join的lsuffix和rsuffix默认值为空,因此如果两者有相同的column,一定要手动指定这两个参数,否则会报错。
join也可以通过on指定前面的DataFrame以column为参考与后面的index关联实现合并,即相当于merge的pd.merge(df1,df2,how = 'left',left_on ='**',right_index = True)。
index重新生成为从0开始的整数。
df1 = pd.DataFrame({'key1':['a','b','c','d'],'key2':[1,2,3,4]}) df2 = pd.DataFrame({'key1':['a','B','c','d'],'key3':['e','f','g','H']}) print(df1) print(df2) print(df1.join(df2,on='key2',lsuffix='_df1',rsuffix='_df2')) # key1 key2 # 0 a 1 # 1 b 2 # 2 c 3 # 3 d 4 # key1 key3 # 0 a e # 1 B f # 2 c g # 3 d H # key1_df1 key2 key1_df2 key3 # 0 a 1 B f # 1 b 2 c g # 2 c 3 d H # 3 d 4 NaN NaN
三、concat
上述merge和join都是指定了column或者index为参考对两个DataFrame进行合并,concat是单纯的对DataFrame进行堆叠,并且空值填充为NaN。
concat可一次实现对多个pandas对象的堆叠,默认是对所有列在垂直方向进行堆叠、index为原来各自的索引。
concat( [obj1, obj2, obj3], axis=0, join="outer", join_axes=None, ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, sort=None, copy=True)
如果是在水平方向进行堆叠,需要指定axis=1,如果合并后有相同列名称,可通过add_prefix或者add_suffix为其中一个添加名称后缀。
s1 = pd.Series([1,2,3],index=['a','b','c'],name='s1') s2 = pd.Series([3,4,'w'],index=['c','x','y'],name='s2') print(s1) print(s2) print(pd.concat([s1,s2])) print(pd.concat([s1,s2],axis=1,sort=False)) # a 1 # b 2 # c 3 # Name: s1, dtype: int64 # c 3 # x 4 # y w # Name: s2, dtype: object # a 1 # b 2 # c 3 # c 3 # x 4 # y w # dtype: object # s1 s2 # a 1.0 NaN # b 2.0 NaN # c 3.0 3 # x NaN 4 # y NaN w
join表示堆叠方式,默认为outer,只有outer和inner方式,inner表示只对相同列进行堆叠。
s1 = pd.DataFrame([[1,2,3],[4,5,6]],columns=['a','b','c']) s2 = pd.DataFrame([[3,4,'w'],[5,6,'x']],columns=['a','b','d']) print(s1) print(s2) print(pd.concat([s1,s2])) print(pd.concat([s1,s2],join="inner")) # a b c # 0 1 2 3 # 1 4 5 6 # a b d # 0 3 4 w # 1 5 6 x # a b c d # 0 1 2 3.0 NaN # 1 4 5 6.0 NaN # 0 3 4 NaN w # 1 5 6 NaN x # a b # 0 1 2 # 1 4 5 # 0 3 4 # 1 5 6
ignore_index表示是否保留原对象的index,默认保留,True表示结果的index为从0开始的整数。
s1 = pd.Series([1,2,3],index=['a','b','c'],name='s1') s2 = pd.Series([3,4,'w'],index=['c','x','y'],name='s2') print(pd.concat([s1,s2])) print(pd.concat([s1,s2],ignore_index=True)) # a 1 # b 2 # c 3 # c 3 # x 4 # y w # dtype: object # 0 1 # 1 2 # 2 3 # 3 3 # 4 4 # 5 w # dtype: object
join_axes指定结果显示的行索引
s1 = pd.Series([1,2,3],index=['a','b','c'],name='s1') s2 = pd.Series([3,4,'w'],index=['c','x','y'],name='s2') print(pd.concat([s1,s2],axis=1)) print(pd.concat([s1,s2],axis=1,join_axes=[['a','c']])) # s1 s2 # a 1.0 NaN # b 2.0 NaN # c 3.0 3 # x NaN 4 # y NaN w # s1 s2 # a 1 NaN # c 3 3
对于Seris来说,默认按照竖直方向堆叠,如果再指定keys,则会形成一个层次索引。
如果在设置axis=1的情况下即按照水平方向进行堆叠,再指定keys,则keys的值会成为column。
s1 = pd.Series([1,2,3],index=['a','b','c'],name='s1') s2 = pd.Series([3,4,'w'],index=['c','x','y'],name='s2') print(pd.concat([s1,s2])) #竖直方向堆叠 print(pd.concat([s1,s2],keys=['s1','s2'])) #竖直方向堆叠,并形成一个层次索引 print(pd.concat([s1,s2],axis=1,keys=['s1','s2'])) #水平方向堆叠,keys的值为column # a 1 # b 2 # c 3 # c 3 # x 4 # y w # dtype: object # s1 a 1 # b 2 # c 3 # s2 c 3 # x 4 # y w # dtype: object # s1 s2 # a 1.0 NaN # b 2.0 NaN # c 3.0 3 # x NaN 4 # y NaN w
四、替换空值combine_first
在相同index和column的位置,用一个对象的值去替换另一个对象的空值NaN。
df1.combine_forst(df2),如果df2有不在df1中的index和column,直接追加上去。
df1 = pd.DataFrame([[1,np.nan,3],[np.nan,5,6]],columns=['a','b','c']) df2 = pd.DataFrame([[3,4,'w'],[5,6,'x'],[7,8,9]],columns=['a','b','d']) print(df1) print(df2) print(df1.combine_first(df2)) #对于index为0和1,在对应column位置使用df2的值替换df1的空值 #df2中的index=2和column='d'不在df1中,结果保留这一行和这里一列, # a b c # 0 1.0 NaN 3 # 1 NaN 5.0 6 # a b d # 0 3 4 w # 1 5 6 x # 2 7 8 9 # a b c d # 0 1.0 4.0 3.0 w # 1 5.0 5.0 6.0 x # 2 7.0 8.0 NaN 9
五、更新update
在相同index和column的位置,使用一个对象的值去更新原对象的值,该方法没有返回值,直接修改原对象。
df1.update(df2),更新df1,结果只包含原对象的行和列。
df1 = pd.DataFrame([[1,np.nan,3],[np.nan,5,6]],columns=['a','b','c']) df2 = pd.DataFrame([[3,4,'w'],[5,6,'x'],[7,8,9]],columns=['a','b','d']) df1.update(df2) #没有返回值,直接打印结果为none,且df2中的第3行和d列不追加到df1 print(df1) # a b c # 0 3.0 4.0 3 # 1 5.0 6.0 6
六、去重duplicate与drop_duplicates
duplicate()结果是一个值为布尔的Seris,通过obj[ df.duplicated()==False ]来取出Seris和DataFrame中的重复值、行,新结果的index为False对应的索引。
对于Seris,从第一个值开始判断,如果元素第一次出现,则duplicate后的值为True,否则为False
对应于DataFrame,从第一行开始判断,如果行的内容第一次出现(要求行内元素顺序一致),则duplicate后的值为True,否则为False。如
s = pd.Series([1,2,2,1,3,3]) print(s.duplicated()) print(s[s.duplicated()==False]) print('----------------') df = pd.DataFrame([[1,2,3],[4,5,6],[1,3,2],[4,5,6],[7,8,9]]) print(df.duplicated()) #[1,2,3]和[1,3,2]不重复 print(df[df.duplicated()==False]) # 0 False # 1 False # 2 True # 3 True # 4 False # 5 True # dtype: bool # 0 1 # 1 2 # 4 3 # dtype: int64 # ---------------- # 0 False # 1 False # 2 False # 3 True # 4 False # dtype: bool # 0 1 2 # 0 1 2 3 # 1 4 5 6 # 2 1 3 2 # 4 7 8 9
drop_duplicates( )删除重复的元素,默认生成新的结果不修改原对象,如果添加参数inplace=True则直接修改原对象。新结果的index为元素第一次出现时对应的索引
s = pd.Series([1,2,2,1,3,3]) print(s.drop_duplicates()) df = pd.DataFrame([[1,2,3],[4,5,6],[1,3,2],[4,5,6],[7,8,9]]) df.drop_duplicates(inplace=True) print(df) # 0 1 # 1 2 # 4 3 # dtype: int64 # 0 1 2 # 0 1 2 3 # 1 4 5 6 # 2 1 3 2 # 4 7 8 9
七、替换replace
replace('原元素','新元素')将原元素替换成新元素
如果要同时替换多个元素,用列表表示即可;如果要将不同的元素替换成不同的内容,使用字典。
s = pd.Series(list('abcafc')) print(s.replace('a','A')) #将每个a替换成A print(s.replace(['a','b'],'W')) #将所有a、b替换成W print(s.replace({'a':'A','f':'F'})) #将a替换成A,f替换成F df = pd.DataFrame([[1,2,3],[4,5,6],[2,5,8]]) print(df.replace(2,'a')) #将2替换成a