Pandas 数据处理:空值清洗、替换填充、级联与合并拼接


join_axes=[df1.columns] 的值是一个列表,表示指定以 df1.columns列索引 或df1.index行索引为连接,只连接匹配的项(行或者列)

针对空值的处理,首先要来了解一下空值的类型:

一、pandas中的None 和 NaN 有什么区别?

type(None) --类型是 NoneType 空的对象类型

type(NaN) --类型是 float 浮点型

注意:Pandas中None 和 NaN 都视作np.nan

二、Pandas 的空值操作

isnull()   判断null ,返回True/False 的数组
notnull()    空值判断
dropna()     过滤空值数据
fillna()    填充丢失数据

1、使用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()正好相反:

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)]

2、df.dropna() 过滤空数据所在的行或列 (可直接过滤)

df.dropna() 可以选择过滤的是行还是列,默认是行,dropna中axis=0 表示行; axis=1 表示列

df.dropna(axis=0)  #等同于上面过滤方式,封装了上面操作

3、fillna() 填充丢失/空值数据

fillna中 axis=0 表示列;axis=1 表示行

可选择向前或向后填充:

  1. method ='bfill' 向后覆盖(空值取前一个);
  2. method ='ffill' 向前覆盖(空值取后一个);
df.fillna(value =5555)   #填充df 中所有空值数据

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

4、drop 删除数据

drop 中 axis=0 表示行,axis=1 表示列

删除无用的列,列索引:'name','name1';inplace参数指是否替代原来的df

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

删除无用的行,行索引:'涨跌'

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

5、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)  #通常检测列里是否有空值,因为行数太多

三、pandas的级联操作

定义:对DataFram 进行横向或纵向的拼接

使用pandas.concat()级联

1、匹配级联

和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

2、不匹配级联

纵向级联( axis=0 -->在行上增加)时列索引不一致,

横向级联( axis=1 -->在列上增加)时行索引不一致

2.1、外连接:补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.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.3、使用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

四、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方法

Pandas 数据处理:空值清洗、替换填充、级联与合并拼接介绍到这里,更多Python学习请参考编程字典Python教程 和问答部分,谢谢大家对编程字典的支持。


原文链接:https://www.cnblogs.com/aitree/p/14303774.html