【pandas】 缺失数据

2023-11-14 17:02:09

第七章 缺失数据

一、缺失值的统计和删除

缺失信息的统计

缺失数据可以使用isna或isnull（两个函数没有区别）来查看每个单元格是否缺失

df.isna().sum()/df.shape[0] # 查看每列缺失的比例  sum默认对列求和
sub_set = df[['Height', 'Weight', 'Transfer']]
df[sub_set.isna().all(1)] # 指定列全部缺失的行
df[sub_set.isna().any(1)].head() # 指定列至少有一个缺失
df[sub_set.notna().all(1)].head() # 没有缺失

缺失信息的删除

df.dropna(axis=0, how='any', thresh:int=None, subset=None, inplace=False)

  • axis：默认为0， 删除行
  • how：‘any’ 或者 ‘all’
  • thresh：整数， 非缺失值没有达到这个数量的相应行或列会被删除，是how的补充
  • subset：备选的删除子集
res = df.dropna(1, thresh=df.shape[0]-15) #删除超过15个缺失值的列

dropna的替代操作——布尔索引

res = df.dropna(how = 'any', subset = ['Height', 'Weight'])
# 等价于
res = df.loc[df[['Height', 'Weight']].notna().all(1)]
# ------------------------------------------------------
res = df.dropna(1, thresh=df.shape[0]-15)
# 等价于
res = df.loc[:, ~(df.isna().sum()>15)]

二、缺失值的填充和插值

利用fillna进行填充

df.fillna(value=None, method=None, axis=None, inplace=False, limit=None)

  • value：标量（填充值）；（索引到元素的）字典映射、
  • method：{‘backfill’, ‘bfill’, ‘pad’, ‘ffill’, None}
  • limit：连续缺失值的最大填充次数
s = pd.Series([np.nan, 1, np.nan, np.nan, 2, np.nan], list('aaabcd'))
s.fillna(method='ffill') # 用前面的值向后填充
s.fillna(method='bfill', limit=1) # 连续出现的缺失，最多填充一次
s.fillna(s.mean()) # value为标量
s.fillna({'a': 100, 'd': 200}) # 通过索引映射填充的值

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

s = pd.Series([1, np.nan, 3, np.nan, np.nan,1])
(s.fillna(method='ffill',limit=1)+s.fillna(method="bfill", limit=1))/2
# 0    1.0
# 1    2.0
# 2    3.0
# 3    NaN
# 4    NaN
# 5    1.0
# dtype: float64

插值函数interpolate

常用且简单的三类情况，即线性插值linear、最近邻插值nearest和索引插值index。

Series.interpolate(method='linear', axis=0, limit=None, inplace=False, limit_direction=None)

  • method：常用的三种：线性插值linear、最近邻插值nearest和索引插值index
  • limit_direction：{forward, backward, both}默认forward
  • limit：同fillna，限制最大连续插值数
# ------------------线性插值
s = pd.Series([np.nan, np.nan, 1, np.nan, np.nan, np.nan, 2, np.nan, np.nan])
res = s.interpolate(limit_direction='backward', limit=1)
# array([ nan, 1.  , 1.  ,  nan,  nan, 1.75, 2.  ,  nan,  nan])
res = s.interpolate(limit_direction='both', limit=1)
# array([ nan, 1. , 1. , 1.25, nan, 1.75, 2., 1.66666667,1.33333333, 1.])

# ------------------最近邻插值
s.interpolate('nearest',limit_direction="backward", limit=1).values 
# 后面怎么不插值了？ ‘nearest’只有当两端有非缺失值才会插值

# ------------------索引插值：根据索引大小进行线性插值
s = pd.Series([0,np.nan,20],index=[0,1,10])
# 0      0.0
# 1      NaN
# 10    10.0
# dtype: float64
s.interpolate(method='index') # 和索引有关的线性插值，计算相应索引大小对应的值
# 0      0.0
# 1      2.0
# 10    20.0
# dtype: float64

【NOTE】关于polynomial和spline插值的注意事项

在interpolate中如果选用polynomial的插值方法，它内部调用的是scipy.interpolate.interp1d(*,*,kind=order)，这个函数内部调用的是make_interp_spline方法，因此其实是样条插值而不是类似于numpy中的polyfit多项式拟合插值；而当选用spline方法时，pandas调用的是scipy.interpolate.UnivariateSpline而不是普通的样条插值。这一部分的文档描述比较混乱，而且这种参数的设计也是不合理的，当使用这两类插值方法时，用户一定要小心谨慎地根据自己的实际需求选取恰当的插值方法。

三、Nullable类型

缺失记号及其缺陷

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

在numpy中利用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

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

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

pd.Series([1, 'two'])
#0      1
#1    two
#dtype: object

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

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

pd.Series([1, np.nan]).dtype
# dtype('float64')
pd.Series([True, False, np.nan]).dtype
# dtype('O')

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

Nullable类型的性质

从字面意义上看Nullable就是可空的，言下之意就是序列类型不受缺失值的影响。例如，在上述三个Nullable类型中存储缺失值，都会转为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: stringx

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

第一点是带有缺失的布尔列表无法进行索引器中的选择，而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]

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

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

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

df = df.convert_dtypes()

缺失数据的计算和分组

计算

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

s = pd.Series([2,3,np.nan,4,5])
s.sum()
# 14.0
s.prod()
# 120.0
s.cumsum()
# 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
# False
pd.NA == 0
# <NA>
np.nan > 0
# False
pd.NA > 0
# <NA>
np.nan + 1
# nan
np.nan ** 0
# 1.0
pd.NA ** 0
# 1
1 ** np.nan
# 1.0
1 ** pd.NA
# 1

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

s
# 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，并且会跳过缺失值计算变化率
# 0         NaN
# 1    0.500000
# 2    0.000000
# 3    0.333333
# 4    0.250000
# dtype: float64

分组

对于一些函数而言，缺失可以作为一个类别处理，例如在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() # pandas版本大于1.1.0
# 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

练习

Ex1：缺失值与类别因变量的相关性检验

在数据处理中，含有过多缺失值的列往往会被删除，除非缺失情况与标签强相关。下面有一份关于二分类问题的数据集，其中X_1, X_2为特征变量，y为二分类标签。

事实上，有时缺失值出现或者不出现本身就是一种特征，并且在一些场合下可能与标签的正负是相关的。关于缺失出现与否和标签的正负性，在统计学中可以利用卡方检验来断言它们是否存在相关性。按照特征缺失的正例、特征缺失的负例、特征不缺失的正例、特征不缺失的负例，可以分为四种情况，设它们分别对应的样例数为 n 11 , n 10 , n 01 , n 00 n_{11}, n_{10}, n_{01}, n_{00} n11​,n10​,n01​,n00​。假若它们是不相关的，那么特征缺失中正例的理论值，就应该接近于特征缺失总数 × \times ×总体正例的比例，即：

E 11 = n 11 ≈ ( n 11 + n 10 ) × n 11 + n 01 n 11 + n 10 + n 01 + n 00 = F 11 E_{11} = n_{11} \approx (n_{11}+n_{10})\times\frac{n_{11}+n_{01}}{n_{11}+n_{10}+n_{01}+n_{00}} = F_{11} E11​=n11​≈(n11​+n10​)×n11​+n10​+n01​+n00​n11​+n01​​=F11​

其他的三种情况同理。现将实际值和理论值分别记作 E i j , F i j E_{ij}, F_{ij} Eij​,Fij​，那么希望下面的统计量越小越好，即代表实际值接近不相关情况的理论值：

S = ∑ i ∈ { 0 , 1 } ∑ j ∈ { 0 , 1 } ( E i j − F i j ) 2 F i j S = \sum_{i\in \{0,1\}}\sum_{j\in \{0,1\}} \frac{(E_{ij}-F_{ij})^2}{F_{ij}} S=i∈{0,1}∑​j∈{0,1}∑​Fij​(Eij​−Fij​)2​

可以证明上面的统计量近似服从*度为 1 1 1的卡方分布，即 S ∼ ⋅ χ 2 ( 1 ) S\overset{\cdot}{\sim} \chi^2(1) S∼⋅χ2(1)。因此，可通过计算 P ( χ 2 ( 1 ) > S ) P(\chi^2(1)>S) P(χ2(1)>S)的概率来进行相关性的判别，一般认为当此概率小于 0.05 0.05 0.05时缺失情况与标签正负存在相关关系，即不相关条件下的理论值与实际值相差较大。

上面所说的概率即为统计学上关于 2 × 2 2\times2 2×2列联表检验问题的 p p p值， 它可以通过scipy.stats.chi2(S, 1)得到。请根据上面的材料，分别对X_1, X_2列进行检验。

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

import scipy

def na_chi2test(x, y):
    df_new = pd.DataFrame({"x": x.isna(), "y": y})
    df_joint = df_new.groupby("y")["x"].agg([("na", sum)])
    df_joint['~na'] = df_new['y'].value_counts() - df_new.groupby("y")["x"].agg([("na", sum)])['na']      # 联合频数分布
    joint_e = df_joint.sum(axis=1).values[:,np.newaxis]*df_joint.sum(axis=0).values/df.y.shape[0] # 期望频数分布
    s = ((df_joint - joint_e)**2/joint_e).sum(axis=0).sum() # chiq统计量的值
    p = 1-scipy.stats.chi2.cdf(s, 1)  # 计算比s更偏激的样本出现的概率p值
    return p
na_chi2test(df['X_1'], df.y) # 不能拒绝原假设，不相关
# 0.9712760884395901
na_chi2test(df["X_2"], df.y) # 拒绝原假设，存在相关关系
# 0

Ex2：用回归模型解决分类问题（1vs多）

KNN是一种监督式学习模型，既可以解决回归问题，又可以解决分类问题。对于分类变量，利用KNN分类模型可以实现其缺失值的插补，思路是度量缺失样本的特征与所有其他样本特征的距离，当给定了模型参数n_neighbors=n时，计算离该样本距离最近的 n n n个样本点中最多的那个类别，并把这个类别作为该样本的缺失预测类别。

有色点的特征数据提供如下：

df = pd.read_excel('../data/color.xlsx')
df.head(3)

# 	X1		X2	Color
# 0	-2.5	2.8	Blue
# 1	-1.5	1.8	Blue
# 2	-0.8	2.8	Blue

已知待预测的样本点为

上一篇：在苹果Mac中将 WEBP 图片转成 JPG、PNG 格式的 2 种方法


下一篇：pandas/power bi merge的时候匹配不出值