Pandas提供了concat赂乐，merge薯鳍，join和append四種方法用于dataframe的拼接，其區(qū)別如下：

pandas.concat()函數(shù)詳解

語(yǔ)法格式：

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)

objs：series嫡霞，dataframe或者是panel對(duì)象構(gòu)成的序列l(wèi)sit
axis：指明連接的軸向， {0/’index’（行）, 1/’columns’（列）}背亥，默認(rèn)為0
join：指明連接方式 秒际， {‘inner’（交集）, ‘outer（并集）’}悬赏，默認(rèn)為outer
join_axes：自定義的索引狡汉。指明用其他n-1條軸的索引進(jìn)行拼接娄徊， 而非默認(rèn)join =’ inner’或’outer’方式拼接
keys：創(chuàng)建層次化索引《艽鳎可以是任意值的列表或數(shù)組寄锐、元組數(shù)組、數(shù)組列表（如果將levels設(shè)置成多級(jí)數(shù)組的話）
ignore_index=True：重建索引

核心功能：

兩個(gè)DataFrame通過(guò)pd.concat()尖啡，既可實(shí)現(xiàn)行拼接又可實(shí)現(xiàn)列拼接橄仆，默認(rèn)axis=0，join='outer'衅斩。表df1和df2的行索引（index）和列索引（columns）均可以重復(fù)盆顾。

設(shè)置join='outer'，只是沿著一條軸畏梆，單純將多個(gè)對(duì)象拼接到一起您宪，類(lèi)似數(shù)據(jù)庫(kù)中的全連接（union all）。
　　a. 當(dāng)axis=0（行拼接）時(shí)奠涌，使用pd.concat([df1,df2])宪巨，拼接表的index=index(df1) + index(df2)，拼接表的columns=columns(df1) ∪ columns(df2)溜畅，缺失值填充N(xiāo)aN捏卓。
　　b. 當(dāng)axis=1（列拼接）時(shí)，使用pd.concat([df1,df2],axis=1)慈格，拼接表的index=index(df1) ∪ index(df2)怠晴，拼接表的columns=columns(df1) + columns(df2)，缺失值填充N(xiāo)aN浴捆。
　　備注： index(df1) + index(df2) 表示：直接在df1的index之后 直接累加 df2的index龄寞；columns(df1) ∪columns(df2)表示：df1的columns和df2的columns 累加去重 ，下同汤功。
　　a. 當(dāng)axis=0時(shí)物邑，pd.concat([obj1, obj2])與obj1.append(obj2)的效果是相同的，使用參數(shù)key可以為每個(gè)數(shù)據(jù)集（bj1, obj2）指定塊標(biāo)記滔金；
　　b. 當(dāng)axis=1時(shí)色解，pd.concat([obj1, obj2], axis=1)與pd.merge(obj1, obj2, left_index=True, right_index=True, how='outer') 的效果是相同的。
設(shè)置join='inner'餐茵，拼接方式為“交聯(lián)”科阎，即：行拼接時(shí)，僅保留df1和df２列索引重復(fù)的列忿族；列拼接時(shí)锣笨，僅保留df1和df２行索引重復(fù)的行蝌矛。
　　a. 當(dāng)axis=0（行拼接）時(shí)，使用pd.concat([df1,df4],join='inner')错英，拼接表的index=index(df1) + index(df2)入撒，拼接表的columns=columns(df1) ∩ columns(df2)；
　　b. 當(dāng)axis=1（列拼接）時(shí)椭岩，pd.concat([df1,df4],axis=1,join='inner')茅逮，拼接表的index=index(df1) ∩ index(df2)，拼接表的columns=columns(df1) + columns(df2)判哥；
　　備注：　columns(df1) ∩columns(df2)表示：df1的columns和df2的columns 重復(fù)相同 献雅，下同。

常見(jiàn)示例：
a.列名（columns）相同塌计，行索引（index）無(wú)重復(fù)項(xiàng)的表df1挺身、df2、df3實(shí)現(xiàn)行拼接：

import numpy as np
import pandas as pd
#樣集1
df1=pd.DataFrame({'A':['A0','A1','A2','A3'],'B':['B0','B1','B2','B3'],
                  'C':['C0','C1','C2','C3'],'D':['D0','D1','D2','D3']},
                index=[0,1,2,3])
#樣集2
df2=pd.DataFrame({'A':['A4','A5','A6','A7'],'B':['B4','B5','B6','B7'],
                  'C':['C4','C5','C6','C7'],'D':['D4','D5','D6','D7']},
                  index=[4,5,6,7])   
#樣集3
df3=pd.DataFrame({'A':['A8','A9','A10','A11'],'B':['B8','B9','B10','B11'],
                  'C':['C8','C9','C10','C11'],'D':['D8','D9','D10','D11']},
                index=[8,9,10,11])   
#樣集4
df4=pd.DataFrame({'B':['B2','B3','B6','B7'],'D':['D2','D3','D6','D7'],
                  'F':['F2','F3','F6','F7']},index=[2,3,6,7])
#樣集1锌仅、2章钾、3、4詳見(jiàn)圖1.1（a）                                                             
#列名（columns）相同技扼，行索引（index）無(wú)重復(fù)項(xiàng)的表df1伍玖、df2、df3實(shí)現(xiàn)行拼接
frames = [df1, df2, df3]
pd.concat(frames)                           #效果見(jiàn)圖1.1（b）
#使用參數(shù)key可以為每個(gè)數(shù)據(jù)集指定塊標(biāo)記
pd.concat(frames,keys=[ 'x','y','z' ])      #效果見(jiàn)圖1.1（c）

如圖1.1所示

1.1.png

## 使用concat()實(shí)現(xiàn)df1窍箍、df4行拼接               
result = pd.concat( [df1,df4] )              #效果見(jiàn)圖1.2（b）
#使用concat()實(shí)現(xiàn)df1、df4列拼接
result = pd.concat( [df1,df4] , axis=1 )     #效果見(jiàn)圖1.2（c）

1.2.png

#concat修改join='inner'椰棘，只保留重復(fù)列索引的行拼接
result=pd.concat([df1,df4],join='inner')   #效果見(jiàn)圖1.3（b）
#concat修改join='inner'，只保留重復(fù)行索引的列拼接
result=pd.concat([df1,df4],axis=1,join='inner')     #效果見(jiàn)圖1.3（c）
#利用參數(shù)join_axes=[df1.index]指定concat按照df1的行索引進(jìn)行列拼接榄笙，df2僅保留行索引與df1重復(fù)的部分     
result=pd.concat( [df1,df4],axis=1,join_axes=[df1.index] )   #效果見(jiàn)圖1.3（d）

1.3.png

pandas.merge()函數(shù)詳解

語(yǔ)法格式

DataFrame.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和right：兩個(gè)不同的DataFrame或Series
how：連接方式邪狞，有inner、left茅撞、right帆卓、outer，默認(rèn)為inner
on：用于連接的列索引名稱(chēng)米丘，必須同時(shí)存在于左剑令、右兩個(gè)DataFrame中，默認(rèn)是以?xún)蓚€(gè)DataFrame列名的交集作為連接鍵拄查，若要實(shí)現(xiàn)多鍵連接吁津，‘on’參數(shù)后傳入多鍵列表即可
left_on：左側(cè)DataFrame中用于連接鍵的列名，這個(gè)參數(shù)在左右列名不同但代表的含義相同時(shí)非常有用堕扶；
right_on：右側(cè)DataFrame中用于連接鍵的列名
left_index：使用左側(cè)DataFrame中的行索引作為連接鍵（ 但是這種情況下最好用JOIN）
right_index：使用右側(cè)DataFrame中的行索引作為連接鍵（ 但是這種情況下最好用JOIN）
sort：默認(rèn)為False碍脏，將合并的數(shù)據(jù)進(jìn)行排序梭依，設(shè)置為False可以提高性能
suffixes：字符串值組成的元組，用于指定當(dāng)左右DataFrame存在相同列名時(shí)在列名后面附加的后綴名稱(chēng)典尾，默認(rèn)為(’_x’, ‘_y’)
copy：默認(rèn)為T(mén)rue役拴，總是將數(shù)據(jù)復(fù)制到數(shù)據(jù)結(jié)構(gòu)中，設(shè)置為False可以提高性能
indicator：顯示合并數(shù)據(jù)中數(shù)據(jù)的來(lái)源情況.

核心功能
類(lèi)似于關(guān)系型數(shù)據(jù)庫(kù)的連接方式急黎，可以根據(jù)一個(gè)或多個(gè)鍵將兩張不同的DatFrame連接起來(lái)扎狱，由于默認(rèn)how='inner'侧到，故合并表僅保留key重名的行勃教，不重名的行將被丟棄。（ 備注： merge()只能完成兩張表的連接匠抗，若有三個(gè)及以上表故源，需不斷兩兩合并來(lái)實(shí)現(xiàn)） 該函數(shù)的典型應(yīng)用場(chǎng)景： 兩張表有相同內(nèi)容的某一列（類(lèi)似SQL中的主鍵），欲根據(jù)主鍵將兩張表進(jìn)行列拼接整合到一張表中汞贸，合并表的列數(shù)等于兩個(gè)原數(shù)據(jù)表的列數(shù)和減去連接鍵的數(shù)量绳军。

df1和df2的列索引（columns）僅有一項(xiàng)重復(fù)（即：col_1(df1)=col_1(df2)）時(shí)，存在如下三種類(lèi)型的數(shù)據(jù)合并：一對(duì)一矢腻、多對(duì)一门驾、多對(duì)多，其拼接規(guī)則如下：

1. 一對(duì)一：若df1（左表）和df2（右表）的重名列col_1(df1)和col_1(df2)中多柑，各列的值均不重復(fù)奶是，通過(guò)pd.merge()方法能夠自動(dòng)識(shí)別相同的行作為主鍵，進(jìn)行列拼接（拼接原理類(lèi)似基因配對(duì)竣灌，拼接過(guò)程示意圖見(jiàn)圖1.4）聂沙； 備注： 共同列中的元素位置可以不一致，pd.merge()能夠自動(dòng)選取相同的行進(jìn)行拼接初嘹。另外及汉，pd.merge()默認(rèn)會(huì)丟棄原來(lái)的索引，重新生成索引屯烦。 　　 2.多對(duì)一：若df1（左表）和df2（右表）的重名列col_1(df1)和col_1(df2)坷随，有一列的值有重復(fù)，通過(guò)多對(duì)一合并獲得的連接表將會(huì)保留重復(fù)值驻龟。

2. 多對(duì)多：若df1（左表）和df2（右表）的重名列col_1(df1)和col_1(df2)都包含重復(fù)值温眉，那么通過(guò)多對(duì)多合并獲得的連接表將會(huì)保留所有重復(fù)值。 備注： 若重名列col_1(df1)有m行重名和col_1(df2)有n行重名迅脐，則合并表將有m×n行數(shù)據(jù)
   1.4.png

3. df1和df2的列索引（columns）有兩項(xiàng)及以上重復(fù)（即：col_1(df1)=col_1(df2)芍殖，col_2(df1)=col_2(df2)，…）時(shí)谴蔑，即：實(shí)現(xiàn)多鍵連接豌骏，僅需在'on'參數(shù)后傳入多鍵列表即可.

常見(jiàn)示例
a. 兩張表df1和df2的列名有重疊龟梦，且重疊列的內(nèi)容完全相同，直接用pd.merge(df1, df2)

#樣集1
df1=pd.DataFrame(np.arange(12).reshape(3,4),columns=['a','b','c','d'])
>>> df1
   a  b   c   d
0  0  1   2   3
1  4  5   6   7
2  8  9  10  11
#樣集2
df2=pd.DataFrame({'b':[1,5],'d':[3,7],'a':[0,4]})  
>>> df2
   b  d  a
0  1  3  0
1  5  7  4
#兩張表df1和df2的列名有重疊窃躲，且重疊列的內(nèi)容完全相同计贰，直接用pd.merge(df1, df2)
pd.merge(df1,df2)  
>>>
    a   b   c   d
0   0   1   2   3
1   4   5   6   7  

b. 兩張表df1和df2的列名有重疊，但重疊列的內(nèi)容完全不同蒂窒，須使用pd.merge(df1, df2, left_index=True, right_index=True, how='left')
（備注： 如果直接用pd.merge(df1, df2)躁倒，將會(huì)得到一張空表，故必須指定行索引參數(shù)left_index, right_index洒琢，這種情況下最好使用join實(shí)現(xiàn)秧秉。）

#樣集1
df1=pd.DataFrame(np.arange(12).reshape(3,4),columns=['a','b','c','d'])
>>>df1
   a  b   c   d
0  0  1   2   3
1  4  5   6   7
2  8  9  10  11
#樣集2
df2=pd.DataFrame({'b':[15,6],'d':[1,11],'a':[0,6]}) 
>>>df2
    b   d  a
0  15   1  0
1   6  11  6
#b. 兩張表df1和df2的列名有重疊，但重疊列的內(nèi)容完全不同
pd.merge(df1, df2, left_index=True, right_index=True, how='left')    
>>>
   a_x  b_x c   d_x   b_y   d_y   a_y
0   0   1   2   3    15.0   1.0   0.0
1   4   5   6   7    6.0    11.0  6.0
2   8   9   10  11   NaN    NaN   NaN

pandas.join()函數(shù)詳解

語(yǔ)法格式:

DataFrame.join(other, on=None, how='left', lsuffix=' ', rsuffix=' ', sort=False)

參數(shù)的意義與merge方法基本相同衰抑，只是join方法默認(rèn)為左外連接how=’left’

核心功能:

該函數(shù)的典型應(yīng)用場(chǎng)景：無(wú)重復(fù)列名的兩個(gè)表df1和df2 基于行索引進(jìn)行列拼接象迎，直接使用df1.join(df2)即可,無(wú)需添加任何參數(shù)，合并表的行數(shù)與left表相同呛踊，列數(shù)為left表+right表的列數(shù)之和砾淌，結(jié)果僅保留left表和right表中行索引相同的行，對(duì)列不做任何處理谭网。如果兩個(gè)表有重復(fù)的列名汪厨，需指定lsuffix, rsuffix參數(shù)。
　　利用join也可 基于列索引進(jìn)行列拼接愉择，需借助參數(shù)‘on’劫乱。常見(jiàn)的基于列索引的列拼接方式有3種：
（Ⅰ）列名不同，列內(nèi)容有相同：需要用到 l.join(r.set_index(key of r), on='key of l')
（Ⅱ）列名和列內(nèi)容均有相同：需要用到l.join(r.set_index(key), on='key')
（Ⅲ）列名不同薄辅，列內(nèi)容也不同：這種情況是典型的基于行索引進(jìn)行列拼接要拂，不能用JOIN的ON參數(shù)。
JOIN 拼接列站楚，主要用于基于行索引上的合并脱惰。

常見(jiàn)示例：

a. 無(wú)重復(fù)列名的兩個(gè)表df1和df3基于 行索引，進(jìn)行列拼接窿春，直接使用df1.join(df2)即可
b. 有重復(fù)列名的兩個(gè)表df1和df2（即使內(nèi)容沒(méi)有重復(fù)）基于 行索引拉一，進(jìn)行列拼接，使用df1.join(df2)時(shí)需要指定lsuffix, rsuffix參數(shù)旧乞，即：df1.join(df2, lsuffix='_l', rsuffix='_r')蔚润，否則會(huì)報(bào)錯(cuò)

#樣集1
df1=pd.DataFrame(np.arange(12).reshape(3,4),columns=['a','b','c','d'])
>>>df1
   a  b   c   d
0  0  1   2   3
1  4  5   6   7
2  8  9  10  11
#樣集2
df2=pd.DataFrame({'b':[15,6],'d':[1,11],'a':[0,6]})
>>>df2
    b   d  a
0  15   1  0
1   6  11  6
#用join合并表df1和表df2,需指定lsuffix, rsuffix參數(shù),標(biāo)識(shí)兩個(gè)表的重復(fù)列名
df1.join(df2, lsuffix='_l', rsuffix='_r') 
>>>
   a_l  b_l  c   d_l    b_r  d_r    a_r
0   0   1    2   3     15.0  1.0    0.0
1   4   5    6   7     6.0   11.0   6.0
2   8   9    10  11    NaN   NaN    NaN

c. 列名不同，列內(nèi)容有相同的兩個(gè)表df1和df2基于 列索引尺栖，進(jìn)行列拼接嫡纠，使用l.join(r.set_index(key of r), on='key of l')，這種JOIN的寫(xiě)法等同于前面提到的merge設(shè)置left_on,right_on（備注：#列名不同，使用merge進(jìn)行列拼接時(shí)除盏，內(nèi)容相同的行可以作為鍵）叉橱，因?yàn)閙erge默認(rèn)是內(nèi)連接，所以返回的結(jié)果只有一行者蠕，而JOIN返回的結(jié)果是以左表的key列為準(zhǔn)窃祝，有兩行。

#樣集1
left=pd.DataFrame({'key1':['foo','bar1'],'lval':[1,2]})
>>>left
    key1  lval
0    foo     1
1   bar1     2
#樣集2
right=pd.DataFrame({'key2':['foo','bar'],'rval':[4,5]})
>>>right
   key2  rval
0  foo     4
1  bar     5
#列名不同踱侣，列內(nèi)容有相同的兩個(gè)表df1和df2基于列索引粪小，進(jìn)行列拼接
left.join(right.set_index('key2'),on='key1')  #.set_index()設(shè)置表right的列索引
>>>
    key1    lval   rval
0   foo     1      4.0
1   bar1    2      NaN

d. 列名和列內(nèi)容均有相同的兩個(gè)表df1和df2基于 列索引，進(jìn)行列拼接抡句，使用l.join(r.set_index(key), on='key')探膊，這種JOIN的寫(xiě)法等同于前面提到的merge設(shè)置不帶任何參數(shù)，而且這種情況下merge會(huì)去掉重復(fù)的列

#樣集1
left=pd.DataFrame({'key':['foo','bar1'],'lval':[1,2]})
>>>
    key  lval
0   foo     1
1  bar1     2
#樣集2
right=pd.DataFrame({'key':['foo','bar'],'rval':[4,5]})
>>>
   key  rval
0  foo     4
1  bar     5
#列名和列內(nèi)容均部分相同的表df1和df2進(jìn)行基于列索引玉转，列拼接
left.join(right.set_index('key'),on='key')
>>>
    key   lval  rval
0   foo     1   4.0
1   bar1    2   NaN
#樣集3
left=pd.DataFrame({'key':['foo','bar1'],'val':[1,2]})
>>>
    key   val
0   foo     1
1   bar1    2
#樣集4
right=pd.DataFrame({'key':['foo','bar'],'val':[4,5]})
>>>
   key  val
0  foo    4
1  bar    5
#列名相同突想，列內(nèi)容部分相同的表df1和df2基于列索引進(jìn)行列合并殴蹄，必須用參數(shù)lsuffix='_l',rsuffix='_r'指定重名列的下標(biāo)究抓，否則報(bào)錯(cuò)
left.join(right.set_index('key'),on='key',lsuffix='_l',rsuffix='_r')
>>>
    key   val_l  val_r
0   foo     1    4.0
1   bar1    2    NaN
#特別注意，即使列名相同了袭灯，也必須用到' set_index(key)' 否則直接使用
left.join(right,on='key',lsuffix='_l',rsuffix='_r')
>>> ValueError: You are trying to merge on object and int64 columns. If you wish to proceed you should use pd.concat
#另外需明確刺下，不指定'ON= '參數(shù)的情況下，JOIN是按行索引進(jìn)行列拼接稽荧，不對(duì)列進(jìn)行任何操作橘茉。
left.join(right,lsuffix='_l',rsuffix='_r')
>>>
        key_l   val_l   key_r   val_r
0       foo      1       foo    4
1       bar1     2       bar    5

DataFrame.append()函數(shù)詳解

語(yǔ)法格式

DataFrame.append(other, ignore_index=False, verify_integrity=False, sort=None)

other: DataFrame or Series/dict-like object, or list of these
The data to append.
ignore_index : boolean, default False
If True, do not use the index labels.
verify_integrity : boolean, default False
If True, raise ValueError on creating index with duplicates.
sort: boolean, default None
只是join方法默認(rèn)為左外連接how=’left’

核心功能：

append是concat的簡(jiǎn)略形式,只不過(guò)只能在axis=0上進(jìn)行合并

df1.append(df2),df1.append(df2,ignore_index=True)

DataFrame和Series進(jìn)行合并的時(shí)候需要使用參數(shù)ignore_index=True或者含有屬性name，因?yàn)镾eries是只有一維索引的（備注：如果不添加參數(shù)ignore_index=True姨丈，那么會(huì)出錯(cuò)的畅卓。）

原文鏈接：https://blog.csdn.net/weixin_42782150/article/details/89546357