pandas第七章- 缺失数据--缺失值的统计、删除、填充、插值、Nullable类型

一、缺失值的统计和删除

1.缺失信息的统计
isna 或 isnull查看每个单元格是否缺失

#mean 可以计算出每列缺失值的比例。因为true是1，false是0
df.isna().mean() # 查看每列的缺失比例
Out[5]: 
Grade       0.000
Name        0.000
Gender      0.000
Height      0.085
Weight      0.055
Transfer    0.060
dtype: float64

查看某一列缺失的行：df[df.列名.isnull()]

#查看某一列缺失的行
df[df.Height.isna()].head()

如果想要同时对几个列，检索出全部为缺失或者至少有一个缺失或者没有缺失的行，可以使用 isna, notna 和 any, all 的组合。
df[列组合名.isnull().all(1)] 筛选列组合中的列全部缺失的行
df[列组合名.isnull().any(1)] 筛选列组合中的列至少有一个缺失的行
df[列组合名.notna().all(1)] 筛选列组合中的列都没有缺失的行

sub_set = df[['Height', 'Weight', 'Transfer']]  #多列组合成一个集合，名为sub_set

df[sub_set.isna().all(1)] # sub_set中列全部缺失的行
Out[8]: 
      Grade          Name Gender  Height  Weight Transfer
102  Junior  Chengli Zhao   Male     NaN     NaN      NaN

df[sub_set.isna().any(1)].head() # sub_set中列至少有一个缺失
Out[9]: 
        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() # sub_set中列没有缺失的行筛选出来
Out[10]: 
       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. 缺失信息的删除
dropna
dropna 的主要参数为轴方向 axis （默认为0，即删除行）、删除方式 how 、删除的非缺失值个数阈值 thresh （ 非缺失值 没有达到这个数量的相应维度会被删除）、备选的删除子集 subset ，其中 how 主要有 any 和 all 两种参数可以选择。

#删除身高体重至少有一个缺失的行：
res = df.dropna(how = 'any', subset = ['Height', 'Weight'])    #法一
res = df.loc[df[['Height', 'Weight']].notna().all(1)]  #法二

#删除超过15个缺失值的列：
res = df.dropna(1, thresh=df.shape[0]-15) # 身高列被删除 ，法一
res = df.loc[:, ~(df.isna().sum()>15)]   #法二

二、缺失值的填充和插值

1. 利用fillna进行填充
常用参数： value, method, limit 。
其中， value 为填充值，可以是标量，也可以是索引到元素的字典映射； method 为填充方法，有用前面的元素填充 ffill 和用后面的元素填充 bfill 两种类型， limit 参数表示连续缺失值的最大填充次数。

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


s
Out[20]: 
a    NaN
a    1.0
a    NaN
b    NaN
c    2.0
d    NaN
dtype: float64

s.fillna(method='ffill') # 用前面的值向后填充
Out[21]: 
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) # 连续出现的缺失，最多填充一次
Out[22]: 
a    NaN
a    1.0
a    1.0
b    NaN
c    2.0
d    2.0
dtype: float64

s.fillna(s.mean()) # value为标量
Out[23]: 
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}) # 通过索引映射填充的值
Out[24]: 
a    100.0
a      1.0
a    100.0
b      NaN
c      2.0
d    200.0
dtype: float64

有时为了更加合理地填充，需要先进行分组后再操作
df.groupby(‘分组列名’)[‘填充列名’].transform(lambda x:x.fillna(x.mean()))

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

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

2. 插值函数
interpolate 函数
比较常用且简单的三类情况:线性插值、最近邻插值和索引插值。

对于 interpolate 而言，除了插值方法（默认为 linear 线性插值）之外，有与 fillna 类似的两个常用参数，一个是控制方向的 limit_direction ，另一个是控制最大连续缺失值插值个数的 limit 。其中，限制插值的方向默认为 forward ，这与 fillna 的 method 中的 ffill 是类似的，若想要后向限制插值或者双向限制插值可以指定为 backward 或 both 。

例子：先设定一组缺失数据

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


s.values
Out[27]: array([nan, nan,  1., nan, nan, nan,  2., nan, nan])

1)在默认线性插值法下分别进行 backward 和双向限制插值，同时限制最大连续条数为1：
s.interpolate(limit_direction = ‘backward’ , limit = 1)

res = s.interpolate(limit_direction='backward', limit=1)
#它的向后实际是向前，limit=1指只向后填充一个
res.values
Out[29]: array([ nan, 1.  , 1.  ,  nan,  nan, 1.75, 2.  ,  nan,  nan])

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

res.values
Out[31]: array([ nan, 1.  , 1.  , 1.25,  nan, 1.75, 2.  , 2.  ,  nan])

2)第二种常见的插值是最近邻插补，即缺失值的元素和离它最近的非缺失值元素一样：
s.interpolate(‘nearest’)

s.interpolate('nearest').values
Out[32]: array([nan, nan,  1.,  1.,  1.,  2.,  2., nan, nan])
#往后填充的，所以先有值之后，后面的空才有值填充

3)最后来介绍索引插值，即根据索引大小进行线性插值。
例子：

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

s
Out[34]: 
0      0.0
1      NaN
10    10.0
dtype: float64

s.interpolate() # 默认的线性插值，等价于计算中点的值
Out[35]: 
0      0.0
1      5.0
10    10.0
dtype: float64

s.interpolate(method='index') # 和索引有关的线性插值，计算相应索引大小对应的值
Out[36]: 
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
Out[38]: 
2020-01-01     0.0
2020-01-02     NaN
2020-01-11    10.0
dtype: float64

s.interpolate()
Out[39]: 
2020-01-01     0.0
2020-01-02     5.0
2020-01-11    10.0
dtype: float64

s.interpolate(method='index')
Out[40]: 
2020-01-01     0.0
2020-01-02     1.0
2020-01-11    10.0
dtype: float64

三、Nullable类型

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

None == None
Out[41]: True
#再判断等于其他任何，都会报错

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

np.nan == np.nan
Out[45]: False

np.nan == None
Out[46]: False

np.nan == False
Out[47]: 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
Out[51]: 
0     True
1    False
dtype: bool

s1.equals(s2)
Out[52]: False

s1.equals(s3)
Out[53]: True

即：列表equals()函数判断时，两个np.nan会认为为True

3）在时间序列的对象中， pandas 利用 pd.NaT 来指代缺失值，它的作用和 np.nan 是一致的
那么为什么要引入 pd.NaT 来表示时间对象中的缺失呢？仍然以 np.nan 的形式存放会有什么问题？
在 pandas 中可以看到 object 类型的对象，而 object 是一种混杂对象类型，如果出现了多个类型的元素同时存储在 Series 中，它的类型就会变成 object 。
NaT 问题的根源来自于 np.nan 的本身是一种浮点类型，而如果浮点和时间类型混合存储，如果不设计新的内置缺失类型来处理，就会变成含糊不清的 object 类型，这显然是不希望看到的。

type(np.nan)
Out[57]: float

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

pd.Series([1, np.nan]).dtype
Out[58]: dtype('float64')

pd.Series([True, False, np.nan]).dtype
Out[59]: dtype('O')

简而言之：有np.nan在，会改变原来数组的类型，使之成为float类型

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

2. Nullable类型的性质
从字面意义上看 Nullable 就是可空的，言下之意就是序列类型不受缺失值的影响。
在Int, boolean 和 string类型中存储缺失值，都会转为 pandas 内置的 pd.NA ：

#都是转成了<NA>
pd.Series([np.nan, 1], dtype = 'Int64') # "i"是大写的
Out[60]: 
0    <NA>
1       1
dtype: Int64

pd.Series([np.nan, True], dtype = 'boolean')
Out[61]: 
0    <NA>
1    True
dtype: boolean

pd.Series([np.nan, 'my_str'], dtype = 'string')
Out[62]: 
0      <NA>
1    my_str
dtype: string

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

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

# s[s_bool] # 报错
s[s_boolean]
Out[69]: 
0    a
dtype: object

2）在进行逻辑运算时， bool 类型在缺失处返回的永远是 False ，而 boolean 会根据逻辑运算是否能确定唯一结果来返回相应的值。
那什么叫能否确定唯一结果呢？举个简单例子： True | pd.NA 中无论缺失值为什么值，必然返回 True ； False | pd.NA 中的结果会根据缺失值取值的不同而变化，此时返回 pd.NA ； False & pd.NA 中无论缺失值为什么值，必然返回 False 。

s_boolean = pd.Series([True, np.nan]).astype('boolean')
s_boolean & True
Out[70]: 
0    True
1    <NA>
dtype: boolean

s_boolean | True
Out[71]: 
0    True
1    True
dtype: boolean

~s_boolean # 取反操作同样是无法唯一地判断缺失结果
Out[72]: 
0    False
1     <NA>
dtype: boolean

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

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

df = df.convert_dtypes()

3. 缺失数据的计算和分组
当调用函数 sum加法时，缺失数据等价于被分别视作0，
当调用函数 prod加法时，缺失数据等价于被分别视作1，
即不改变原来的计算结果：

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

s.sum()
Out[77]: 14.0

s.prod()
Out[78]: 120.0

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

s.cumsum()
Out[79]: 
0     2.0
1     5.0
2     NaN
3     9.0
4    14.0
dtype: float64

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

np.nan == 0
Out[80]: False

pd.NA == 0
Out[81]: <NA>

pd.NA ** 0
Out[88]: 1

1 ** np.nan
Out[89]: 1.0

diff, pct_change 这两个函数虽然功能相似，但是对于缺失的处理不同，前者凡是参与缺失计算的部分全部设为了缺失值，而后者缺失值位置会被设为 0% 的变化率

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