panda DataFrame 數據合併，連接（merge,join,concat)

merge  通過鍵拼接列

pandas提供了一個類似於關係數據庫的連接(join)操作的方法<Strong>merage</Strong>,可以根據一個或多個鍵將不同DataFrame中的行連接起來
語法如下

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

用於通過一個或多個鍵將兩個數據集的行連接起來，類似於 SQL 中的 JOIN。該函數的典型應用場景是，針對同一個主鍵存在兩張包含不同字段的表，現在我們想把他們整合到一張表裏。在此典型情況下，結果集的行數並沒有增加，列數則爲兩個元數據的列數和減去連接鍵的數量。
on=None 用於顯示指定列名（鍵名），如果該列在兩個對象上的列名不同，則可以通過 left_on=None, right_on=None 來分別指定。或者想直接使用行索引作爲連接鍵的話，就將 left_index=False, right_index=False 設爲 True。
how='inner' 參數指的是當左右兩個對象中存在不重合的鍵時，取結果的方式：inner 代表交集；outer 代表並集；left 和 right 分別爲取一邊。
suffixes=('_x','_y') 指的是當左右對象中存在除連接鍵外的同名列時，結果集中的區分方式，可以各加一個小尾巴。
對於多對多連接，結果採用的是行的笛卡爾積。

參數說明：
left與right：兩個不同的DataFrame
how：指的是合併(連接)的方式有inner(內連接),left(左外連接),right(右外連接),outer(全外連接);默認爲inner
on : 指的是用於連接的列索引名稱。必須存在右右兩個DataFrame對象中，如果沒有指定且其他參數也未指定則以兩個DataFrame的列名交集做爲連接鍵
left_on：左則DataFrame中用作連接鍵的列名;這個參數中左右列名不相同，但代表的含義相同時非常有用。
right_on：右則DataFrame中用作 連接鍵的列名
left_index：使用左則DataFrame中的行索引做爲連接鍵
right_index：使用右則DataFrame中的行索引做爲連接鍵
sort：默認爲True，將合併的數據進行排序。在大多數情況下設置爲False可以提高性能
suffixes：字符串值組成的元組，用於指定當左右DataFrame存在相同列名時在列名後面附加的後綴名稱，默認爲('_x','_y')
copy：默認爲True,總是將數據複製到數據結構中；大多數情況下設置爲False可以提高性能
indicator：在 0.17.0中還增加了一個顯示合併數據中來源情況；如只來自己於左邊(left_only)、兩者(both)

merge一些特性示例：

1.默認以重疊的列名當做連接鍵。

In [16]: df1=DataFrame({'key':['a','b','b'],'data1':range(3)})

In [17]: df2=DataFrame({'key':['a','b','c'],'data2':range(3)})

In [18]: pd.merge(df1,df2)   #沒有指定連接鍵，默認用重疊列名，沒有指定連接方式
Out[18]:
   data1 key  data2
0      0   a      0
1      1   b      1
2      2   b      1

2.默認做inner連接（取key的交集），連接方式還有（left,right,outer)，制定連接方式加參數：how=''

In [19]: pd.merge(df2,df1)
Out[19]:
   data2 key  data1
0      0   a      0
1      1   b      1
2      1   b      2                   #默認內連接，可以看見c沒有連接上。

In [20]: pd.merge(df2,df1,how='left')    #通過how，指定連接方式
Out[20]:
   data2 key  data1
0      0   a      0
1      1   b      1
2      1   b      2
3      2   c    NaN

3.多鍵連接時將連接鍵組成列表傳入，例：pd.merge(df1,df2,on=['key1','key2']

In [23]: right=DataFrame({'key1':['foo','foo','bar','bar'],
    ...:     'key2':['one','one','one','two'],
    ...:     'lval':[4,5,6,7]})

In [24]: left=DataFrame({'key1':['foo','foo','bar'],
    ...:     'key2':['one','two','one'],
    ...:     'lval':[1,2,3]})

In [25]: right=DataFrame({'key1':['foo','foo','bar','bar'],
    ...:     'key2':['one','one','one','two'],
    ...:     'lval':[4,5,6,7]})

In [26]: pd.merge(left,right,on=['key1','key2'],how='outer')  #傳出數組
Out[26]:
  key1 key2  lval_x  lval_y
0  foo  one       1       4
1  foo  one       1       5
2  foo  two       2     NaN
3  bar  one       3       6
4  bar  two     NaN       7

4.如果兩個對象的列名不同，可以分別指定，例：pd.merge(df1,df2,left_on='lkey',right_on='rkey')

In [31]: df3=DataFrame({'key3':['foo','foo','bar','bar'], #將上面的right的key 改了名字
    ...:     'key4':['one','one','one','two'],
    ...:     'lval':[4,5,6,7]})

In [32]: pd.merge(left,df3,left_on='key1',right_on='key3')  #鍵名不同的連接
Out[32]:
  key1 key2  lval_x key3 key4  lval_y
0  foo  one       1  foo  one       4
1  foo  one       1  foo  one       5
2  foo  two       2  foo  one       4
3  foo  two       2  foo  one       5
4  bar  one       3  bar  one       6
5  bar  one       3  bar  two       7

5.以索引當做連接鍵，使用參數left_index=true,right_index=True （最好使用join）

join 拼接列，主要用於索引上的合併

join方法提供了一個簡便的方法用於將兩個DataFrame中的不同的列索引合併成爲一個DataFrame

join(self, other, on=None, how='left', lsuffix='', rsuffix='',sort=False):

其中參數的意義與merge方法基本相同,只是join方法默認爲左外連接how=left

1.默認按索引合併，可以合併相同或相似的索引，不管他們有沒有重疊列。

2.可以連接多個DataFrame

3.可以連接除索引外的其他列

4.連接方式用參數how控制

5.通過lsuffix='', rsuffix='' 區分相同列名的列

concat  可以沿着一條軸將多個對象堆疊到一起

concat方法相當於數據庫中的全連接(UNION ALL),可以指定按某個軸進行連接,也可以指定連接的方式join(outer,inner 只有這兩種)。與數據庫不同的時concat不會去重，要達到去重的效果可以使用drop_duplicates方法

concat(objs, axis=0, join='outer', join_axes=None, ignore_index=False,
          keys=None, levels=None, names=None, verify_integrity=False, copy=True):

軸向連接 pd.concat() 就是單純地把兩個表拼在一起，這個過程也被稱作連接（concatenation）、綁定（binding）或堆疊（stacking）。因此可以想見，這個函數的關鍵參數應該是 axis，用於指定連接的軸向。

在默認的 axis=0 情況下，pd.concat([obj1,obj2]) 函數的效果與 obj1.append(obj2) 是相同的；

而在 axis=1 的情況下，pd.concat([df1,df2],axis=1) 的效果與 pd.merge(df1,df2,left_index=True,right_index=True,how='outer') 是相同的。

可以理解爲 concat 函數使用索引作爲“連接鍵”。
本函數的全部參數爲：

pd.concat(objs, axis=0, join='outer', join_axes=None, ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False)。

objs 就是需要連接的對象集合，一般是列表或字典；

axis=0 是連接軸向join='outer' 參數作用於當另一條軸的 index 不重疊的時候，只有 'inner' 和 'outer' 可選（順帶展示 ignore_index=True 的用法）

concat 一些特點：

1.作用於Series時，如果在axis=0時，類似union。axis=1 時，組成一個DataFrame，索引是union後的，列是類似join後的結果。

2.通過參數join_axes=[] 指定自定義索引。

3.通過參數keys=[] 創建層次化索引

4.通過參數ignore_index=True 重建索引。

In [5]: df1=DataFrame(np.random.randn(3,4),columns=['a','b','c','d'])

In [6]: df2=DataFrame(np.random.randn(2,3),columns=['b','d','a'])

In [7]: pd.concat([df1,df2])
Out[7]:
          a         b         c         d
0 -0.848557 -1.163877 -0.306148 -1.163944
1  1.358759  1.159369 -0.532110  2.183934
2  0.532117  0.788350  0.703752 -2.620643
0 -0.316156 -0.707832       NaN -0.416589
1  0.406830  1.345932       NaN -1.874817

In [8]: pd.concat([df1,df2],ignore_index=True)
Out[8]:
          a         b         c         d
0 -0.848557 -1.163877 -0.306148 -1.163944
1  1.358759  1.159369 -0.532110  2.183934
2  0.532117  0.788350  0.703752 -2.620643
3 -0.316156 -0.707832       NaN -0.416589
4  0.406830  1.345932       NaN -1.874817