pandas合併、拼接、結合

把來自不同地方的數據源整合轉換成統一的數據結構，增加屬性、增加樣本。

合併merge()

官方文檔連接
語法： 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： 連接方式，‘left’, ‘right’, ‘outer’, ‘inner’，默認‘inner’
• on： label or list。指定連接key，可指定多keys。None或者未使用下述四個參數時，則以兩邊所有重複的列爲鍵連接。
• left_on： label or list, or array-like。指定左邊的連接鍵，可以指定多鍵。
• right_on： label or list, or array-like。指定右邊的連接鍵，可以指定多鍵。
• left_index： bool, default False。True表示左邊數據框以索引爲連接鍵，如果是多級索引，需要右邊也有同樣級別。
• right_index： bool, default False。True表示右邊數據框以索引爲連接鍵
• sort： bool, default False。True表示以連接鍵排序
• suffixes： 元組(str, str)，默認(‘_x’, ‘_y’)。如果合併的有重複列，則分別爲其加後綴。如果suffixes=(False, False)，則當有重複列時，引發異常。
• copy： 布爾值，默認False。引用or複製。
• indicator： bool or str, default False。新增一列 “_merge”（默認，可指定），表示該行記錄是來自左邊還是右邊，或者both
• validate： str, optional。檢測是否有重複鍵。
  • ‘1:1’表示兩邊連接鍵都不能有重複值，否則報錯
  • ‘1:m’表示左邊連接鍵不能有重複值，否則報錯
  • ‘m:1’表示右邊邊連接鍵不能有重複值，否則報錯
  • ‘m:m’表示兩邊連接鍵都可以有重複值

備註： left_on、right_on和left_index、right_index可以混合使用

df1 = pd.DataFrame({'lkey': ['foo', 'bar', 'baz', 'foo'], 'value': [1, 2, 3, 5]})
df2 = pd.DataFrame({'rkey': ['foo', 'bar', 'baz', 'foo'], 'value': [5, 6, 7, 8]})
df1
    lkey value
0   foo      1
1   bar      2
2   baz      3
3   foo      5
df2
    rkey value
0   foo      5
1   bar      6
2   baz      7
3   foo      8

pd.merge(df1, df2, left_on='lkey', right_on='rkey', suffixes=('_left', '_right'))
  lkey  value_left rkey  value_right
0  foo           1  foo            5
1  foo           1  foo            8
2  foo           5  foo            5
3  foo           5  foo            8
4  bar           2  bar            6
5  baz           3  baz            7

>>> df1.merge(df2, left_on='lkey', right_on='rkey', suffixes=(False, False))
Traceback (most recent call last):
...
ValueError: columns overlap but no suffix specified:
    Index(['value'], dtype='object')

拼接concat()

語法： pandas.concat(objs, axis=0, join=‘outer’, join_axes=None, ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, sort=None, copy=True)
用途： 使用時需要DataFrame或Series有相同的索引結構（層級數）；使用axis指定是縱向拼接（增加樣本）還是橫向拼接（使用行索引連接）；使用join指定是外連接還是內連接；使用keys增加新的等級索引，爲objs中每個對象生成一個索引。
參數：
objs： 要連接的DataFrame和Series對象，以列表或字典的形式傳入。若以字典形式傳入，涉及到參數keys的用法，見下。
axis： {0/’index’, 1/’columns’}, default 0。縱向連接或橫向連接
join： {‘inner’, ‘outer’}, default ‘outer’。內連接或外連接
ignore_index： bool, default False。是否忽略現有索引，新生成索引0、1、2……的單級索引
keys： sequence, default None。生成新的索引，看例子就明白了。
names： list, default None。爲新生成的多級索引命名，加下例子
verify_integrity： bool, default False. Check whether the new concatenated axis contains duplicates. This can be very expensive relative to the actual data concatenation.

fra1 = pd.DataFrame(np.array([[25, 70], [40, 80], [15, 40], [20, 65]]), index=['a', 'b', 'c', 'd'], columns=['age', 'weight'])
fra2 = pd.DataFrame(np.array([[20, 60], [15, 80], [40, 100], [60, 50]]), index=['c', 'd', 'e', 'f'], columns=['age', 'height'])
ser = pd.Series([165, 170, 180, 158], index=['c', 'd', 'e', 'f'])
ser.name = 'size'

fra1
Out[74]: 
   age  weight
a   25      70
b   40      80
c   15      40
d   20      65

fra2
Out[75]: 
   age  height
c   20      60
d   15      80
e   40     100
f   60      50

ser
Out[76]: 
c    165
d    170
e    180
f    158
Name: size, dtype: int64

#橫向拼接，外連接，設置新等級索引
pd.concat([fra1, fra2, ser], axis=1, join='outer', keys=['fra1', 'fra2', 'ser'], names=['level0', 'level1'])
Out[77]: 
level0  fra1         fra2           ser
level1   age weight   age height   size
a       25.0   70.0   NaN    NaN    NaN
b       40.0   80.0   NaN    NaN    NaN
c       15.0   40.0  20.0   60.0  165.0
d       20.0   65.0  15.0   80.0  170.0
e        NaN    NaN  40.0  100.0  180.0
f        NaN    NaN  60.0   50.0  158.0

#內連接
pd.concat([fra1, fra2, ser], axis=1, join='inner', keys=['fra1', 'fra2', 'ser'], names=['level0', 'level1'])
Out[78]: 
level0 fra1        fra2         ser
level1  age weight  age height size
c        15     40   20     60  165
d        20     65   15     80  170
#省略參數keys的一種寫法
pd.concat({'fra1':fra1, 'fra2':fra2, 'ser':ser}, axis=1, join='inner', names=['level0', 'level1'])
Out[83]: 
level0 fra1        fra2         ser
level1  age weight  age height size
c        15     40   20     60  165
d        20     65   15     80  170

#縱向拼接
pd.concat([fra1, fra2])
Out[79]: 
   age  height  weight
a   25     NaN    70.0
b   40     NaN    80.0
c   15     NaN    40.0
d   20     NaN    65.0
c   20    60.0     NaN
d   15    80.0     NaN
e   40   100.0     NaN
f   60    50.0     NaN

組合combine_first()

語法： fra1.combine_first(fra2)
用途： 使用fra2中相同位置（指索引位置）的非NaN元素填充fra1中的NaN元素。得到新的DataFrame對象，把二者的所有索引都包含在內，缺失元素（某些行索引只在一方存在，就會造成缺失元素）使用NaN填充。fra也可以是Series。

fra1 = pd.DataFrame(np.array([[25, 70], [40, 80], [15, np.NaN], [np.NaN, 65]]), index=['a', 'b', 'c', 'd'], columns=['age', 'weight'])
fra2 = pd.DataFrame(np.array([[20, 60], [15, 80], [np.NaN, 100], [60, 50]]), index=['c', 'd', 'e', 'f'], columns=['age', 'height'])

fra1
Out[24]: 
    age  weight
a  25.0    70.0
b  40.0    80.0
c  15.0     NaN
d   NaN    65.0

fra2
Out[25]: 
    age  height
c  20.0    60.0
d  15.0    80.0
e   NaN   100.0
f  60.0    50.0

fra1.combine_first(fra2)
Out[26]: 
    age  height  weight
a  25.0     NaN    70.0
b  40.0     NaN    80.0
c  15.0    60.0     NaN
d  15.0    80.0    65.0
e   NaN   100.0     NaN
f  60.0    50.0     NaN