Pandas 數據處理：空值清洗、替換填充、級聯與合併拼接

時間  2021-01-22
標籤 java python 算法 數組 app 函數 測試 編碼 spa 3d 欄目 大數據 简体版
原文   原文鏈接

      針對空值的處理，首先要來了解一下空值的類型：java

1、pandas中的None  和  NaN 有什麼區別？

      type(None)     --類型是  NoneType 空的對象類型python

      type(NaN)      --類型是  float 浮點型算法

      注意：Pandas中None 和 NaN 都視做np.nan 數組

2、Pandas 的空值操做

isnull()   判斷null ，返回True/False 的數組
notnull()    空值判斷
dropna()     過濾空值數據
fillna()    填充丟失數據

  一、使用pandas過濾空值：

 df.isnull().any(axis = 1)
# 解析： any中軸向：axis = 0  表示列   axis = 1  表示行
# 新函數：  all(axis = 0)   全部數據
           any(axis = 0)   任何一個

# df.isnull()表示返回一組True/False 的數組，any(axis = 1)表示橫向判斷行，一行中任意一個爲true就這行就返回 True, 最後返回一維數組
#  最終返回結果以下：
1    False
2    True
3    False
4    False
5    True

#  擴展： df.isnull().all(axis = 1) 一行中任意一個爲False就這行就返回 False, 最後返回一維數組

      notnull() 的使用方法和isnull()正好相反：app

 df.notnull().all(axis = 1)

# 一行中任意一個爲False就這行就返回 False, 最後返回一維數組
#  最終返回結果以下：
1    True
2    False
3    True
4    True
5    False

# 總結：  固定搭配以下：
          isnull()  --> any()
          notnull()  -->all()

      最後過濾掉有空值的行函數

df.iloc[df.notnull().all(axis = 1)]

  二、df.dropna()  過濾空數據所在的行或列 (可直接過濾)

           df.dropna() 能夠選擇過濾的是行仍是列，默認是行，dropna中axis=0 表示行; axis=1 表示列測試

df.dropna(axis=0)  #等同於上面過濾方式，封裝了上面操做

  三、fillna()  填充丟失/空值數據

            fillna中 axis=0 表示列；axis=1 表示行           編碼

           可選擇向前或向後填充：spa

  1.  method ='bfill'  向後覆蓋(空值取前一個)；
  2.  method ='ffill'  向前覆蓋(空值取後一個)；  
df.fillna(value =5555)   #填充df 中全部空值數據

df.fillna(method ='bfill',axis=0)   # 列裏的空值取列裏空值取前一個填充

   四、drop 刪除數據      

         drop 中  axis=0 表示行，axis=1 表示列3d

         刪除無用的列，列索引：'name','name1'；inplace參數指是否替代原來的df

                   data.drop(labels=['name','name1'],axis = 1,inplace=True)     

          刪除無用的行，行索引：'漲跌'

                   df.drop(['漲跌'], axis=0, inplace=True)   

    五、Pandas 刪除空值行數據、替換空值案例代碼： 

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

# 提取數據
data = pd.read_excel('./測試數據.excel')

# 刪除無用的列，列索引：'name','name1'
data.drop(labels=['name','name1'],axis = 1,inplace=True)     

# 刪除空數據所在的行
data.dropna(axis=0)    

# 覆蓋
v_1 = data.fillna(method='ffill',axis=0) .fillna(method='bfill',axis=0) 

# 檢測v_1中是否有空值
v_1.isnull().any(axis = 0)  #一般檢測列裏是否有空值，由於行數太多

3、pandas的級聯操做

      定義：對DataFram 進行橫向或縱向的拼接

                 使用pandas.concat()級聯   

 一、匹配級聯

            和numpy.concatenate同樣，優先增長行數（默認axis=0 )，numpy.concatenate(axis=1)的時候是水平的級聯,numpy中沒有index,和columns,因此只要行列相等就能夠級聯，

            在pandas中,若是行 和 列不一致,可是shape相同,會級聯成一個更大的df,不對應的值會填充NaN。

  •     注意： 

                   縱向級聯 axis=0：按行拼接--->在行上增長，列索引不匹配填充NaN

                   橫向級聯 axis=1：按列拼接--->在列上增長，行索引不匹配填充NaN

        匹配級聯拼接案例分析：

import numpy as np
import pandas as pd
from pandas import Series,DataFrame
def make_df(cols,index): 
    data = {col:[str(col)+str(ind) for ind in index] for col in cols} 
    df = DataFrame(data = data,columns = cols ,index = index )
    return df

df1 = make_df(['a','b','c'],[1,2,3])
# 輸出
    a   b   c
1 a1 b1 c1
2 a2 b2 c2
3 a3 b3 c3

df2 = make_df(['a','b','c'],[4,5,6])
# 輸出
    a   b   c
4 a4 b4 c4
5 a5 b5 c5
6 a6 b6 c6

pd.concat([df1,df2],axis=1)
結果以下：
    a     b   c     a    b    c
1  a1    b1   c1   NaN  NaN  NaN
2  a2    b2   c2   NaN  NaN  NaN
3  a3    b3   c3   NaN  NaN  NaN
4  NaN  NaN  NaN   a4   b4   c4
5  NaN  NaN  NaN   a5   b5   c5
6  NaN  NaN  NaN   a6   b6   c6         

pd.concat([df1,df2],axis=0)
結果以下：
  a   b   c
1 a1 b1 c1
2 a2 b2 c2
3 a3 b3 c3
4 a4 b4 c4
5 a5 b5 c5
6 a6 b6 c6

  二、不匹配級聯

        縱向級聯( axis=0 -->在行上增長)時列索引不一致，

        橫向級聯( axis=1 -->在列上增長)時行索引不一致

      2.一、外鏈接：補NaN（默認）

df1 = make_df(['a','b','c'],[1,2,3])
# 輸出
   a  b  c
1 a1 b1 c1
2 a2 b2 c2
3 a3 b3 c3

df5 = make_df(['c','d','e'],[3,4,5])
# 輸出
   c  d  e
3 c3 d3 e3
4 c4 d4 e4
5 c5 d5 e5

df6 = pd.concat([df1,df5],axis=1)
# 輸出
     a     b    c     c    d    e
1    a1    b1   c1   NaN  NaN  NaN
2    a2    b2   c2   NaN  NaN  NaN
3    a3    b3   c3   c3   d3   e3
4   NaN   NaN   NaN  c4   d4   e4
5   NaN   NaN   NaN  c5   d5   e5

df6 = pd.concat([df1,df5],axis=0)
# 輸出
     a     b   c    d     e
1    a1   b1   c1   NaN  NaN
2    a2   b2   c2   NaN  NaN
3    a3   b3   c3   NaN  NaN
3   NaN  NaN   c3   d3    e3
4   NaN  NaN   c4   d4    e4
5   NaN  NaN   c5   d5    e5

　 2.二、內鏈接(join='inner')：只鏈接匹配的項(行或者列)其餘項(行或者列)忽略

        join_axes=[df1.columns] 的值是一個列表，表示指定以 df1.columns列索引 或 df1.index行索引爲鏈接，只鏈接匹配的項(行或者列)

df6 = pd.concat([df1,df5],axis=1,join='inner')
# 輸出
  a  b  c  c  d  e
3 a3 b3 c3 c3 d3 e3

df7 = pd.concat([df1,df5],join_axes=[df1.columns])
#join_axes 的值是一個列表[df1.index]
# 輸出
    a  b  c
1  a1 b1  c1
2  a2 b2  c2
3  a3 b3  c3
3 NaN NaN c3
4 NaN NaN c4
5 NaN NaN c5

     2.三、使用append()函數添加　

      append專門用於在後面添加，append 和 concat 類似

      append是縱向拼接，( axis=0 -->在行上增長)

df1.append(df5)
# 同以下拼接方式
df6 = pd.concat([df1,df5],axis=0)
# 輸出
  a   b   c   d   e
1 a1  b1  c1 NaN NaN
2 a2  b2  c2 NaN NaN
3 a3  b3  c3 NaN NaN
3 NaN NaN c3  d3  e3
4 NaN NaN c4  d4  e4
5 NaN NaN c5  d5  e5

4、Pandas的 合併拼接操做

       merge方法主要基於兩個dataframe的共同列進行合併，

       join方法主要基於兩個dataframe的索引進行合併，

       concat方法是對series或dataframe進行行拼接或列拼接。

  1. Merge方法

     pandas的merge方法是基於共同列，將兩個dataframe鏈接起來。merge方法的主要參數：

  1. left/right：左/右位置的dataframe。
  2. how：數據合併的方式。left：基於左dataframe列的數據合併；right：基於右dataframe列的數據合併；outer：基於列的數據外合併（取並集）；inner：基於列的數據內合併（取交集）；默認爲'inner'。
  3. on：用來合併的列名，這個參數須要保證兩個dataframe有相同的列名。
  4. left_on/right_on：左/右dataframe合併的列名，也可爲索引，數組和列表。
  5. left_index/right_index：是否以index做爲數據合併的列名，True表示是。
  6. sort：根據dataframe合併的keys排序，默認是。
  7. suffixes：如有相同列且該列沒有做爲合併的列，可經過suffixes設置該列的後綴名，通常爲元組和列表類型。

     merges經過設置how參數選擇兩個dataframe的鏈接方式，有內鏈接，外鏈接，左鏈接，右鏈接，下面經過例子介紹鏈接的含義。

   1.1 內鏈接

　　how='inner'，dataframe的連接方式爲內鏈接，咱們能夠理解基於共同列的交集進行鏈接，參數on設置鏈接的共有列名

# 單列的內鏈接
# 定義df1
import pandas as pd
import numpy as np

df1 = pd.DataFrame({'alpha':['A','B','B','C','D','E'],'feature1':[1,1,2,3,3,1],
            'feature2':['low','medium','medium','high','low','high']})
# 定義df2
df2 = pd.DataFrame({'alpha':['A','A','B','F'],'pazham':['apple','orange','pine','pear'],
            'kilo':['high','low','high','medium'],'price':np.array([5,6,5,7])})
# print(df1)
# print(df2)
# 基於共同列alpha的內鏈接
df3 = pd.merge(df1,df2,how='inner',on='alpha')
df3

取共同列alpha值的交集進行鏈接。

  1.2 外鏈接

　　how='outer'，dataframe的連接方式爲外鏈接，咱們能夠理解基於共同列的並集進行鏈接，參數on設置鏈接的共有列名。

# 單列的外鏈接
# 定義df1
df1 = pd.DataFrame({'alpha':['A','B','B','C','D','E'],'feature1':[1,1,2,3,3,1],
                'feature2':['low','medium','medium','high','low','high']})
# 定義df2
df2 = pd.DataFrame({'alpha':['A','A','B','F'],'pazham':['apple','orange','pine','pear'],
                        'kilo':['high','low','high','medium'],'price':np.array([5,6,5,7])})
# 基於共同列alpha的內鏈接
df4 = pd.merge(df1,df2,how='outer',on='alpha')
df4

     若兩個dataframe間除了on設置的鏈接列外並沒有相同列，則該列的值置爲NaN。

 1.3 左鏈接

　　how='left'，dataframe的連接方式爲左鏈接，咱們能夠理解基於左邊位置dataframe的列進行鏈接，參數on設置鏈接的共有列名。

# 單列的左鏈接
# 定義df1
df1 = pd.DataFrame({'alpha':['A','B','B','C','D','E'],'feature1':[1,1,2,3,3,1],
    'feature2':['low','medium','medium','high','low','high']})
# 定義df2
df2 = pd.DataFrame({'alpha':['A','A','B','F'],'pazham':['apple','orange','pine','pear'],
                        'kilo':['high','low','high','medium'],'price':np.array([5,6,5,7])})
# 基於共同列alpha的左鏈接
df5 = pd.merge(df1,df2,how='left',on='alpha')
df5

     由於df2的鏈接列alpha有兩個'A'值，因此左鏈接的df5有兩個'A'值，若兩個dataframe間除了on設置的鏈接列外並沒有相同列，則該列的值置爲NaN。

  1.4 右鏈接

　 how='right'，dataframe的連接方式爲左鏈接，咱們能夠理解基於右邊位置dataframe的列進行鏈接，參數on設置鏈接的共有列名。 

# 單列的右鏈接
# 定義df1
df1 = pd.DataFrame({'alpha':['A','B','B','C','D','E'],'feature1':[1,1,2,3,3,1],
'feature2':['low','medium','medium','high','low','high']})
# 定義df2
df2 = pd.DataFrame({'alpha':['A','A','B','F'],'pazham':['apple','orange','pine','pear'],
                        'kilo':['high','low','high','medium'],'price':np.array([5,6,5,7])})
# 基於共同列alpha的右鏈接
df6 = pd.merge(df1,df2,how='right',on='alpha')
df6

      由於df1的鏈接列alpha有兩個'B'值，因此右鏈接的df6有兩個'B'值。若兩個dataframe間除了on設置的鏈接列外並沒有相同列，則該列的值置爲NaN。

 1.5 基於多列的鏈接算法 

　　多列鏈接的算法與單列鏈接一致，本節只介紹基於多列的內鏈接和右鏈接，讀者可本身編碼並按照本文給出的圖解方式去理解外鏈接和左鏈接。 

多列的內鏈接：

# 多列的內鏈接
# 定義df1
df1 = pd.DataFrame({'alpha':['A','B','B','C','D','E'],'beta':['a','a','b','c','c','e'],
                    'feature1':[1,1,2,3,3,1],'feature2':['low','medium','medium','high','low','high']})
# 定義df2
df2 = pd.DataFrame({'alpha':['A','A','B','F'],'beta':['d','d','b','f'],'pazham':['apple','orange','pine','pear'],
                        'kilo':['high','low','high','medium'],'price':np.array([5,6,5,7])})
# 基於共同列alpha和beta的內鏈接
df7 = pd.merge(df1,df2,on=['alpha','beta'],how='inner')
df7

   多列的右鏈接：

# 多列的右鏈接
# 定義df1
df1 = pd.DataFrame({'alpha':['A','B','B','C','D','E'],'beta':['a','a','b','c','c','e'],
                    'feature1':[1,1,2,3,3,1],'feature2':['low','medium','medium','high','low','high']})
# 定義df2
df2 = pd.DataFrame({'alpha':['A','A','B','F'],'beta':['d','d','b','f'],'pazham':['apple','orange','pine','pear'],
                        'kilo':['high','low','high','medium'],'price':np.array([5,6,5,7])})
print(df1)
print(df2)

# 基於共同列alpha和beta的右鏈接
df8 = pd.merge(df1,df2,on=['alpha','beta'],how='right')
df8

  1.6 基於index的鏈接方法

    前面介紹了基於column的鏈接方法，merge方法亦可基於index鏈接dataframe

# 基於column和index的右鏈接
# 定義df1
df1 = pd.DataFrame({'alpha':['A','B','B','C','D','E'],'beta':['a','a','b','c','c','e'],
                    'feature1':[1,1,2,3,3,1],'feature2':['low','medium','medium','high','low','high']})
# 定義df2
df2 = pd.DataFrame({'alpha':['A','A','B','F'],'pazham':['apple','orange','pine','pear'],
                        'kilo':['high','low','high','medium'],'price':np.array([5,6,5,7])},index=['d','d','b','f'])
print(df1)
print(df2)

# 基於df1的beta列和df2的index鏈接，left_on='beta' 表示左邊這一列做爲右邊的索引
df9 = pd.merge(df1,df2,how='inner',left_on='beta',right_index=True)
df9

圖解index和column的內鏈接方法：

 

 設置參數suffixes以修改除鏈接列外相同列的後綴名。

# 基於df1的alpha列和df2的index內鏈接
df9 = pd.merge(df1,df2,how='inner',left_on='beta',right_index=True,suffixes=('_df1','_df2'))
df9

 2. join方法

　　join方法是基於index鏈接dataframe，merge方法是基於column鏈接，鏈接方法有內鏈接，外鏈接，左鏈接和右鏈接，與merge一致。 

       index與index的鏈接：

caller = 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']})
print(caller)print(other)
# lsuffix和rsuffix設置鏈接的後綴名
caller.join(other,lsuffix='_caller', rsuffix='_other',how='inner')

 join也能夠基於列進行鏈接：

caller = 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']})
print(caller)
print(other)

# 基於key列進行鏈接
caller.set_index('key').join(other.set_index('key'),how='inner')

 所以，join和merge的鏈接方法相似，這裏就不展開join方法了，建議用merge方法

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程