轉載：https://blog.csdn.net/ly_ysys629/article/details/73849543

參考：https://blog.csdn.net/stevenkwong/article/details/52540605

數據規整化：合并、清理、過濾

pandas和python標準庫提供了一整套高級、靈活的、高效的核心函數和算法將數據規整化為你想要的形式！

本篇博客主要介紹：

合并數據集：.merge()、.concat()等方法，類似于SQL或其他關系型數據庫的連接操作。

合并數據集

1） merge 函數參數

參數說明

left

參與合并的左側DataFrame

right

參與合并的右側DataFrame

how

連接方式：‘inner’（默認）；還有，‘outer’、‘left’、‘right’

on

用于連接的列名，必須同時存在于左右兩個DataFrame對象中，如果位指定，則以left和right列名的交集作為連接鍵

left_on

左側DataFarme中用作連接鍵的列

right_on

右側DataFarme中用作連接鍵的列

left_index

將左側的行索引用作其連接鍵

right_index

將右側的行索引用作其連接鍵

sort

根據連接鍵對合并后的數據進行排序，默認為True。有時在處理大數據集時，禁用該選項可獲得更好的性能

suffixes

字符串值元組，用于追加到重疊列名的末尾，默認為（‘_x’,‘_y’）.例如，左右兩個DataFrame對象都有‘data’，則結果中就會出現‘data_x’，‘data_y’

copy

設置為False，可以在某些特殊情況下避免將數據復制到結果數據結構中。默認總是賦值

1、多對一的合并（一個表的連接鍵列有重復值，另一個表中的連接鍵沒有重復值）

import pandas as pd

import numpy as np

df1 = pd.DataFrame({'key':['b','b','a','c','a','a','b'],'data1': range(7)})

df1

1

2

3

4

5

6

data1key

0

0

b

1

1

b

2

2

a

3

3

c

4

4

a

5

5

a

6

6

b

df2 = pd.DataFrame({'key':['a','b','d'],'data2':range(3)})

df2

1

2

3

data2key

0

0

a

1

1

b

2

2

d

pd.merge(df1,df2)#默認情況

1

data1keydata2

0

0

b

1

1

1

b

1

2

6

b

1

3

2

a

0

4

4

a

0

5

5

a

0

df1.merge(df2)

1

data1keydata2

0

0

b

1

1

1

b

1

2

6

b

1

3

2

a

0

4

4

a

0

5

5

a

0

df1.merge(df2,on = 'key',how = 'inner')#內連接，取交集

1

data1keydata2

0

0

b

1

1

1

b

1

2

6

b

1

3

2

a

0

4

4

a

0

5

5

a

0

df1.merge(df2,on = 'key',how = 'outer')#外鏈接，取并集，并用nan填充

1

data1keydata2

0

0.0

b

1.0

1

1.0

b

1.0

2

6.0

b

1.0

3

2.0

a

0.0

4

4.0

a

0.0

5

5.0

a

0.0

6

3.0

c

NaN

7

NaN

d

2.0

df1.merge(df2,on = 'key',how = 'left')#左連接，左側DataFrame取全部，右側DataFrame取部分

1

data1keydata2

0

0

b

1.0

1

1

b

1.0

2

2

a

0.0

3

3

c

NaN

4

4

a

0.0

5

5

a

0.0

6

6

b

1.0

df1.merge(df2,on = 'key',how = 'right')#右連接，右側DataFrame取全部，左側DataFrame取部分

1

data1keydata2

0

0.0

b

1

1

1.0

b

1

2

6.0

b

1

3

2.0

a

0

4

4.0

a

0

5

5.0

a

0

6

NaN

d

2

如果左右側DataFrame的連接鍵列名不一致，但是取值有重疊，可使用left_on、right_on來指定左右連接鍵

df3 = pd.DataFrame({'lkey':['b','b','a','c','a','a','b'],'data1': range(7)})

df3

1

2

3

data1lkey

0

0

b

1

1

b

2

2

a

3

3

c

4

4

a

5

5

a

6

6

b

df4 = pd.DataFrame({'rkey':['a','b','d'],'data2':range(3)})

df4

1

2

3

data2rkey

0

0

a

1

1

b

2

2

d

df3.merge(df4,left_on = 'lkey',right_on = 'rkey',how = 'inner')

1

data1lkeydata2rkey

0

0

b

1

b

1

1

b

1

b

2

6

b

1

b

3

2

a

0

a

4

4

a

0

a

5

5

a

0

a

2、多對多的合并（一個表的連接鍵列有重復值，另一個表中的連接鍵有重復值）

df1 = pd.DataFrame({'key':['b','b','a','c','a','a','b'],'data1': range(7)})

df1

1

2

3

data1key

0

0

b

1

1

b

2

2

a

3

3

c

4

4

a

5

5

a

6

6

b

df5 = pd.DataFrame({'key':['a','b','a','b','b'],'data2': range(5)})

df5

1

2

data2key

0

0

a

1

1

b

2

2

a

3

3

b

4

4

b

df1.merge(df5)

1

data1keydata2

0

0

b

1

1

0

b

3

2

0

b

4

3

1

b

1

4

1

b

3

5

1

b

4

6

6

b

1

7

6

b

3

8

6

b

4

9

2

a

0

10

2

a

2

11

4

a

0

12

4

a

2

13

5

a

0

14

5

a

2

合并小結

1）默認情況下，會將兩個表中相同列名作為連接鍵

2）多對多，會采用笛卡爾積形式鏈接（左表連接鍵有三個值‘1，3，5’，右表有兩個值‘2，3’，則會形成，（1，2）（1，3）（3，1），（3，2）。。。6種組合）

3）存在多個連接鍵的處理

left = pd.DataFrame({'key1':['foo','foo','bar'],'key2':['one','one','two'],'lval':[1,2,3]})

right = pd.DataFrame({'key1':['foo','foo','bar','bar'],'key2':['one','one','one','two'],'rval':[4,5,6,7]})

1

2

3

4

left

1

key1key2lval

0

foo

one

1

1

foo

one

2

2

bar

two

3

right

1

key1key2rval

0

foo

one

4

1

foo

one

5

2

bar

one

6

3

bar

two

7

pd.merge(left,right,on = ['key1','key2'],how = 'outer')

1

key1key2lvalrval

0

foo

one

1.0

4

1

foo

one

1.0

5

2

foo

one

2.0

4

3

foo

one

2.0

5

4

bar

two

3.0

7

5

bar

one

NaN

6

1）連接鍵是多對多關系，應執行笛卡爾積形式

2）多列應看連接鍵值對是否一致

4）對連接表中非連接列的重復列名的處理

pd.merge(left,right,on = 'key1')

1

key1key2_xlvalkey2_yrval

0

foo

one

1

one

4

1

foo

one

1

one

5

2

foo

one

2

one

4

3

foo

one

2

one

5

4

bar

two

3

one

6

5

bar

two

3

two

7

pd.merge(left,right,on = 'key1',suffixes = ('_left','_right'))

1

key1key2_leftlvalkey2_rightrval

0

foo

one

1

one

4

1

foo

one

1

one

5

2

foo

one

2

one

4

3

foo

one

2

one

5

4

bar

two

3

one

6

5

bar

two

3

two

7

2）索引上的合并

當連接鍵位于索引中時，成為索引上的合并，可以通過merge函數，傳入left_index、right_index來說明應該被索引的情況。

一表中連接鍵是索引列、另一表連接鍵是非索引列

left1 = pd.DataFrame({'key':['a','b','a','a','b','c'],'value': range(6)})

left1

1

2

keyvalue

0

a

0

1

b

1

2

a

2

3

a

3

4

b

4

5

c

5

right1 = pd.DataFrame({'group_val':[3.5,7]},index = ['a','b'])

right1

1

2

group_val

a

3.5

b

7.0

pd.merge(left1,right1,left_on = 'key',right_index = True)

1

keyvaluegroup_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

有上可知，left_on、right_on是指定表中非索引列為連接鍵，left_index、right_index是指定表中索引列為連接鍵，兩者可以組合，是為了區分是否是索引列

兩個表中的索引列都是連接鍵

left2 = pd.DataFrame(np.arange(6).reshape(3,2),index = ['a','b','e'],columns = ['0hio','nevada'])

right2 = pd.DataFrame(np.arange(7,15).reshape(4,2),index = ['b','c','d','e'],columns = ['misso','ala'])

left2

1

2

3

4

5

0hionevada

a

0

1

b

2

3

e

4

5

right2

1

missoala

b

7

8

c

9

10

d

11

12

e

13

14

pd.merge(left2,right2,left_index = True,right_index = True,how = 'outer')

1

0hionevadamissoala

a

0.0

1.0

NaN

NaN

b

2.0

3.0

7.0

8.0

c

NaN

NaN

9.0

10.0

d

NaN

NaN

11.0

12.0

e

4.0

5.0

13.0

14.0

3）軸向連接

在這里展示一種新的連接方法，對應于numpy的concatenate函數，pandas有concat函數

#numpy

arr =np.arange(12).reshape(3,4)

1

2

arr

1

array([[ 0, 1, 2, 3],

[ 4, 5, 6, 7],

[ 8, 9, 10, 11]])

1

2

3

4

np.concatenate([arr,arr],axis = 1)#橫軸連接塊

1

array([[ 0, 1, 2, 3, 0, 1, 2, 3],

[ 4, 5, 6, 7, 4, 5, 6, 7],

[ 8, 9, 10, 11, 8, 9, 10, 11]])

1

2

3

4

concat函數參數表格

參數說明

objs

參與連接的列表或字典，且列表或字典里的對象是pandas數據類型，唯一必須給定的參數

axis=0

指明連接的軸向，0是縱軸，1是橫軸，默認是0

join

‘inner’（交集），‘outer’（并集），默認是‘outer’指明軸向索引的索引是交集還是并集

join_axis

指明用于其他n-1條軸的索引（層次化索引，某個軸向有多個索引），不執行交并集

keys

與連接對象有關的值，用于形成連接軸向上的層次化索引（外層索引），可以是任意值的列表或數組、元組數據、數組列表（如果將levels設置成多級數組的話）

levels

指定用作層次化索引各級別（內層索引）上的索引，如果設置keys的話

names

用于創建分層級別的名稱，如果設置keys或levels的話

verify_integrity

檢查結果對象新軸上的重復情況，如果發橫則引發異常，默認False，允許重復

ignore_index

不保留連接軸上的索引，產生一組新索引range（total_length）

s1 = pd.Series([0,1,2],index = ['a','b','c'])

s2 = pd.Series([2,3,4],index = ['c','f','e'])

s3 = pd.Series([4,5,6],index = ['c','f','g'])

1

2

3

4

5

pd.concat([s1,s2,s3])#默認并集、縱向連接

1

a 0 b 1 c 2 c 2 f 3 e 4 c 4 f 5 g 6 dtype: int64

pd.concat([s1,s2,s3],ignore_index = True)#生成縱軸上的并集，索引會自動生成新的一列

1

0 0 1 1 2 2 3 2 4 3 5 4 6 4 7 5 8 6 dtype: int64

pd.concat([s1,s2,s3],axis = 1,join = 'inner')#縱向取交集,注意該方法對對象表中有重復索引時失效

1

012

c

2

2

4

pd.concat([s1,s2,s3],axis = 1,join = 'outer')#橫向索引取并集，縱向索引取交集,注意該方法對對象表中有重復索引時失效

1

012

a

0.0

NaN

NaN

b

1.0

NaN

NaN

c

2.0

2.0

4.0

e

NaN

4.0

NaN

f

NaN

3.0

5.0

g

NaN

NaN

6.0

concat函數小結

1）縱向連接，ignore_index = False ,可能生成重復的索引

2）橫向連接時，對象索引不能重復

4）合并重疊數據

適用范圍：

1）當兩個對象的索引有部分或全部重疊時

2）用參數對象中的數據為調用者對象的缺失數據‘打補丁’

a = pd.Series([np.nan,2.5,np.nan,3.5,4.5,np.nan],index = ['a','b','c','d','e','f'])

b = pd.Series(np.arange(len(a)),index = ['a','b','c','d','e','f'])

1

2

3

a

1

a NaN

b 2.5

c NaN

d 3.5

e 4.5

f NaN

dtype: float64

1

2

3

4

5

6

7

8

b

1

a 0

b 1

c 2

d 3

e 4

f 5

dtype: int32

1

2

3

4

5

6

7

8

a.combine_first(b)#利用b填補了a的空值

1

a 0.0

b 2.5

c 2.0

d 3.5

e 4.5

f 5.0

dtype: float64

1

2

3

4

5

6

7

8

a = pd.Series([np.nan,2.5,np.nan,3.5,4.5,np.nan],index = ['g','b','c','d','e','f'])

1

a.combine_first(b)#部分索引重疊

1

a 0.0

b 2.5

c 2.0

d 3.5

e 4.5

f 5.0

g NaN

dtype: float64

1

2

3

4

5

6

7

8

9

小結

本篇博客主要講述了一下內容：

1） merge函數合并數據集

2）concat函數合并數據集

3）combine_first函數，含有重疊索引的缺失值填補