Pandas之旅（三）最實用的Merge, Join,Concat方法詳解

時間 2019-12-10

標籤 pandas 之旅實用 merge join concat 方法詳解欄目 Git 简体版

原文原文鏈接

Merge, Join, Concat

你們好，我有回來啦，這周更新的有點慢，主要是由於我更新了我的簡歷哈哈，若是感興趣的朋友能夠去看看哈：python

個人主頁

我的認爲仍是很漂亮的~，不得不說，不少時候老外的設計能力仍是很強。git

好了，有點扯遠了，這一期我想和你們分享的是pandas中最多見的幾種方法，這些方法若是你學會了，某種程度上能夠很好的替代Excel，這篇文章是pandas之旅的第三篇，主要會從如下幾個方面和你們分享個人心得體會：github

Merge
Join
Concat
源碼及GitHub地址

話很少說，讓咱們開始今天的Pandas之旅吧！sql

1. Merge

首先merge的操做很是相似sql裏面的join，實現將兩個Dataframe根據一些共有的列鏈接起來，固然，在實際場景中，這些共有列通常是Id，
鏈接方式也豐富多樣，能夠選擇inner(默認)，left,right,outer 這幾種模式，分別對應的是內鏈接，左鏈接，右鏈接dom

1.1 InnerMerge (內鏈接)

首先讓咱們簡單的建立兩個DF,分別爲DataFrame1,DataFrame2,他們的公有列是key函數

import numpy as np
import pandas as pd
from pandas import Series, DataFrame

# Let's make a dframe
dframe1 = DataFrame({'key':['X','Z','Y','Z','X','X'],'value_df1': np.arange(6)})
dframe1

	key	value_df1
0	X	0
1	Z	1
2	Y	2
3	Z	3
4	X	4
5	X	5

#Now lets make another dframe
dframe2 = DataFrame({'key':['Q','Y','Z'],'value_df2':[1,2,3]})
dframe2

	key	value_df2
0	Q	1
1	Y	2
2	Z	3

咱們如今能夠簡單地使用pd.merge(dframe1,dframe2)來實現Merge功能學習

pd.merge(dframe1,dframe2)

	key	value_df1	value_df2
0	Z	1	3
1	Z	3	3
2	Y	2	2

咱們如今須要注意一點，X僅僅是存在於dframe1的key，在dframe2中不存在，所以你們能夠發現，當咱們調用pd.merge的時候，會自動默認爲inner join，
咱們再換一種方式寫一下，你們就明白了：spa

pd.merge(dframe1,dframe2,on='key',how='inner')

	key	value_df1	value_df2
0	Z	1	3
1	Z	3	3
2	Y	2	2

你們能夠發現結果是同樣的，看到這裏，對sql熟悉的朋友們已經有感受了估計，由於實在是太像了，若是咱們不經過on和how來指定
想要merge的公有列或者方式，那麼pd.merge就會自動尋找到兩個DataFrame的相同列並自動默認爲inner join，至此，
估計你們也能夠猜出其餘幾種模式的merge啦

1.2 LeftMerge (左鏈接)

如今一樣的，讓咱們看一下how='left'的狀況，這是一個左鏈接

pd.merge(dframe1,dframe2,on='key',how='left')

	key	value_df1	value_df2
0	X	0	NaN
1	Z	1	3.0
2	Y	2	2.0
3	Z	3	3.0
4	X	4	NaN
5	X	5	NaN

咱們能夠看到返回的是dframe1的全部key值對應的結果，若是在dframe2中不存在，顯示爲Nan空值設計

1.3 RightMerge (右鏈接)

右鏈接的原理和左鏈接正相反code

pd.merge(dframe1,dframe2,on='key',how='right')

	key	value_df1	value_df2
0	Z	1.0	3
1	Z	3.0	3
2	Y	2.0	2
3	Q	NaN	1

這裏Q只存在於drame2的key中

1.4 OuterMerge (全鏈接)

#Choosing the "outer" method selects the union of both keys
pd.merge(dframe1,dframe2,on='key',how='outer')

	key	value_df1	value_df2
0	X	0.0	NaN
1	X	4.0	NaN
2	X	5.0	NaN
3	Z	1.0	3.0
4	Z	3.0	3.0
5	Y	2.0	2.0
6	Q	NaN	1.0

這裏就是一個並集的形式啦，其實就是一個union的結果，會把key這一列在兩個Dataframe出現的全部值所有顯示出來，若是有空值顯示爲Nan

1.5 MultipleKey Merge (基於多個key上的merge)

剛纔咱們都是僅僅實現的在一個key上的merge，固然咱們也能夠實現基於多個keys的merge

# Dframe on left
df_left = DataFrame({'key1': ['SF', 'SF', 'LA'],
                  'key2': ['one', 'two', 'one'],
                  'left_data': [10,20,30]})
df_left

	key1	key2	left_data
0	SF	one	10
1	SF	two	20
2	LA	one	30

#Dframe on right
df_right = DataFrame({'key1': ['SF', 'SF', 'LA', 'LA'],
                   'key2': ['one', 'one', 'one', 'two'],
                   'right_data': [40,50,60,70]})
df_right

	key1	key2	right_data
0	SF	one	40
1	SF	one	50
2	LA	one	60
3	LA	two	70

這是內鏈接（交集）的結果

#Merge， Inner
pd.merge(df_left, df_right, on=['key1', 'key2'])

	key1	key2	left_data	right_data
0	SF	one	10	40
1	SF	one	10	50
2	LA	one	30	60

這是外鏈接（並集）的結果

#Merge， Outer
pd.merge(df_left, df_right, on=['key1', 'key2'],how='outer')

	key1	key2	left_data	right_data
0	SF	one	10.0	40.0
1	SF	one	10.0	50.0
2	SF	two	20.0	NaN
3	LA	one	30.0	60.0
4	LA	two	NaN	70.0

這裏還有一個地方很是有意思，你們能夠發現如今df_left,df_right做爲key的兩列分別是key1和key2，它們的名字是相同的，剛剛咱們是經過制定on=['key1', 'key2'],那若是咱們只指定一列會怎麼樣呢？

pd.merge(df_left,df_right,on='key1')

	key1	key2_x	left_data	key2_y	right_data
0	SF	one	10	one	40
1	SF	one	10	one	50
2	SF	two	20	one	40
3	SF	two	20	one	50
4	LA	one	30	one	60
5	LA	one	30	two	70

你們能夠看到pandas自動把key2這一列拆分紅了key2_x和key2_y，都會顯示在最後的merge結果裏，若是咱們想要給這兩列從新命名，也是很容易的：

# We can also specify what the suffix becomes
pd.merge(df_left,df_right, on='key1',suffixes=('_lefty','_righty'))

	key1	key2_lefty	left_data	key2_righty	right_data
0	SF	one	10	one	40
1	SF	one	10	one	50
2	SF	two	20	one	40
3	SF	two	20	one	50
4	LA	one	30	one	60
5	LA	one	30	two	70

像這樣，咱們能夠經過suffixes參數來指定拆分的列的名字。

1.6 Merge on Index (基於index上的merge)

咱們還能夠實現幾個Dataframe基於Index的merge，仍是老樣子，先讓咱們建立兩個Dataframe

df_left = DataFrame({'key': ['X','Y','Z','X','Y'],
                  'data': range(5)})
df_right = DataFrame({'group_data': [10, 20]}, index=['X', 'Y'])

df_left

	key	data
0	X	0
1	Y	1
2	Z	2
3	X	3
4	Y	4

df_right

	group_data
X	10
Y	20

好了，如今咱們想要實現兩個Dataframe的merge，可是條件是經過df_left的Key和df_right的Index

pd.merge(df_left,df_right,left_on='key',right_index=True)

	key	data	group_data
0	X	0	10
3	X	3	10
1	Y	1	20
4	Y	4	20

這樣咱們也能夠獲得結果。

# We can also get a union by using outer
pd.merge(df_left,df_right,left_on='key',right_index=True,how='outer')

	key	data	group_data
0	X	0	10.0
3	X	3	10.0
1	Y	1	20.0
4	Y	4	20.0
2	Z	2	NaN

其餘的merge方式就相似啦，這裏就不一一說了，只是舉一個outer join的例子

# 經過outer實現外鏈接，union並集
pd.merge(df_left,df_right,left_on='key',right_index=True,how='outer')

	key	data	group_data
0	X	0	10.0
3	X	3	10.0
1	Y	1	20.0
4	Y	4	20.0
2	Z	2	NaN

咱們也能夠嘗試一些有意思的merge，好比，若是一個dataframe的index是多層嵌套的狀況：

df_left_hr = DataFrame({'key1': ['SF','SF','SF','LA','LA'],
                   'key2': [10, 20, 30, 20, 30],
                   'data_set': np.arange(5.)})
df_right_hr = DataFrame(np.arange(10).reshape((5, 2)),
                   index=[['LA','LA','SF','SF','SF'],
                          [20, 10, 10, 10, 20]],
                   columns=['col_1', 'col_2'])

df_left_hr

	key1	key2	data_set
0	SF	10	0.0
1	SF	20	1.0
2	SF	30	2.0
3	LA	20	3.0
4	LA	30	4.0

df_right_hr

		col_1	col_2
LA	20	0	1
LA	10	2	3
SF	10	4	5
	10	6	7
	20	8	9

如今咱們穿建了兩個Dataframe 分別是df_left_hr和df_right_hr（Index兩層），若是咱們想經過使用df_left_hr的key1，key2 及df_right_hr的Index做爲merge
的列，也是沒有問題的

# Now we can merge the left by using keys and the right by its index
pd.merge(df_left_hr,df_right_hr,left_on=['key1','key2'],right_index=True)

	key1	key2	data_set	col_1	col_2
0	SF	10	0.0	4	5
0	SF	10	0.0	6	7
1	SF	20	1.0	8	9
3	LA	20	3.0	0	1

基本到這裏，我已經和你們分享了基礎的Merge有關的全部操做，若是你平時生活工做中常用Excel執行相似操做的話，能夠學習一下Merge哈，它會大幅度
減輕你的工做強度的！

2.Join

如今咱們能夠接着來看join相關的操做，先讓咱們看一個小例子

left = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'], 
                    'B': ['B0', 'B1', 'B2', 'B3']}, 
                    index = ['K0', 'K1', 'K2', 'K3']) 
  
right = pd.DataFrame({'C': ['C0', 'C1', 'C2', 'C3'], 
                      'D': ['D0', 'D1', 'D2', 'D3']}, 
                      index = ['K0', 'K1', 'K2', 'K3'])

left

	A	B
K0	A0	B0
K1	A1	B1
K2	A2	B2
K3	A3	B3

right

	C	D
K0	C0	D0
K1	C1	D1
K2	C2	D2
K3	C3	D3

left.join(right)

	A	B	C	D
K0	A0	B0	C0	D0
K1	A1	B1	C1	D1
K2	A2	B2	C2	D2
K3	A3	B3	C3	D3

其實經過這一個小例子你們也就明白了，join無非就是合併，默認是橫向，還有一個點須要注意的是，咱們其實能夠經過join實現和merge同樣的效果，可是爲了
避免混淆，我不會多舉其餘的例子了，由於我我的認爲通常狀況下仍是用merge函數好一些

3. Concat

爲了更加全面完全地瞭解Concat函數，你們能夠先從一維的Numpy Array開始，首先讓咱們簡單的建立一個矩陣：

# Create a matrix 
arr1 = np.arange(9).reshape((3,3))
arr1

array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])

接着讓咱們經過concatenate函數進行橫向拼接：

np.concatenate([arr1,arr1],axis=1)

array([[0, 1, 2, 0, 1, 2],
       [3, 4, 5, 3, 4, 5],
       [6, 7, 8, 6, 7, 8]])

再讓咱們進行縱向拼接：

# Let's see other axis options
np.concatenate([arr1,arr1],axis=0)

array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8],
       [0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])

有了基礎的印象以後，如今讓咱們看看在pandas中是如何操做的：

# Lets create two Series with no overlap
ser1 =  Series([0,1,2],index=['T','U','V'])

ser2 = Series([3,4],index=['X','Y'])

#Now let use concat (default is axis=0)
pd.concat([ser1,ser2])

T    0
U    1
V    2
X    3
Y    4
dtype: int64

在上面的例子中，咱們分別建立了兩個沒有重複Index的Series,而後用concat默認的把它們合併在一塊兒，這時生成的依然是Series類型，若是咱們把axis換成1，那生成的就是Dataframe,像下面同樣

pd.concat([ser1,ser2],axis=1,sort =True)  # sort=Ture是默認的，pandas老是默認index排序

	0	1
T	0.0	NaN
U	1.0	NaN
V	2.0	NaN
X	NaN	3.0
Y	NaN	4.0

咱們還能夠指定在哪些index上進行concat:

pd.concat([ser1,ser2],axis=1,join_axes=[['U','V','Y']])

	0	1
U	1.0	NaN
V	2.0	NaN
Y	NaN	4.0

也能夠給不一樣組的index加一層標籤

pd.concat([ser1,ser2],keys=['cat1','cat2'])

cat1  T    0
      U    1
      V    2
cat2  X    3
      Y    4
dtype: int64

若是把axis換成是1，那麼keys就會變成column的名字：

pd.concat([ser1,ser2],axis=1,keys=['cat1','cat2'],sort=True)

	cat1	cat2
T	0.0	NaN
U	1.0	NaN
V	2.0	NaN
X	NaN	3.0
Y	NaN	4.0

若是是兩個現成的dataframe直接進行concat也是同樣：

dframe1 = DataFrame(np.random.randn(4,3), columns=['X', 'Y', 'Z'])
dframe2 = DataFrame(np.random.randn(3, 3), columns=['Y', 'Q', 'X'])

dframe1

	X	Y	Z
0	1.119976	-0.853960	0.027451
1	-0.536831	0.982092	-0.157650
2	-0.219322	-1.489809	1.607735
3	0.767249	-1.661912	0.038837

dframe2

	Y	Q	X
0	-0.035560	0.875282	-1.630508
1	-0.439484	0.096247	1.335693
2	0.746299	0.568684	1.197015

#若是沒有對應的值，默認爲NaN, 空值
pd.concat([dframe1,dframe2],sort=True)

	Q	X	Y	Z
0	NaN	1.119976	-0.853960	0.027451
1	NaN	-0.536831	0.982092	-0.157650
2	NaN	-0.219322	-1.489809	1.607735
3	NaN	0.767249	-1.661912	0.038837
0	0.875282	-1.630508	-0.035560	NaN
1	0.096247	1.335693	-0.439484	NaN
2	0.568684	1.197015	0.746299	NaN

4. 源碼及Github地址

今天我爲你們主要總結了pandas中很是常見的三種方法：

merge
concat
join

你們能夠根據本身的實際須要來決定使用哪種

我把這一期的ipynb文件和py文件放到了Github上，你們若是想要下載能夠點擊下面的連接：

Github倉庫地址： https://github.com/yaozeliang/pandas_share

這一期就到這裏啦，但願你們可以繼續支持我，完結，撒花

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。

	key1	key2_x	left_data	key2_y	right_data
0	SF	one	10	one	40
1	SF	one	10	one	50
2	SF	two	20	one	40
3	SF	two	20	one	50
4	LA	one	30	one	60
5	LA	one	30	two	70

	key1	key2_lefty	left_data	key2_righty	right_data
0	SF	one	10	one	40
1	SF	one	10	one	50
2	SF	two	20	one	40
3	SF	two	20	one	50
4	LA	one	30	one	60
5	LA	one	30	two	70

	key1	key2_x	left_data	key2_y	right_data
0	SF	one	10	one	40
1	SF	one	10	one	50
2	SF	two	20	one	40
3	SF	two	20	one	50
4	LA	one	30	one	60
5	LA	one	30	two	70

	key1	key2_lefty	left_data	key2_righty	right_data
0	SF	one	10	one	40
1	SF	one	10	one	50
2	SF	two	20	one	40
3	SF	two	20	one	50
4	LA	one	30	one	60
5	LA	one	30	two	70

	key1	key2_x	left_data	key2_y	right_data
0	SF	one	10	one	40
1	SF	one	10	one	50
2	SF	two	20	one	40
3	SF	two	20	one	50
4	LA	one	30	one	60
5	LA	one	30	two	70

	key1	key2_lefty	left_data	key2_righty	right_data
0	SF	one	10	one	40
1	SF	one	10	one	50
2	SF	two	20	one	40
3	SF	two	20	one	50
4	LA	one	30	one	60
5	LA	one	30	two	70