Python 数据分析三剑客之 Pandas（七）：合并数据集
生活随笔
收集整理的這篇文章主要介紹了
Python 数据分析三剑客之 Pandas（七）：合并数据集
小編覺得挺不錯的,現在分享給大家,幫大家做個參考.
CSDN 課程推薦：《邁向數據科學家：帶你玩轉Python數據分析》，講師齊偉，蘇州研途教育科技有限公司CTO，蘇州大學應用統計專業碩士生指導委員會委員；已出版《跟老齊學Python：輕松入門》《跟老齊學Python：Django實戰》、《跟老齊學Python：數據分析》和《Python大學實用教程》暢銷圖書。
Pandas 系列文章：
- Python 數據分析三劍客之 Pandas（一）：認識 Pandas 及其 Series、DataFrame 對象
- Python 數據分析三劍客之 Pandas（二）：Index 索引對象以及各種索引操作
- Python 數據分析三劍客之 Pandas（三）：算術運算與缺失值的處理
- Python 數據分析三劍客之 Pandas（四）：函數應用、映射、排序和層級索引
- Python 數據分析三劍客之 Pandas（五）：統計計算與統計描述
- Python 數據分析三劍客之 Pandas（六）：GroupBy 數據分裂、應用與合并
- Python 數據分析三劍客之 Pandas（七）：合并數據集
- Python 數據分析三劍客之 Pandas（八）：數據重塑、重復數據處理與數據替換
- Python 數據分析三劍客之 Pandas（九）：時間序列
- Python 數據分析三劍客之 Pandas（十）：數據讀寫
另有 NumPy、Matplotlib 系列文章已更新完畢，歡迎關注：
- NumPy 系列文章：https://itrhx.blog.csdn.net/category_9780393.html
- Matplotlib 系列文章：https://itrhx.blog.csdn.net/category_9780418.html
推薦學習資料與網站（博主參與部分文檔翻譯）：
- NumPy 官方中文網：https://www.numpy.org.cn/
- Pandas 官方中文網：https://www.pypandas.cn/
- Matplotlib 官方中文網：https://www.matplotlib.org.cn/
- NumPy、Matplotlib、Pandas 速查表：https://github.com/TRHX/Python-quick-reference-table
文章目錄
- 【01x00】concat
- 【02x00】append
- 【03x00】merge
- 【03x01】一對一連接
- 【03x02】多對一連接
- 【03x03】多對多連接
- 【03x04】參數 on / left_on / right_on
- 【03x05】參數 how
- 【03x06】參數 suffixes
- 【03x07】參數 left_index / right_index
- 【04x00】join
- 【05x00】四種方法的區別
這里是一段防爬蟲文本，請讀者忽略。 本文原創首發于 CSDN，作者 TRHX。 博客首頁：https://itrhx.blog.csdn.net/ 本文鏈接：https://itrhx.blog.csdn.net/article/details/106830112 未經授權，禁止轉載！惡意轉載，后果自負！尊重原創，遠離剽竊！
【01x00】concat
pandas.concat 可以沿著指定軸將多個對象堆疊到一起。
官方文檔：https://pandas.pydata.org/docs/reference/api/pandas.concat.html
基本語法：
pandas.concat(objs: Union[Iterable[‘DataFrame’], Mapping[Optional[Hashable], ‘DataFrame’]],axis='0',join: str = "'outer'",ignore_index: bool = 'False',keys='None',levels='None',names='None',verify_integrity: bool = 'False',sort: bool = 'False',copy: bool = 'True') → ’DataFrame’ pandas.concat(objs: Union[Iterable[FrameOrSeriesUnion], Mapping[Optional[Hashable], FrameOrSeriesUnion]],axis='0',join: str = "'outer'",ignore_index: bool = 'False',keys='None',levels='None',names='None',verify_integrity: bool = 'False',sort: bool = 'False',copy: bool = 'True') → FrameOrSeriesUnion常用參數描述：
| objs | Series 或 DataFrame 對象的序列或映射，要合并的對象 |
| axis | 沿指定軸合并，0 or ‘index’，1 or ‘columns’，只有在 DataFrame 中才有 1 or 'columns’ |
| join | 如何處理其他軸（或多個軸）上的索引，可取值：‘inner’，‘outer’（默認值） ‘outer’：當 axis = 0 時，列名相同的列會合并，其余列都保留（并集），空值填充； ‘inner’：當 axis = 0 時，列名相同的列會合并，其余列都舍棄（交集） |
| ignore_index | bool 類型，連接后的值是否使用原索引值，如果為 True，則索引將會是 0, 1, …, n-1 |
| keys | 序列形式，默認 None，傳遞 keys 后，會構造一個層次索引，即 MultiIndex 對象，keys 為最外層索引 |
| levels | 用于構造 MultiIndex 的特定級別（唯一值）。未指定則將從鍵中推斷出來 |
| names | 列表類型，為索引添加標簽 |
| verify_integrity | bool 類型，是否檢查合并后的索引有無重復項，設置為 True 若有重復項則會報錯 |
| sort | 當 join='outer' 時對列索引進行排序。當 join='inner' 時此操作無效 |
合并兩個 Series 對象：
>>> import pandas as pd >>> obj1 = pd.Series(['a', 'b']) >>> obj2 = pd.Series(['c', 'd']) >>> pd.concat([obj1, obj2]) 0 a 1 b 0 c 1 d dtype: object設置 ignore_index=True，放棄原有的索引值：
>>> import pandas as pd >>> obj1 = pd.Series(['a', 'b']) >>> obj2 = pd.Series(['c', 'd']) >>> pd.concat([obj1, obj2], ignore_index=True) 0 a 1 b 2 c 3 d dtype: object設置 keys 參數，添加最外層的索引：
>>> import pandas as pd >>> obj1 = pd.Series(['a', 'b']) >>> obj2 = pd.Series(['c', 'd']) >>> pd.concat([obj1, obj2], keys=['s1', 's2']) s1 0 a1 b s2 0 c1 d dtype: object設置 names 參數，為索引添加標簽：
>>> import pandas as pd >>> obj1 = pd.Series(['a', 'b']) >>> obj2 = pd.Series(['c', 'd']) >>> pd.concat([obj1, obj2], keys=['s1', 's2'], names=['Series name', 'Row ID']) Series name Row ID s1 0 a1 b s2 0 c1 d dtype: object合并 DataFrame 對象：
>>> import pandas as pd >>> obj1 = pd.DataFrame([['a', 1], ['b', 2]], columns=['letter', 'number']) >>> obj2 = pd.DataFrame([['c', 3], ['d', 4]], columns=['letter', 'number']) >>> obj1letter number 0 a 1 1 b 2 >>> >>> obj2letter number 0 c 3 1 d 4 >>> >>> pd.concat([obj1, obj2])letter number 0 a 1 1 b 2 0 c 3 1 d 4合并 DataFrame 對象，不存在的值將會被 NaN 填充：
>>> import pandas as pd >>> obj1 = pd.DataFrame([['a', 1], ['b', 2]], columns=['letter', 'number']) >>> obj2 = pd.DataFrame([['c', 3, 'cat'], ['d', 4, 'dog']], columns=['letter', 'number', 'animal']) >>> obj1letter number 0 a 1 1 b 2 >>> >>> obj2letter number animal 0 c 3 cat 1 d 4 dog >>> >>> pd.concat([obj1, obj2])letter number animal 0 a 1 NaN 1 b 2 NaN 0 c 3 cat 1 d 4 dog合并 DataFrame 對象，設置 join="inner" 不存在的列將會舍棄：
>>> import pandas as pd >>> obj1 = pd.DataFrame([['a', 1], ['b', 2]], columns=['letter', 'number']) >>> obj2 = pd.DataFrame([['c', 3, 'cat'], ['d', 4, 'dog']], columns=['letter', 'number', 'animal']) >>> obj1letter number 0 a 1 1 b 2 >>> >>> obj2letter number animal 0 c 3 cat 1 d 4 dog >>> >>> pd.concat([obj1, obj2], join="inner")letter number 0 a 1 1 b 2 0 c 3 1 d 4合并 DataFrame 對象，設置 axis=1 沿 y 軸合并（增加列）：
>>> import pandas as pd >>> obj1 = pd.DataFrame([['a', 1], ['b', 2]], columns=['letter', 'number']) >>> obj2 = pd.DataFrame([['bird', 'polly'], ['monkey', 'george']], columns=['animal', 'name']) >>> obj1letter number 0 a 1 1 b 2 >>> >>> obj2animal name 0 bird polly 1 monkey george >>> >>> pd.concat([obj1, obj2], axis=1)letter number animal name 0 a 1 bird polly 1 b 2 monkey george設置 verify_integrity=True ，檢查新的索引是否有重復項，有重復項會報錯：
>>> import pandas as pd >>> obj1 = pd.DataFrame([1], index=['a']) >>> obj2 = pd.DataFrame([2], index=['a']) >>> obj10 a 1 >>> >>> obj20 a 2 >>> >>> pd.concat([obj1, obj2], verify_integrity=True) Traceback (most recent call last):... ValueError: Indexes have overlapping values: ['a']設置 sort=True，會對列索引進行排序輸出：
>>> obj1 = pd.DataFrame([['a', 3], ['d', 2]], columns=['letter', 'number']) >>> obj2 = pd.DataFrame([['c', 1, 'cat'], ['b', 4, 'dog']], columns=['letter', 'number', 'animal']) >>> obj1letter number 0 a 3 1 d 2 >>> >>> obj2letter number animal 0 c 1 cat 1 b 4 dog >>> >>> pd.concat([obj1, obj2], sort=True)animal letter number 0 NaN a 3 1 NaN d 2 0 cat c 1 1 dog b 4【02x00】append
Append 方法事實上是在一個 Series / DataFrame 對象后最追加另一個 Series / DataFrame 對象并返回一個新對象，不改變原對象的值。
基本語法：
-
Series.append(self, to_append, ignore_index=False, verify_integrity=False)
-
DataFrame.append(self, other, ignore_index=False, verify_integrity=False, sort=False)
官方文檔：
-
https://pandas.pydata.org/docs/reference/api/pandas.Series.append.html
-
https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.append.html
參數描述：
| to_append / other | 要追加的數據 |
| ignore_index | bool 類型，連接后的值是否使用原索引值，如果為 True，則索引將會是 0, 1, …, n-1 |
| verify_integrity | bool 類型，是否檢查合并后的索引有無重復項，設置為 True 若有重復項則會報錯 |
| sort | bool 類型，是否對列索引（columns）進行排序，默認 False |
合并 Series 對象：
>>> import pandas as pd >>> obj1 = pd.Series([1, 2, 3]) >>> obj2 = pd.Series([4, 5, 6]) >>> obj3 = pd.Series([4, 5, 6], index=[3, 4, 5]) >>> obj1 0 1 1 2 2 3 dtype: int64 >>> >>> obj2 0 4 1 5 2 6 dtype: int64 >>> >>> obj3 3 4 4 5 5 6 dtype: int64 >>> >>> obj1.append(obj2) 0 1 1 2 2 3 0 4 1 5 2 6 dtype: int64 >>> >>> obj1.append(obj3) 0 1 1 2 2 3 3 4 4 5 5 6 dtype: int64 >>> >>> obj1.append(obj2, ignore_index=True) 0 1 1 2 2 3 3 4 4 5 5 6 dtype: int64 >>> >>> obj1.append(obj2, verify_integrity=True) Traceback (most recent call last): ... ValueError: Indexes have overlapping values: Int64Index([0, 1, 2], dtype='int64')合并 DataFrame 對象：
>>> import pandas as pd >>> obj1 = pd.DataFrame([[1, 2], [3, 4]], columns=list('AB')) >>> obj2 = pd.DataFrame([[5, 6], [7, 8]], columns=list('AB')) >>> >>> obj1A B 0 1 2 1 3 4 >>> >>> obj2A B 0 5 6 1 7 8 >>> >>> obj1.append(obj2)A B 0 1 2 1 3 4 0 5 6 1 7 8 >>> >>> obj1.append(obj2, ignore_index=True)A B 0 1 2 1 3 4 2 5 6 3 7 8以下雖然不是生成 DataFrames 的推薦方法，但演示了從多個數據源生成 DataFrames 的兩種方法：
>>> import pandas as pd >>> obj = pd.DataFrame(columns=['A']) >>> for i in range(5):obj = obj.append({'A': i}, ignore_index=True)>>> objA 0 0 1 1 2 2 3 3 4 4 >>> import pandas as pd >>> pd.concat([pd.DataFrame([i], columns=['A']) for i in range(5)], ignore_index=True)A 0 0 1 1 2 2 3 3 4 4【03x00】merge
將不同的數據源進行合并是數據科學中常見的操作，這既包括將兩個不同的數據集非常簡單地拼接在一起，也包括用數據庫那樣的連接（join）與合并（merge）操作處理有重疊字段的數據集。Series 與DataFrame 都具備這類操作，Pandas 的函數與方法讓數據合并變得快速簡單。
數據集的合并（merge）或連接（join）運算是通過一個或多個鍵將行連接起來的。這些運算是關系型數據庫（基于SQL）的核心。Pandas 的 merge 函數是對數據應用這些算法的主要切入點。
pandas.merge 可根據一個或多個連接鍵將不同 DataFrame 中的行連接起來。
基本語法：
pandas.merge(left,right,how: str = 'inner',on=None,left_on=None,right_on=None,left_index: bool = False,right_index: bool = False,sort: bool = False,suffixes='_x', '_y',copy: bool = True,indicator: bool = False,validate=None) → ’DataFrame’官方文檔：https://pandas.pydata.org/docs/reference/api/pandas.merge.html
常見參數描述：
| left | 參與合并的左側 DataFrame 對象 |
| right | 參與合并的右側 DataFrame 對象 |
| how | 合并方式，默認 'inner' 'inner'：內連接，即使用兩個對象中都有的鍵（交集）； 'outer'：外連接，即使用兩個對象中所有的鍵（并集）； 'left'：左連接，即使用左對象中所有的鍵； 'right'：右連接，即使用右對象中所有的鍵； |
| on | 用于連接的列名。必須存在于左右兩個 Dataframe對象中 如果未指定，且其他連接鍵也未指定，則以 left 和 right 列名的交集作為連接鍵 |
| left_on | 左側 DataFrame 對象中用作連接鍵的列 |
| right_on | 右側 DataFrame 對象中用作連接鍵的列 |
| left_index | bool 類型，是否使用左側 DataFrame 對象中的索引（index）作為連接鍵，默認 False |
| right_index | bool 類型，是否使用右側 DataFrame 對象中的索引（index）作為連接鍵，默認 False |
| sort | bool 類型，是否在結果中按順序對連接鍵排序，默認 False。 如果為 False，則連接鍵的順序取決于聯接類型（how 關鍵字） |
| suffixes | 字符串值元組，用于追加到重疊列名的末尾，默認為 ('_x', '_y')。 例如，如果左右兩個 DataFrame 對象都有 data 列時，則結果中就會出現 data_x 和 data_y |
【03x01】一對一連接
一對一連接是指兩個 DataFrame 對象的列的值沒有重復值。
如果不指定任何參數，調用 merge 方法，merge 就會將重疊的列的列名當做鍵來合并。
在下面的示例中，兩個 DataFrame 對象都有一個列名為 key 的列，未指定按照哪一列來合并，merge 就會默認按照 key 來合并：
>>> import pandas as pd >>> obj1 = pd.DataFrame({'key': ['b', 'a', 'c'], 'data1': range(3)}) >>> obj2 = pd.DataFrame({'key': ['a', 'c', 'b'], 'data2': range(3)}) >>> obj1key data1 0 b 0 1 a 1 2 c 2 >>> >>> obj2key data2 0 a 0 1 c 1 2 b 2 >>> >>> pd.merge(obj1, obj2)key data1 data2 0 b 0 2 1 a 1 0 2 c 2 1【03x02】多對一連接
多對一連接是指兩個 DataFrame 對象中，有一個的列的值有重復值。通過多對一連接獲得的結果，DataFrame 將會保留重復值。
>>> import pandas as pd >>> obj1 = pd.DataFrame({'key': ['b', 'b', 'a', 'c', 'a', 'a', 'b'], 'data1': range(7)}) >>> obj2 = pd.DataFrame({'key': ['a', 'b', 'd'], 'data2': range(3)}) >>> >>> obj1key data1 0 b 0 1 b 1 2 a 2 3 c 3 4 a 4 5 a 5 6 b 6 >>> >>> obj2key data2 0 a 0 1 b 1 2 d 2 >>> >>> pd.merge(obj1, obj2)key data1 data2 0 b 0 1 1 b 1 1 2 b 6 1 3 a 2 0 4 a 4 0 5 a 5 0【03x03】多對多連接
多對多連接是指兩個 DataFrame 對象中的列的值都有重復值。
>>> import pandas as pd >>> obj1 = pd.DataFrame({'key': ['a', 'b', 'b', 'c'], 'data1': range(4)}) >>> obj2 = pd.DataFrame({'key': ['a', 'a', 'b', 'b', 'c', 'c'], 'data2': range(6)}) >>> obj1key data1 0 a 0 1 b 1 2 b 2 3 c 3 >>> >>> obj2key data2 0 a 0 1 a 1 2 b 2 3 b 3 4 c 4 5 c 5 >>> >>> pd.merge(obj1, obj2)key data1 data2 0 a 0 0 1 a 0 1 2 b 1 2 3 b 1 3 4 b 2 2 5 b 2 3 6 c 3 4 7 c 3 5這里是一段防爬蟲文本，請讀者忽略。 本文原創首發于 CSDN，作者 TRHX。 博客首頁：https://itrhx.blog.csdn.net/ 本文鏈接：https://itrhx.blog.csdn.net/article/details/106830112 未經授權，禁止轉載！惡意轉載，后果自負！尊重原創，遠離剽竊！
【03x04】參數 on / left_on / right_on
參數 on 用于指定按照某一列來進行合并，若不指定該參數，則會默認按照重疊的列的列名當做鍵來合并：
>>> import pandas as pd >>> obj1 = pd.DataFrame({'key': ['b', 'a', 'c'], 'data1': range(3)}) >>> obj2 = pd.DataFrame({'key': ['a', 'c', 'b'], 'data2': range(3)}) >>> obj1key data1 0 b 0 1 a 1 2 c 2 >>> >>> obj2key data2 0 a 0 1 c 1 2 b 2 >>> >>> pd.merge(obj1, obj2, on='key')key data1 data2 0 b 0 2 1 a 1 0 2 c 2 1如果要根據多個鍵進行合并，傳入一個由列名組成的列表即可：
>>> import pandas as pd >>> left = pd.DataFrame({'key1': ['foo', 'foo', 'bar'],'key2': ['one', 'two', 'one'],'lval': [1, 2, 3]}) >>> right = pd.DataFrame({'key1': ['foo', 'foo', 'bar', 'bar'],'key2': ['one', 'one', 'one', 'two'],'rval': [4, 5, 6, 7]}) >>> leftkey1 key2 lval 0 foo one 1 1 foo two 2 2 bar one 3 >>> >>> rightkey1 key2 rval 0 foo one 4 1 foo one 5 2 bar one 6 3 bar two 7 >>> >>> pd.merge(left, right, on=['key1', 'key2'])key1 key2 lval rval 0 foo one 1 4 1 foo one 1 5 2 bar one 3 6如果兩個對象的列名不同，就可以使用 left_on、right_on 參數分別進行指定：
>>> import pandas as pd >>> obj1 = pd.DataFrame({'lkey': ['b', 'b', 'a', 'c', 'a', 'a', 'b'], 'data1': range(7)}) >>> obj2 = pd.DataFrame({'rkey': ['a', 'b', 'd'], 'data2': range(3)}) >>> obj1lkey data1 0 b 0 1 b 1 2 a 2 3 c 3 4 a 4 5 a 5 6 b 6 >>> >>> obj2rkey data2 0 a 0 1 b 1 2 d 2 >>> >>> pd.merge(obj1, obj2, left_on='lkey', right_on='rkey')lkey data1 rkey data2 0 b 0 b 1 1 b 1 b 1 2 b 6 b 1 3 a 2 a 0 4 a 4 a 0 5 a 5 a 0【03x05】參數 how
在前面的示例中，結果里面 c 和 d 以及與之相關的數據消失了。默認情況下，merge 做的是內連接（'inner'），結果中的鍵是交集。其他方式還有：'left'、'right'、'outer'，含義如下：
- 'inner'：內連接，即使用兩個對象中都有的鍵（交集）；
- 'outer'：外連接，即使用兩個對象中所有的鍵（并集）；
- 'left'：左連接，即使用左對象中所有的鍵；
- 'right'：右連接，即使用右對象中所有的鍵；
【03x06】參數 suffixes
suffixes 參數用于指定附加到左右兩個 DataFrame 對象的重疊列名上的字符串：
在以下示例中，選擇按照 key1 進行合并，而兩個 DataFrame 對象都包含 key2 列，如果未指定 suffixes 參數，則默認會為兩個對象的 key2 加上 _x 和 _y，以便區分它們，如果指定了 suffixes 參數，就會按照添加指定的后綴：
>>> import pandas as pd >>> left = pd.DataFrame({'key1': ['foo', 'foo', 'bar'],'key2': ['one', 'two', 'one'],'lval': [1, 2, 3]}) >>> right = pd.DataFrame({'key1': ['foo', 'foo', 'bar', 'bar'],'key2': ['one', 'one', 'one', 'two'],'rval': [4, 5, 6, 7]}) >>> leftkey1 key2 lval 0 foo one 1 1 foo two 2 2 bar one 3 >>> >>> rightkey1 key2 rval 0 foo one 4 1 foo one 5 2 bar one 6 3 bar two 7 >>> >>> pd.merge(left, right, on='key1')key1 key2_x lval key2_y rval 0 foo one 1 one 4 1 foo one 1 one 5 2 foo two 2 one 4 3 foo two 2 one 5 4 bar one 3 one 6 5 bar one 3 two 7 >>> >>> pd.merge(left, right, on='key1', suffixes=('_left', '_right'))key1 key2_left lval key2_right rval 0 foo one 1 one 4 1 foo one 1 one 5 2 foo two 2 one 4 3 foo two 2 one 5 4 bar one 3 one 6 5 bar one 3 two 7【03x07】參數 left_index / right_index
有時候，DataFrame 中的連接鍵位于其索引中。在這種情況下，可以使用 left_index=True 或right_index=True（或兩個都傳）以說明索引應該被用作連接鍵。這種方法稱為按索引連接，在 Pandas 中還有個 join 方法可以實現這個功能。
在以下示例中，按照 left 的 key 列進行連接，而 right 對象的連接鍵位于其索引中，因此要指定 right_index=True：
>>> import pandas as pd >>> left = pd.DataFrame({'key': ['a', 'b', 'a', 'a', 'b', 'c'], 'value': range(6)}) >>> right = pd.DataFrame({'group_val': [3.5, 7]}, index=['a', 'b']) >>> leftkey value 0 a 0 1 b 1 2 a 2 3 a 3 4 b 4 5 c 5 >>> >>> rightgroup_val a 3.5 b 7.0 >>> >>> pd.merge(left, right, left_on='key', right_index=True)key value group_val 0 a 0 3.5 2 a 2 3.5 3 a 3 3.5 1 b 1 7.0 4 b 4 7.0【04x00】join
join 方法只適用于 DataFrame 對象，Series 對象沒有該方法，該方法用于連接另一個 DataFrame 對象的列（columns）。
基本語法：DataFrame.join(self, other, on=None, how='left', lsuffix='', rsuffix='', sort=False) → ’DataFrame’
參數描述：
| other | 另一個 DataFrame、Series 或 DataFrame 列表對象 |
| on | 列名稱，或者列名稱組成的列表、元組，連接的列 |
| how | 合并方式，默認 'left' 'inner'：內連接，即使用兩個對象中都有的鍵（交集）； 'outer'：外連接，即使用兩個對象中所有的鍵（并集）； 'left'：左連接，即使用左對象中所有的鍵； 'right'：右連接，即使用右對象中所有的鍵； |
| lsuffix | 當兩個對象有相同的列名時，合并后左邊數據列名的后綴 |
| rsuffix | 當兩個對象有相同的列名時，合并后右邊數據列名的后綴 |
| sort | bool 類型，是否在結果中按順序對連接鍵排序，默認 False。 如果為 False，則連接鍵的順序取決于聯接類型（how 關鍵字） |
使用 lsuffix 和 rsuffix 參數：
>>> import pandas as pd >>> obj = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3', 'K4', 'K5'],'A': ['A0', 'A1', 'A2', 'A3', 'A4', 'A5']}) >>> other = pd.DataFrame({'key': ['K0', 'K1', 'K2'],'B': ['B0', 'B1', 'B2']}) >>> objkey A 0 K0 A0 1 K1 A1 2 K2 A2 3 K3 A3 4 K4 A4 5 K5 A5 >>> >>> otherkey B 0 K0 B0 1 K1 B1 2 K2 B2 >>> >>> obj.join(other, lsuffix='_1', rsuffix='_2')key_1 A key_2 B 0 K0 A0 K0 B0 1 K1 A1 K1 B1 2 K2 A2 K2 B2 3 K3 A3 NaN NaN 4 K4 A4 NaN NaN 5 K5 A5 NaN NaN如果右表的索引是左表的某一列的值，這時可以將右表的索引和左表的列對齊合并這樣的靈活方式進行合并：
>>> import pandas as pd >>> obj = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'], 'B': ['B0', 'B1', 'B2', 'B3'],'key': ['K0', 'K1', 'K0', 'K1']}) >>> other = pd.DataFrame({'C': ['C0', 'C1'],'D': ['D0', 'D1']},index=['K0', 'K1']) >>> objA B key 0 A0 B0 K0 1 A1 B1 K1 2 A2 B2 K0 3 A3 B3 K1 >>> >>> otherC D K0 C0 D0 K1 C1 D1 >>> >>> obj.join(other, on='key')A B key C D 0 A0 B0 K0 C0 D0 1 A1 B1 K1 C1 D1 2 A2 B2 K0 C0 D0 3 A3 B3 K1 C1 D1【05x00】四種方法的區別
-
concat：可用于兩個或多個 Series 或 DataFrame 對象間，通過 axis 參數指定按照行方向（增加行）或列方向（增加列）進合并操作，默認行合并（增加行），取并集；
-
append：在一個 Series 或 DataFrame 對象后最追加另一個 Series 或 DataFrame 對象并返回一個新對象，不改變原對象的值。只能按行合并（增加行）。
-
merge：只能對兩個 DataFrame 對象進行合并，一般按照列方向（增加列）進行合并操作，按照行方向合并一般用 join 方法代替，默認列合并（增加列），取交集；
-
join：只能對兩個 DataFrame 對象進行合并，按照列方向（增加列）進行合并操作，默認左連接。
這里是一段防爬蟲文本，請讀者忽略。 本文原創首發于 CSDN，作者 TRHX。 博客首頁：https://itrhx.blog.csdn.net/ 本文鏈接：https://itrhx.blog.csdn.net/article/details/106830112 未經授權，禁止轉載！惡意轉載，后果自負！尊重原創，遠離剽竊！
總結
以上是生活随笔為你收集整理的Python 数据分析三剑客之 Pandas（七）：合并数据集的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 网友不相信高通骁龙8+会有惊喜 雷军：不
- 下一篇： 【Python 必会技巧】使用 Pyth