Python中isna python中isna和isnull_mob6454cc6bcf40的技术博客_

缺失数据

import pandas as pd 
import numpy as np

一、缺失信息的统计和删除

1. 缺失信息的统计

缺失数据可以使用 isna 或 isnull （两个函数没有区别）来查看每个单元格是否缺失，结合 mean 可以计算出每列缺失值的比例，sum可以计算每列缺失值的总数：

df = pd.read_csv('data/learn_pandas.csv',
                usecols=['Grade','Name','Gender','Height','Weight','Transfer'])
df.isna().head()

	Grade	Name	Gender	Height	Weight	Transfer
0	False	False	False	False	False	False
1	False	False	False	False	False	False
2	False	False	False	False	False	False
3	False	False	False	True	False	False
4	False	False	False	False	False	False

df.isna().mean()

Grade        0
Name         0
Gender       0
Height      17
Weight      11
Transfer    12
dtype: int64

1.查看某一列缺失或者非缺失的行，可以利用 Series 上的 isna 或者 notna 进行布尔索引

df[df.Height.isna()].head()

	Grade	Name	Gender	Height	Weight	Transfer
3	Sophomore	Xiaojuan Sun	Female	NaN	41.0	N
12	Senior	Peng You	Female	NaN	48.0	NaN
26	Junior	Yanli You	Female	NaN	48.0	N
36	Freshman	Xiaojuan Qin	Male	NaN	79.0	Y
60	Freshman	Yanpeng Lv	Male	NaN	65.0	N

2.同时对几个列，检索出全部为缺失或者至少有一个缺失或者没有缺失的行，可以使用 isna, notna 和 any, all 的组合

sub_set = df[['Height','Weight','Transfer']]
df[sub_set.isna().all(1)]#全部缺失

	Grade	Name	Gender	Height	Weight	Transfer
102	Junior	Chengli Zhao	Male	NaN	NaN	NaN

df[sub_set.isna().any(1)].head() #至少一个缺失

	Grade	Name	Gender	Height	Weight	Transfer
3	Sophomore	Xiaojuan Sun	Female	NaN	41.0	N
9	Junior	Juan Xu	Female	164.8	NaN	N
12	Senior	Peng You	Female	NaN	48.0	NaN
21	Senior	Xiaopeng Shen	Male	166.0	62.0	NaN
26	Junior	Yanli You	Female	NaN	48.0	N

df[sub_set.notna().all(1)].head()

	Grade	Name	Gender	Height	Weight	Transfer
0	Freshman	Gaopeng Yang	Female	158.9	46.0	N
1	Freshman	Changqiang You	Male	166.5	70.0	N
2	Senior	Mei Sun	Male	188.9	89.0	N
4	Sophomore	Gaojuan You	Male	174.0	74.0	N
5	Freshman	Xiaoli Qian	Female	158.0	51.0	N

2. 缺失信息的删除

1.dropna函数

参数：

axis：轴方向，默认0(行)

how：删除方式，any/all

thresh：删除的非缺失值个数阈值（非缺失值没有达到这个数量的相应维度会被删除

subset：备选的删除子集

例：删除身高体重至少有一个缺失的行

res = df.dropna(how='any', subset=['Height','Weight'])
print(df.shape)
res.shape

(200, 6)
(174, 6)

例：删除超过15个缺失值的列

df.shape[0]

res = df.dropna(1, thresh=df.shape[0]-15)
#1代表按列删除，thresh反映的非缺失值，所以这里需要转换一下
res.head()

	Grade	Name	Gender	Weight	Transfer
0	Freshman	Gaopeng Yang	Female	46.0	N
1	Freshman	Changqiang You	Male	70.0	N
2	Senior	Mei Sun	Male	89.0	N
3	Sophomore	Xiaojuan Sun	Female	41.0	N
4	Sophomore	Gaojuan You	Male	74.0	N

二、缺失值的填充和插值

1. 利用fillna进行填充

参数:

value：填充值，可以是标量、索引到元素的字典映射

method：填充方法，ffill：前面的元素填充；bfill：用后面的元素填充

limit：连续缺失值的最大填充次数

s = pd.Series([np.nan, 1, np.nan, np.nan, 2, np.nan],
             list('aaabcd'))
s

a    NaN
a    1.0
a    NaN
b    NaN
c    2.0
d    NaN
dtype: float64

s.fillna(method='ffill')

a    NaN
a    1.0
a    1.0
b    1.0
c    2.0
d    2.0
dtype: float64

s.fillna(method='ffill',limit=1)# 连续出现的缺失，最多填充一次

a    NaN
a    1.0
a    1.0
b    NaN
c    2.0
d    2.0
dtype: float64

s.fillna(s.mean())# value为标量

a    1.5
a    1.0
a    1.5
b    1.5
c    2.0
d    1.5
dtype: float64

s.fillna({'a':100, 'd':200}) # 通过索引映射填充的值

a    100.0
a      1.0
a    100.0
b      NaN
c      2.0
d    200.0
dtype: float64

1.进行分组后再操作

例：据年级进行身高的均值填充

df.groupby('Grade')['Height'].transform(lambda x: x.fillna(x.mean())).head()

0    158.900000
1    166.500000
2    188.900000
3    163.075862
4    174.000000
Name: Height, dtype: float64

2. 练一练1

对一个序列以如下规则填充缺失值：如果单独出现的缺失值，就用前后均值填充，如果连续出现的缺失值就不填充，即序列[1, NaN, 3, NaN, NaN]填充后为[1, 2, 3, NaN, NaN]，请利用 fillna 函数实现。（提示：利用 limit 参数）

思路：缺失值只出现一次，所以限制limit=1

df1 = pd.Series([1, np.nan, 3, np.nan, np.nan])
df1.fillna(df1.mean(),limit=1)

0    1.0
1    2.0
2    3.0
3    NaN
4    NaN
dtype: float64

之后在群里看见大佬的解释，如果将序列变为[1, np.nan, 3, np.nan, np.nan,5,np.nan]，上面的条件就是错误的，还在考虑如何实现

df2 = pd.Series([1, np.nan, 3, np.nan, np.nan,5,np.nan])
df2.fillna(df2.mean(),limit=1)

0    1.0
1    3.0
2    3.0
3    NaN
4    NaN
5    5.0
6    NaN
dtype: float64

3. 插值函数

interpolate函数：

参数：

limit_direction：控制方向，默认为 forward，向后：backward，双向：both

limit：控制最大连续缺失值插值个数
默认为 linear 线性插值插入方法

s = pd.Series([np.nan, np.nan, 1, np.nan, np.nan, np.nan, 2, np.nan, np.nan])
s.values

array([nan, nan,  1., nan, nan, nan,  2., nan, nan])

1.线性插值法

res = s.interpolate(limit_direction='forward',limit=1) 
res.values

array([ nan,  nan, 1.  , 1.25,  nan,  nan, 2.  , 2.  ,  nan])

res = s.interpolate(limit_direction='backward',limit=1) 
res.values

array([ nan, 1.  , 1.  ,  nan,  nan, 1.75, 2.  ,  nan,  nan])

res = s.interpolate(limit_direction='both',limit=1)
res.values

array([ nan, 1.  , 1.  , 1.25,  nan, 1.75, 2.  , 2.  ,  nan])

2.最近邻插补(nearest)

缺失值的元素和离它最近的非缺失值元素一样

s.interpolate('nearest').values

array([nan, nan,  1.,  1.,  1.,  2.,  2., nan, nan])

3.索引插值

根据索引大小进行线性插值

s = pd.Series([0,np.nan,10],index=[0,1,10])
s

0      0.0
1      NaN
10    10.0
dtype: float64

s.interpolate() # 默认的线性插值，等价于计算中点的值

0      0.0
1      5.0
10    10.0
dtype: float64

s.interpolate(method='index')# 和索引有关的线性插值，计算相应索引大小对应的值

0      0.0
1      1.0
10    10.0
dtype: float64

这种方法对于时间戳索引也是可以使用

s = pd.Series([0,np.nan,10],
             index=pd.to_datetime(['20200101','20200102','20200111']))
s

2020-01-01     0.0
2020-01-02     NaN
2020-01-11    10.0
dtype: float64

s.interpolate()

2020-01-01     0.0
2020-01-02     5.0
2020-01-11    10.0
dtype: float64

s.interpolate(method='index')

2020-01-01     0.0
2020-01-02     1.0
2020-01-11    10.0
dtype: float64

三、Nullable类型

1. 缺失记号及其缺陷

1.None

在 python 中的缺失值用 None 表示，该元素除了等于自己本身之外，与其他任何元素不相等

None == None

True

None == False

False

2.np.nan

在 numpy 中利用 np.nan 来表示缺失值，该元素除了不和其他任何元素相等之外，和自身的比较结果也返回 False

np.nan == np.nan

False

虽然在对缺失序列或表格的元素进行比较操作的时候， np.nan 的对应位置会返回 False ，但是在使用 equals 函数进行两张表或两个序列的相同性检验时，会自动跳过两侧表都是缺失值的位置，直接返回 True

s1 = pd.Series([1,np.nan])
s2 = pd.Series([1,2])
s3 = pd.Series([1, np.nan])
s1 == 1

0     True
1    False
dtype: bool

s1.equals(s2)

False

s1.equals(s3)

True

3.pd.NaT

在时间序列的对象中， pandas 利用 pd.NaT 来指代缺失值，它的作用和 np.nan 是一致的

pd.to_timedelta(['30s',np.nan])# Timedelta中的NaT

TimedeltaIndex(['0 days 00:00:30', NaT], dtype='timedelta64[ns]', freq=None)

pd.to_datetime(['20200101', np.nan]) # Datetime中的NaT

DatetimeIndex(['2020-01-01', 'NaT'], dtype='datetime64[ns]', freq=None)

为什么要引入 pd.NaT 来表示时间对象中的缺失呢？仍然以 np.nan 的形式存放会有什么问题？在 pandas 中可以看到 object 类型的对象，而 object 是一种混杂对象类型，如果出现了多个类型的元素同时存储在 Series 中，它的类型就会变成 object

pd.Series([1,'two'])

0      1
1    two
dtype: object

NaT 问题的根源来自于 np.nan 的本身是一种浮点类型，而如果浮点和时间类型混合存储，如果不设计新的内置缺失类型来处理，就会变成含糊不清的 object 类型

type(np.nan)

float

同时，由于 np.nan 的浮点性质，如果在一个整数的 Series 中出现缺失，那么其类型会转变为 float64 ；而如果在一个布尔类型的序列中出现缺失，那么其类型就会转为 object 而不是 bool

pd.Series([1, np.nan]).dtype

dtype('float64')

pd.Series([True, False, np.nan]).dtype

dtype('O')

pandas 尝试设计了一种新的缺失类型 pd.NA 以及三种 Nullable 序列类型来应对这些缺陷，它们分别是 Int, boolean 和 string

2. Nullable类型的性质

Nullable 就是可空的，言下之意就是序列类型不受缺失值的影响，例如，在上述三个 Nullable 类型(Int, boolean 和 string)中存储缺失值，都会转为 pandas 内置的 pd.NA ：

pd.Series([np.nan, 1],dtype='Int64') #'I'大写

0    <NA>
1       1
dtype: Int64

pd.Series([np.nan, True], dtype = 'boolean')

0    <NA>
1    True
dtype: boolean

pd.Series([np.nan, 'my_str'], dtype = 'string')

0      <NA>
1    my_str
dtype: string

在 Int 的序列中，返回的结果会尽可能地成为 Nullable 的类型：

pd.Series([np.nan, 0], dtype = 'Int64') + 1

0    <NA>
1       1
dtype: Int64

pd.Series([np.nan, 0], dtype = 'Int64') == 0

0    <NA>
1    True
dtype: boolean

pd.Series([np.nan, 0], dtype = 'Int64') * 0.5 # 只能是浮点

0    NaN
1    0.0
dtype: float64

对于 boolean 类型的序列而言，其和 bool 序列的行为主要有两点区别:

(1)带有缺失的布尔列表无法进行索引器中的选择，而 boolean 会把缺失值看作 False

s = pd.Series(['a', 'b'])
s_bool = pd.Series([True, np.nan])
s_boolean = pd.Series([True, np.nan]).astype('boolean')

try:
    s[s_bool]
except Exception as e:
        Err_Msg = e
Err_Msg

ValueError('Cannot mask with non-boolean array containing NA / NaN values')

s[s_boolean]

0    a
dtype: object

(2) 在进行逻辑运算时， bool 类型在缺失处返回的永远是 False ，而 boolean 会根据逻辑运算是否能确定唯一结果来返回相应的值。

那什么叫能否确定唯一结果呢？举个简单例子： True | pd.NA 中无论缺失值为什么值，必然返回 True ； False | pd.NA 中的结果会根据缺失值取值的不同而变化，此时返回 pd.NA ； False & pd.NA 中无论缺失值为什么值，必然返回 False

s_boolean & True

0    True
dtype: boolean

s_boolean | True

0    True
1    True
dtype: boolean

~s_boolean # 取反操作同样是无法唯一地判断缺失结果

0    False
dtype: boolean

一般在实际数据处理时，可以在数据集读入后，先通过 convert_dtypes 转为 Nullable 类型

df = pd.read_csv('data/learn_pandas.csv')
df = df.convert_dtypes()
df.dtypes

School          string
Grade           string
Name            string
Gender          string
Height         float64
Weight           Int64
Transfer        string
Test_Number      Int64
Test_Date       string
Time_Record     string
dtype: object

3. 缺失数据的计算和分组

1.sum, prod

当调用函数 sum, prob 使用加法和乘法的时候，缺失数据等价于被分别视作0和1，即不改变原来的计算结果

s = pd.Series([2,3,np.nan,4,5])
s.sum()

14.0

s.prod()

120.0

2.累计函数

当使用累计函数时，会自动跳过缺失值所处的位置

s.cumsum()

0     2.0
1     5.0
2     NaN
3     9.0
4    14.0
dtype: float64

3.单个标量运算

除了 np.nan ** 0 和 1 ** np.nan 这两种情况为确定的值之外，所有运算结果全为缺失（ pd.NA 的行为与此一致），并且 np.nan 在比较操作时一定返回 False ，而 pd.NA 返回 pd.NA

np.nan ** 0

1.0

1 ** np.nan

1.0

pd.NA ** 0

1 ** pd.NA

np.nan == 0

False

pd.NA == 0

<NA>

np.nan + 1

nan

np.log(np.nan)

nan

np.add(np.nan, 1)

nan

4.diff, pct_change

diff：凡是参与缺失计算的部分全部设为了缺失值，求与前一个元素的差

pct_change：缺失值位置会被设为 0% 的变化率，求当前元素与先前n个元素的相差百分比，指定periods=n

0    2.0
1    3.0
2    NaN
3    4.0
4    5.0
dtype: float64

s.diff()

0    NaN
1    1.0
2    NaN
3    NaN
4    1.0
dtype: float64

s.pct_change()

0         NaN
1    0.500000
2    0.000000
3    0.333333
4    0.250000
dtype: float64

5.对于一些函数而言，缺失可以作为一个类别处理，例如在 groupby, get_dummies 中可以设置相应的参数来进行增加缺失类别

df_nan = pd.DataFrame({'category':['a','a','b',np.nan,np.nan],
                      'value':[1,3,5,7,9]})
df_nan

	category	value
0	a	1
1	a	3
2	b	5
3	NaN	7
4	NaN	9

df_nan.groupby('category',dropna=False)['value'].mean()

category
a      2
b      5
NaN    8
Name: value, dtype: int64

pd.get_dummies(df_nan.category, dummy_na=True)

	a	b	NaN
0	1	0	0
1	1	0	0
2	0	1	0
3	0	0	1
4	0	0	1

练习题我还没看懂，计划学到后面之后再回来继续写