DataWhale——Task05：合并

Task05：合并

一、append和assign

1. append方法

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

s = pd.Series(data,name='new_row') 
df.append(s)

(b) 用dataframe添加表

df1 = pd.DataFrame(data,index=['col1','col2'])
df.append(d1)

2. assign方法

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

ser_obj = pd.Series(list('abcd'),index=range(4))
df.assign(new_col=ser_obj)

一次添加多个列，例如：

df.assign(col1=lambda x:x['Gender']*2，
          col2=s)

二、combine与updata

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

1. combine方法

（a）填充对象

combine方法是按照表的顺序轮流进行逐列循环的，而且自动索引对齐，缺失值为NaN

df1.combine(df2)

（b）一些例子：

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

#例4 再新增匹配df2的元素位置填充-1
df1.combine(df2,lambda x,y:x if x.mean()>y.mean() else y,fill_value=-1)

（c）combine_first

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

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

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方法

（a）三个特点

①返回的框索引只会与被调用框的一致（默认使用左连接，下一节会介绍）
②第二个框中的nan元素不会起作用
③没有返回值，直接在df上操作

（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

例②：部分填充

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

例③：缺失值不会填充

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

三、concat方法

（a）一般形式

concat()函数可以沿着一条轴将多个对象进行堆叠，其使用方式类似数据库中的数据表合并。

concat(objs,axis=0,join=‘outer’,join_axes=None,ignore_index=False,keys=None,levels=None,names=None, ...)

• axis：表示连接的轴向，可以为0或1，默认为0。
• join：表示连接的方式，inner表示内连接，outer表示外连接，默认使用外连接。
• ignore_index：如果设置为True，清除现有索引并重置索引值。
• names：结果分层索引中的层级的名称。

（b）横向堆叠、纵向堆叠

根据轴方向的不同，可以将堆叠分成横向堆叠与纵向堆叠，默认采用的是纵向堆叠方式。

（c）内连接、外连接

在堆叠数据时，默认采用的是外连接（join参数设为outer）的方式进行合并，当然也可以通过join=inner设置为内连接的方式。

（d）轴向堆叠数据

当使用concat()函数合并时，若是将axis参数的值设为1，且join参数的值设为outer，代表着使用横向堆叠与外连接的方式进行合并。

当使用concat()函数合并时，若是将axis参数的值设为0，且join参数的值设为inner，则代表着使用纵向堆叠与内连接的方式进行合并。

这部分内容参考了传智播客数据预处理部分。

四、merge与join

1. merge方法

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

（a）函数一般形式

pandas.merge(left, right, how='inner', on=None, left_on=None,right_on=None, left_index=False, right_index=False, sort=False,suffixes=('_x', '_y'), copy=True, indicator=False, validate=None)

• left：参与合并的左侧DataFrame对象。
• right：参与合并的右侧DataFrame对象。
• how：表示连接方式，默认为inner。

（b）支持多组键连接：

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

（c）左连接

左连接是以左表为基准进行连接，所以left表中的数据会全部显示，right表中只会显示与重叠数据行索引值相同的数据，合并后表中缺失的数据会使用NaN进行填充。

（d）右连接

右连接与左连接的规则正好相反，右连接是以右表为基准，右表中的数据全部显示，而左表中显示与重叠数据行索引值相同的数据，合并后缺失的数据使用NaN填充合并。

2. join方法

join函数作用是将多个pandas对象横向拼接，遇到重复的索引项时会使用笛卡尔积，默认左连接，可选inner、outer、right连接。

（a）函数一般形式

join（other，on = None，how ='left'，lsuffix =''，rsuffix =''，sort = False ）

（b）例子

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