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（七）：合併數據集

---

另有 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

---

---

這裏是一段防爬蟲文本，請讀者忽略。
本文原創首發於 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    a
    1    b
s2  0    c
    1    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         a
             1         b
s2           0         c
             1         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'])
>>> obj1
  letter  number
0      a       1
1      b       2
>>> 
>>> obj2
  letter  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'])
>>> obj1
  letter  number
0      a       1
1      b       2
>>> 
>>> obj2
  letter  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'])
>>> obj1
  letter  number
0      a       1
1      b       2
>>> 
>>> obj2
  letter  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'])
>>> obj1
  letter  number
0      a       1
1      b       2
>>> 
>>> obj2
   animal    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'])
>>> obj1
   0
a  1
>>> 
>>> obj2
   0
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'])
>>> obj1
  letter  number
0      a       3
1      d       2
>>> 
>>> obj2
  letter  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'))
>>> 
>>> obj1
   A  B
0  1  2
1  3  4
>>> 
>>> obj2
   A  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)

	
>>> obj
   A
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)})
>>> obj1
  key  data1
0   b      0
1   a      1
2   c      2
>>> 
>>> obj2
  key  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)})
>>> 
>>> obj1
  key  data1
0   b      0
1   b      1
2   a      2
3   c      3
4   a      4
5   a      5
6   b      6
>>> 
>>> obj2
  key  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)})
>>> obj1
  key  data1
0   a      0
1   b      1
2   b      2
3   c      3
>>> 
>>> obj2
  key  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)})
>>> obj1
  key  data1
0   b      0
1   a      1
2   c      2
>>> 
>>> obj2
  key  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]})
>>> left
  key1 key2  lval
0  foo  one     1
1  foo  two     2
2  bar  one     3
>>> 
>>> right
  key1 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)})
>>> obj1
  lkey  data1
0    b      0
1    b      1
2    a      2
3    c      3
4    a      4
5    a      5
6    b      6
>>> 
>>> obj2
  rkey  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'：右連接，即使用右對象中所有的鍵；

>>> 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)})
>>> obj1
  key  data1
0   b      0
1   b      1
2   a      2
3   c      3
4   a      4
5   a      5
6   b      6
>>> 
>>> obj2
  key  data2
0   a      0
1   b      1
2   d      2
>>> 
>>> pd.merge(obj1, obj2, on='key', how='inner')
  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
>>> 
>>> pd.merge(obj1, obj2, on='key', how='outer')
  key  data1  data2
0   b    0.0    1.0
1   b    1.0    1.0
2   b    6.0    1.0
3   a    2.0    0.0
4   a    4.0    0.0
5   a    5.0    0.0
6   c    3.0    NaN
7   d    NaN    2.0
>>> 
>>> pd.merge(obj1, obj2, on='key', how='left')
  key  data1  data2
0   b      0    1.0
1   b      1    1.0
2   a      2    0.0
3   c      3    NaN
4   a      4    0.0
5   a      5    0.0
6   b      6    1.0
>>> 
>>> pd.merge(obj1, obj2, on='key', how='right')
  key  data1  data2
0   b    0.0      1
1   b    1.0      1
2   b    6.0      1
3   a    2.0      0
4   a    4.0      0
5   a    5.0      0
6   d    NaN      2

【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]})
>>> left
  key1 key2  lval
0  foo  one     1
1  foo  two     2
2  bar  one     3
>>> 
>>> right
  key1 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'])
>>> left
  key  value
0   a      0
1   b      1
2   a      2
3   a      3
4   b      4
5   c      5
>>> 
>>> right
   group_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']})
>>> obj
  key   A
0  K0  A0
1  K1  A1
2  K2  A2
3  K3  A3
4  K4  A4
5  K5  A5
>>> 
>>> other
  key   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'])
>>> obj
    A   B key
0  A0  B0  K0
1  A1  B1  K1
2  A2  B2  K0
3  A3  B3  K1
>>> 
>>> other
     C   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
未經授權，禁止轉載！惡意轉載，後果自負！尊重原創，遠離剽竊！

---