Pandas数据分析 ——Task05：合并

教程地址：joyful-pandas/第5章 合并——datawhalechina

一、append与assign

1. append方法

必须指定name

dff = df.loc[:3,['Gender','Height']].copy()   #取出原表中一部分

# 利用序列添加行
s = pd.Series({'Gender':'F','Height':188},name='new_row')   
dff_append1 = dff.append(s)  
# 利用DataFrame添加表
df_temp = pd.DataFrame({'Gender':['F','M'],'Height':[188,176]},index=['new_1','new_2'])
dff_append2 = dff.append(df_temp)
# 输出
print(dff,'\n',dff_append1,'\n',dff_append2)

结果：

  Gender  Height
0      M     173
1      F     192
2      M     186
3      F     167 
         Gender  Height
0            M     173
1            F     192
2            M     186
3            F     167
new_row      F     188 
       Gender  Height
0          M     173
1          F     192
2          M     186
3          F     167
new_1      F     188
new_2      M     176

2. assign方法

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

# 添加单列(列名为Letter）
s = pd.Series(list('abcd'),index = range(4))
dff_assign1 = dff.assign(Letter = s)
# 添加多列
dff_assign2 = dff.assign(col1 = lambda x:x['Gender']*2,col2 = s)
# 输出
print(dff,'\n',dff_assign1,'\n',dff_assign2)

结果：

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

二、combine与update

1. comine方法

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

• overwrite:是否覆盖原来符合条件的值（默认True）
• fill_value:设置后面的表没有的行列的填充（默认为NaN）

# 根据列均值的大小填充,注意索引对齐特性
df1 = pd.DataFrame({'A': [6, 7], 'B': [8, 9]})
df2 = pd.DataFrame({'B': [8, 7], 'C': [6, 5]},index=[1,2])
dd = df1.combine(df2,lambda x,y:x if x.mean()>y.mean() else y,
                 overwrite = False,fill_value = -1)
print(df1,'\n',df2,'\n',dd)

结果：

   A  B
0  6  8
1  7  9 
   B  C
1  8  6
2  7  5 
    A    B    C
0  6.0  8.0 -1.0
1  7.0  9.0  6.0
2  NaN -1.0  5.0

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

df1 = pd.DataFrame({'A': [None, 0], 'B': [4, None]})
df2 = pd.DataFrame({'B': [3, 3], 'C': [1, 1]}, index=[1, 2])
dd = df1.combine_first(df2)
print(df1,'\n',df2,'\n',dd)

结果：注意(1,‘B’)处被填补的值

    A    B
0  NaN  4.0
1  0.0  NaN 
   B  C
1  3  1
2  3  1 
    A    B    C
0  NaN  4.0  NaN
1  0.0  3.0  1.0
2  NaN  3.0  1.0

2. update方法

1. 返回的框索引只会与被调用框的一致（默认使用左连接）
2. 第二个框中的nan元素不会起作用
3. 没有返回值，直接在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)      
df3 = pd.DataFrame({'B': [7, np.nan, 9]})
df1.update(df3) #缺失值不会填充
print(df1)

结果：

   A  B
0  1  4
1  2  5
2  3  6
   A   B
0  1  7.0
1  2  5.0
2  3  9.0

三、concat方法

concat方法可以在两个维度上拼接
部分参数如下：

• axis：拼接方向（默认纵向拼接，即axis = 0）
• join：拼接方式（默认外连接，取拼接方向的并集，而设置为 inner 时取拼接方向的交集）
• sort:设置列排序(默认为False)
• verify_integrity:检查列是否唯一
• key：用于对不同的数据框增加一个标号，便于索引

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])
                    
dfc1 = pd.concat([df1,df2])         #纵向拼接
dfc2 = pd.concat([df1,df2],axis=1)  #横向拼接
dfc3 = pd.concat([df3,df1],join = 'inner')    #join设置为内连接,列取交集
print(dfc1,'\n',dfc2,'\n',dfc3)

结果：

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

同样，可以添加Series：

s = pd.Series(['X0', 'X1'], name='X')
dfc4 = pd.concat([df1,s],axis = 1)
print(dfc4)

结果：

    A   B   X
0  A0  B0  X0
1  A1  B1  X1

四、merge与join

1. merge函数

merge函数的作用是将两个pandas对象横向合并，遇到重复的索引项时会使用笛卡尔积（可用参数how修改，默认inner连接，可选left、outer、right连接）
所谓左连接，就是指以第一个表索引为基准，右边的表中如果不再左边的则不加入，如果在左边的就以笛卡尔积的方式加入
merge/join与concat的不同之处在于on参数，可以指定某一个对象为key来进行连接
为了更好地理解，下面给出几个例子：

dfl = pd.DataFrame({'key1': ['K0', 'K0', 'K1', 'K2'],
                     'key2': ['K0', 'K1', 'K0', 'K1'],
                      'A': ['A0', 'A1', 'A2', 'A3'],
                      'B': ['B0', 'B1', 'B2', 'B3']}) 
dfr1 = pd.DataFrame({'key1': ['K0', 'K1', 'K1', 'K2'],
                      'key2': ['K0', 'K0', 'K0', 'K0'],
                      'C': ['C0', 'C1', 'C2', 'C3'],
                      'D': ['D0', 'D1', 'D2', 'D3']})
dfr2 = pd.DataFrame({'key1': ['K0', 'K1', 'K1', 'K2'],
                      'key2': ['K0', 'K0', 'K0', 'K0'],
                      'C': ['C0', 'C1', 'C2', 'C3']})
# print(dfl,'\n',dfr1,'\n',dfr2)
# 单键连接：若两df具有同名的列，则默认suffixes=('_x','_y')
df_merge1 = pd.merge(dfl, dfr1, on = 'key1')        
# 多键组合连接    
df_merge2 = pd.merge(dfl, dfr1, on = ['key1','key2']) 
# 外连接
df_merge3 = pd.merge(dfl, dfr1, how = 'outer', on = ['key1','key2'])
print(df_merge1,'\n',df_merge2,'\n',df_merge3)

结果：

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