使用pandas拼接
1. pd.merge()
功能：用於通過一個或多個鍵將兩個數據集的行連接起來，類似於 SQL 中的 JOIN。
語法如下：
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)
應用場景是：把主鍵相同，字段不同的兩張表合並到一張表里。結果集的行數並沒有增加，列數則為兩個元數據的列數和減去連接鍵的數量。
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：將列添加到輸出綜合呼吁_merge與信息源的每一行。_merge是絕對類型，並對觀測其合並鍵只出現在'左'的綜合，觀測其合並鍵只會出現在'正確'的綜合，
和兩個如果觀察合並關鍵發現在兩個right_onlyleft_only的值。在 0.17.0中還增加了一個顯示合並數據中來源情況；如只來自己於左邊(left_only)、兩者(both)
我們先上實例，再分析解說
df1=DataFrame({'key':['a','b','b'],'data1':range(3)})
df2=DataFrame({'key':['a','b','c'],'data2':range(3)})
pd.merge(df1,df2)
結果：
df1
Out[3]:
key data1
0 a 0
1 b 1
2 b 2
df2
Out[4]:
key data2
0 a 0
1 b 1
2 c 2
df
Out[5]:
key data1 data2
0 a 0 0
1 b 1 1
2 b 2 1
注意，pandas拼接的要求是，有一列相同，每列長度相同。長度不同時，會提示：raise ValueError("arrays must all be same length")
如果：把上面的數據改一下，會得到什么呢？
df1=pd.DataFrame({'key':['a','b','b'],'data1':range(3)})
df2=pd.DataFrame({'key':['x','y','z'],'data2':range(3)})
df=pd.merge(df1,df2)
將上面的語句修改一下：
df=pd.merge(df1,df2,how='outer',on='key')
df
Out[33]:
key data1 data2
0 a 0.0 NaN
1 b 1.0 NaN
2 b 2.0 NaN
3 x NaN 0.0
4 y NaN 1.0
5 z NaN 2.0
如果覺得這樣得到的結果不好看，把NaN用0代替，可以用下面的語句
df1=pd.merge(df1,df2,how='outer',on='key').fillna(0)
df1
Out[35]:
key data1 data2
0 a 0.0 0.0
1 b 1.0 0.0
2 b 2.0 0.0
3 x 0.0 0.0
4 y 0.0 1.0
5 z 0.0 2.0
pandas.merge()的outer連接
right=pd.DataFrame({'key1':['foo','foo','bar','bar'],
'key2':['one','one','one','two'],
'lval':[4,5,6,7]})
left=pd.DataFrame({'key1':['foo','foo','bar'],
'key2':['one','two','one'],
'lval':[1,2,3]})
df_outer= pd.merge(left,right,on=['key1','key2'],how='outer')
得到：
####right
Out[18]:
key1 key2 lval
0 foo one 4
1 foo one 5
2 bar one 6
3 bar two 7
####left
Out[19]:
key1 key2 lval
0 foo one 1
1 foo two 2
2 bar one 3
####df_outer
Out[21]:
key1 key2 lval_x lval_y
0 foo one 1.0 4.0
1 foo one 1.0 5.0
2 foo two 2.0 NaN
3 bar one 3.0 6.0
4 bar two NaN 7.0
如果兩個對象的列名不同，可以分別指定，例：pd.merge(df1,df2,left_on='lkey',right_on='rkey')
df3=pd.DataFrame({'key3':['foo','foo','bar','bar'], #將上面的right的key 改了名字
'key4':['one','one','one','two'],
'lval':[4,5,6,7]})
df_on=pd.merge(left,df3,left_on='key1',right_on='key3') #鍵名不同的連接
得到：
left
Out[19]:
key1 key2 lval
0 foo one 1
1 foo two 2
2 bar one 3
df3
Out[24]:
key3 key4 lval
0 foo one 4
1 foo one 5
2 bar one 6
3 bar two 7
df_on
Out[25]:
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
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 函數使用索引作為“連接鍵”。
本函數的全部參數為：
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 重建索引。
===
數據量大時生成DataFrame，應避免使用append方法
因為：
與python列表中的append和extend方法不同的是pandas的append方法不會改變原來的對象，而是創建一個新的對象。當然，這樣的話會使效率變低而且會占用更多內存，所以如果你有很多數據需要append，建議使用列表，然后傳給DataFrame。
建議直接用空列表依次裝好各列的數據，再統一生成總的dataframe表，如下例所示。
import pandas as pd
import numpy as np
from datetime import datetime
# 模擬生成較大批次量的數據
df_list = [pd.DataFrame({
'a': [np.random.rand() for _ in range(20000)],
'b': [np.random.rand() for _ in range(20000)]
}) for i in range(800)]
# %% 第一種方式（運行時間最長——1分鍾，內存占用一般）
start1 = datetime.now()
res1 = pd.DataFrame()
for df in df_list:
res1 = res1.append(df)
print('append耗時：%s秒' % (datetime.now() - start1))
# %% 第二種方式（運行時間相對第一種少一些——46秒，但內存接近溢出）
start2 = datetime.now()
dict_list = [df.to_dict() for df in df_list]
combine_dict = {}
i = 0
for dic in dict_list:
length = len(list(dic.values())[0])
for idx in range(length):
combine_dict[i] = {k: dic[k][idx] for k in dic.keys()}
i += 1
res2 = pd.DataFrame.from_dict(combine_dict, 'index')
print('dict合並方式耗時：%s秒' % (datetime.now() - start2))
# %% 第三種方式：list裝好所有值（運行時間最短——4秒多，內存占用低）
start3 = datetime.now()
columns = ['a', 'b']
a_list = []
b_list = []
4
for df in df_list:
a_list.extend(df['a'])
b_list.extend(df['b'])
res3 = pd.DataFrame({'a': a_list, 'b': b_list})
print('list裝好所有值方式耗時：%s秒' % (datetime.now() - start3))