pandas学习第5章---合并

import numpy as np
import pandas as pd
df = pd.read_csv('data/table.csv')
df.head()

一、append与assign

1. append方法

（1）利用序列添加行（必须指定name）

#获取列为'Gender'、'Height'的前4行（loc包含右端点）
df_append = df.loc[:3,['Gender','Height']].copy()
df_append

#利用Series在df_append后添加一行
s = pd.Series({'Gender':'F','Height':188},name='new_row')
df_append.append(s)

（2）用DataFrame添加表

#在df_append后面添加一个定义好的DataFrame
df_temp = pd.DataFrame({'Gender':['F','M'],'Height':[188,176]},\
index=['new_1','new_2'])
df_append.append(df_temp)

2. assign方法

该方法主要用于添加列，列名直接由参数指定

#添加一个列名为letter，内容为abcd的列
s = pd.Series(list('abcd'),index=range(4))
df_append.assign(Letter=s)

#一次添加多个列，添加2列，col1和col2
df_append.assign(col1=lambda x:x['Gender']*2,
                 col2=s)

二、combine与update

combine和update都是用于表的填充函数，可以根据某种规则填充

1. combine方法

（1）填充对象

可以看出combine方法是按照表的顺序轮流进行逐列循环的，而且自动
索引对齐，缺失值为NaN，理解这一点很重要
Function that takes two series as inputs and return a Series or a
scalar. Used to merge the two dataframes column by columns.

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,y))

（2）例子

# 例子1，根据列均值的大小填充，填充列均值大的DataFrame
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)

#例子2，索引对齐特性（默认状态下，后面的表没有的行列都会设置为NaN）
#df2 中没有的行和列即A的都会设置为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)

#例3子,使得df1原来符合条件的值不会被覆盖
df1.combine(df2,lambda x,y:x if x.mean()>y.mean() else y,\
overwrite=False) 
#overwrite : bool, default True
   # If True, columns in `self` that do not exist in `other` 
   # will be overwritten with NaNs.
 
#例子4,在新增匹配df2的元素位置填充-1
df1.combine(df2,lambda x,y:x if x.mean()>y.mean() else y,\
fill_value=-1)

（3）combine_first方法

这个方法作用是用df2填补df1的缺失值，功能比较简单，但很多时候会比combine更常用，下面举两个例子

#例子1，用df2将df1 为None的部分对应填补
df1 = pd.DataFrame({'A': [None, 0], 'B': [None, 4]})
df2 = pd.DataFrame({'A': [1, 1], 'B': [3, 3]})
df1.combine_first(df2)

#例子2，注意索引对齐
df1 = pd.DataFrame({'A': [None, 0], 'B': [4, None]})
df2 = pd.DataFrame({'B': [3, 3], 'C': [1, 1]}, index=[1, 2])
df1.combine_first(df2)

2. update方法

（1）三个特点

①返回的框索引只会与被调用框的一致（默认使用左连接）

②第二个框中的nan元素不会起作用

③没有返回值，直接在df上操作

（2）例子

#例1，索引完全对齐情况下的操作，将df1更新为df2相同索引的列
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

#例2，部分填充
df1 = pd.DataFrame({'A': ['a', 'b', 'c'],
                    'B': ['x', 'y', 'z']})
df2 = pd.DataFrame({'B': ['d', 'e']}, index=[1,2])
df1.update(df2)
df1

#例3，缺失值不会填充，df2 中的nan不起作用
df1 = pd.DataFrame({'A': [1, 2, 3],
                    'B': [400, 500, 600]})
df2 = pd.DataFrame({'B': [4, np.nan, 6]})
df1.update(df2)
df1

三、concat方法

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

所谓外连接，就是取拼接方向的并集，而’inner’是取拼接方向（若使用默认的纵向拼接，则为列的交集）的交集

下面举一些例子说明其参数：

#定义三个DataFrame，注意index
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])
               
#默认状态下拼接，纵向，外连接，在df1下方拼接df2
pd.concat([df1,df2])

#axis=1时沿列方向拼接，缺失值NaN     
pd.concat([df1,df2],axis=1)

#join设置为内连接（由于axis=0，因此列取交集）
pd.concat([df3,df1],join='inner')
#df3、 df1 取交集只有A列

#join设置为外链接    
pd.concat([df3,df1],join='outer',sort=True)
#sort设置列排序，默认为False    

#检查索引重叠
#pd.concat([df3,df1],verify_integrity=True,sort=True) 报错

#可以添加Series
s = pd.Series(['X0', 'X1'], name='X')
pd.concat([df1,s],axis=1)

key参数用于对不同的数据框增加一个标号，便于索引
pd.concat([df1,df2], keys=['x', 'y'])
pd.concat([df1,df2], keys=['x', 'y']).index
#If multiple levels passed, should contain tuples. Construct
#hierarchical index using the passed keys as the outermost level

四、merge与join

1. merge函数

merge函数的作用是将两个pandas对象横向合并，遇到重复的索引项时会使用笛卡尔积，默认inner连接，可选left、outer、right连接

所谓左连接，就是指以第一个表索引为基准，右边的表中如果不再左边的则不加入，如果在左边的就以笛卡尔积的方式加入

merge/join与concat的不同之处在于on参数，可以指定某一个对象为key来进行连接

例子

#定义3个DataFrame
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连接，因为merge只能横向拼接，所以取行向上keys的交集，
#下面看如果使用how=outer参数
#注意：这里的how就是concat的join
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'])

#由于B的所有元素为2，因此需要6行
left = pd.DataFrame({'A': [1, 2], 'B': [2, 2]})
right = pd.DataFrame({'A': [4, 5, 6], 'B': [2, 2, 2]})
pd.merge(left, right, on='B', how='outer')

#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'也是可以的

2. join函数

join函数作用是将多个pandas对象横向拼接，遇到重复的索引项时会使用笛卡尔积，默认左连接，可选inner、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)

对于many_to_one模式下的合并，往往join更为方便
同样可以指定key

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')

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

声明：本文主要参考Datawhale主办的一期Joyful-Pandas资料