Pandas学习（五）

合并

append

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

>>> df_append = df.loc[:3,['Gender','Height']].copy()
>>> df_append
  Gender  Height
0      M     173
1      F     192
2      M     186
3      F     167
>>> s = pd.Series({'Gender':'F','Height':188},name='new_row')
>>> df_append.append(s)
        Gender  Height
0            M     173
1            F     192
2            M     186
3            F     167
new_row      F     188

2.用DataFrame添加表

>>> df_temp = pd.DataFrame({'Gender':['F','M'],'Height':[188,176]},index=['new_1','new_2'])
>>> df_append.append(df_temp)
      Gender  Height
0          M     173
1          F     192
2          M     186
3          F     167
new_1      F     188
new_2      M     176

assign

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

>>> s = pd.Series(list('abcd'),index=range(4))
>>> 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=s)
  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

1.填充对象

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

>>> df_combine_1.combine(df_combine_2,lambda x,y:print(x,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

2.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)
     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, np.nan, 6]})
>>> df1.update(df2)
>>> df1
   A      B
0  1    4.0
1  2  500.0
2  3    6.0

concat

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

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

>>> 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])
>>> pd.concat([df1,df2])
    A   B
0  A0  B0
1  A1  B1
2  A2  B2
3  A3  B3
>>> 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
>>> pd.concat([df3,df1],join='inner')
    A
1  A1
3  A3
0  A0
1  A1
>>> pd.concat([df3,df1],join='outer',sort=True) #sort设置列排序，默认为False
    A    B    D    E
1  A1  NaN   D1   E1
3  A3  NaN   D3   E3
0  A0   B0  NaN  NaN
1  A1   B1  NaN  NaN
>>> pd.concat([df3,df1],join='outer')                                      
    A    D    E    B
1  A1   D1   E1  NaN
3  A3   D3   E3  NaN
0  A0  NaN  NaN   B0
1  A1  NaN  NaN   B1
>>> s = pd.Series(['X0', 'X1'], name='X')
>>> pd.concat([df1,s],axis=1)
    A   B   X
0  A0  B0  X0
1  A1  B1  X1
>>> pd.concat([df1,s],axis=0) 
     A    B    0
0   A0   B0  NaN
1   A1   B1  NaN
0  NaN  NaN   X0
1  NaN  NaN   X1
>>> pd.concat([df1,s],axis=0,join='outer') 
     A    B    0
0   A0   B0  NaN
1   A1   B1  NaN
0  NaN  NaN   X0
1  NaN  NaN   X1
>>> pd.concat([df1,s],axis=0,join='inner') 
Empty DataFrame
Columns: []
Index: [0, 1, 0, 1]

merge

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

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

>>> 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']})
>>> left
  key1 key2   A   B
0   K0   K0  A0  B0
1   K0   K1  A1  B1
2   K1   K0  A2  B2
3   K2   K1  A3  B3
>>> pd.merge(left, right, on='key2') 
  key1_x key2   A   B key1_y   C   D
0     K0   K0  A0  B0     K0  C0  D0
1     K0   K0  A0  B0     K1  C1  D1
2     K0   K0  A0  B0     K1  C2  D2
3     K0   K0  A0  B0     K2  C3  D3
4     K1   K0  A2  B2     K0  C0  D0
5     K1   K0  A2  B2     K1  C1  D1
6     K1   K0  A2  B2     K1  C2  D2
7     K1   K0  A2  B2     K2  C3  D3
>>> right
  key1 key2   C   D
0   K0   K0  C0  D0
1   K1   K0  C1  D1
2   K1   K0  C2  D2
3   K2   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
>>> pd.merge(right,left, on=['key1','key2'])  
  key1 key2   C   D   A   B
0   K0   K0  C0  D0  A0  B0
1   K1   K0  C1  D1  A2  B2
2   K1   K0  C2  D2  A2  B2
>>> 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
>>> 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
>>> pd.merge(left, right, how='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
3   K2   K0  NaN  NaN  C3  D3

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)
     A   B    C    D
K0  A0  B0   C0   D0
K1  A1  B1  NaN  NaN
K2  A2  B2   C2   D2
>>> left.join(right,how='outer') 
      A    B    C    D
K0   A0   B0   C0   D0
K1   A1   B1  NaN  NaN
K2   A2   B2   C2   D2
K3  NaN  NaN   C3   D3
>>> left.join(right,how='left')
     A   B    C    D
K0  A0  B0   C0   D0
K1  A1  B1  NaN  NaN
K2  A2  B2   C2   D2
>>> left.join(right,how='right')
      A    B   C   D
K0   A0   B0  C0  D0
K2   A2   B2  C2  D2
K3  NaN  NaN  C3  D3