pandas-task07-缺失数据.md

缺失数据

在数据处理过程种我们经常会遇到缺失数据如NaN或None这样的值，我们一般会对这些数据单独处理，删除或者修改或者忽略等，下面分不同情况讨论下如何处理缺失数据。
下面操作以此表格为基础，表格如下

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

	Grade	Name	Gender	Height	Weight	Transfer
0	Freshman	Gaopeng Yang	Female	158.9	46	N
1	Freshman	Changqiang You	Male	166.5	70	N
2	Senior	Mei Sun	Male	188.9	89	N
3	Sophomore	Xiaojuan Sun	Female	nan	41	N
4	Sophomore	Gaojuan You	Male	174	74	N

看下前三个和最后三个的空值情况，都不为空。

pd.concat([df.isna().head(3),df.isna().tail(3)])

一、缺失值的统计和删除

1. 缺失信息的统计

缺失数据可以使用 isna 或 isnull （两个函数没有区别）来查看每个单元格是否缺失，结合sum()和mean()可以查看某缺失值数量及占比情况：

print(df.isna().sum())
print(df.isna().mean())

空值数量

	0
Grade	0
Name	0
Gender	0
Height	17
Weight	11
Transfer	12

空值占比情况

	0
Grade	0
Name	0
Gender	0
Height	0.085
Weight	0.055
Transfer	0.06

如果想要查看某一列缺失或者非缺失的行，可以利用 Series 上的 isna 或者 notna 进行布尔索引。例如，查看身高缺失的行：

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

	Grade	Name	Gender	Height	Weight	Transfer
3	Sophomore	Xiaojuan Sun	Female	nan	41	N
12	Senior	Peng You	Female	nan	48	nan
26	Junior	Yanli You	Female	nan	48	N
36	Freshman	Xiaojuan Qin	Male	nan	79	Y
60	Freshman	Yanpeng Lv	Male	nan	65	N

打印一下df.Height.isna()看看上面df传入的是什么

df.Height.isna()

可以看到本质传入的是一个bool型的Series，筛选出非空的数据（索引为Ture）。那么我们试一下传入一个bool型的list是不是一样的效果。

test1=[True for i in range(1,len(df))]
test1.append(False)
df[test1].tail()

	Grade	Name	Gender	Height	Weight	Transfer
194	Senior	Yanmei Qian	Female	160.3	49	nan
195	Junior	Xiaojuan Sun	Female	153.9	46	N
196	Senior	Li Zhao	Female	160.9	50	N
197	Senior	Chengqiang Chu	Female	153.9	45	N
198	Senior	Chengmei Shen	Male	175.3	71	N

可以看到效果完全一致，我们传入了一个长度和df相同的bool型list,除最后一共元素为False外全为True,成功过滤掉最后一行。

如果想要同时对几个列，检索出全部为缺失或者至少有一个缺失或者没有缺失的行，可以使用 isna, notna 和 any, all 的组合。例如，对身高、体重和转系情况这3列分别进行这三种情况的检索：

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() # 没有缺失

all的作用是判断指定轴的所有元素是否都为真，返回bool型的Series。any是只要有真就返回True.
全部缺失情况

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

至少有一个缺失

	Grade	Name	Gender	Height	Weight	Transfer
3	Sophomore	Xiaojuan Sun	Female	nan	41	N
9	Junior	Juan Xu	Female	164.8	nan	N
12	Senior	Peng You	Female	nan	48	nan
21	Senior	Xiaopeng Shen	Male	166	62	nan
26	Junior	Yanli You	Female	nan	48	N

没有缺失

	Grade	Name	Gender	Height	Weight	Transfer
0	Freshman	Gaopeng Yang	Female	158.9	46	N
1	Freshman	Changqiang You	Male	166.5	70	N
2	Senior	Mei Sun	Male	188.9	89	N
4	Sophomore	Gaojuan You	Male	174	74	N
5	Freshman	Xiaoli Qian	Female	158	51	N

2. 缺失信息的删除

数据处理中经常需要根据缺失值的大小、比例或其他特征来进行行样本或列特征的删除， pandas 中提供了 dropna 函数来进行操作。

dropna 的主要参数为轴方向 axis （默认为0，即删除行）、删除方式 how 、删除的非缺失值个数阈值 thresh—threshold阈值的简写 （ 非缺失值 没有达到这个数量的相应维度会被删除）、备选的删除子集 subset ，其中 how 主要有 any 和 all 两种参数可以选择。

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

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

输出为(174, 6)，删掉了26行数据。

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

res=df.dropna(axis=1,thresh=df.shape[0]-15)
res.shape

输出(200, 5) 身高被删除。

当然，不用 dropna 同样是可行的，例如上述的两个操作，也可以使用布尔索引来完成：

res1 = df.loc[df[['Height', 'Weight']].notna().all(1)]
res2 = df.loc[:, ~(df.isna().sum()>15)]

二、缺失值的填充和插值

1. 利用fillna进行填充

在 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.fillna(method='ffill', limit=1) # 用前面的值向后填充
s.ffill(limit=1) # 和上面的等价
s.fillna(s.mean())

注意含有缺失值的列中，计算均值时缺失值是不计算的，如果希望含有缺失值的行都不计入计算过程，可以事先采用上面提到的统计和删除操作进行预处理。如果希望计入计算，可以使用对应规则对缺失值填充。
有时为了更加合理地填充，需要先进行分组后再操作。例如，根据年级进行身高的均值填充：

df.Height=df.groupby('Grade')['Height'].transform(
                         lambda x: x.fillna(x.mean()))
df=df.round({'Height':2})
df.head(5)

	Grade	Name	Gender	Height	Weight	Transfer
0	Freshman	Gaopeng Yang	Female	158.9	46	N
1	Freshman	Changqiang You	Male	166.5	70	N
2	Senior	Mei Sun	Male	188.9	89	N
3	Sophomore	Xiaojuan Sun	Female	163.08	41	N
4	Sophomore	Gaojuan You	Male	174	74	N

使用上述操作，对不同年级学生的缺失值用相应年级非缺失值均值进行填充。

练一练

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

实现方法：想了好久脑壳疼，刚开始还想到了之前的滑窗和今天学到的结合，复习了一下滑窗发现好像没用。后面想到可以利用两次fillna，一次向前，一次向后，然后取均值的方法得到结果，试验了下果然可行。
测试的例子如下：

s = pd.Series([1,np.nan, 3, np.nan,np.nan, 4],
                  list('aabcdd'))
s

	0
a	1
a	nan
b	3
c	nan
d	nan
d	4

实现方法：

s1 = s.fillna(method='ffill',limit=1)
s2 = s.fillna(method='backfill',limit=1)
s=(s1+s2)/2
s

	0
a	1
a	2
b	3
c	nan
d	nan
d	4

2. 插值函数

在关于 interpolate 函数的 文档 描述中，列举了许多插值法，包括了大量 Scipy 中的方法。由于很多插值方法涉及到比较复杂的数学知识，因此这里只讨论比较常用且简单的三类情况，即线性插值、最近邻插值和索引插值。

对于 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
# 输出为array([nan, nan,  1., nan, nan, nan,  2., nan, nan])

例如，在默认线性插值法下分别进行 backward 和双向限制插值，同时限制最大连续条数为1：

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

第二种常见的插值是最近邻插补，即缺失值的元素和离它最近的非缺失值元素一样：

s.interpolate('nearest').values
# 输出为array([nan, nan,  1.,  1.,  1.,  2.,  2., nan, nan])

这种只在两端非缺失的位置插，距离两端位置一样情况按前一个复制插。

最后来介绍索引插值，即根据索引大小进行线性插值。例如，构造不等间距的索引进行演示：

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

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

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

In [36]: s.interpolate(method='index') # 和索引有关的线性插值，计算相应索引大小对应的值
Out[36]: 
0      0.0
1      1.0
10    10.0
dtype: float64

同时，这种方法对于时间戳索引也是可以使用的，有关时间序列的其他话题会在第十章进行讨论，这里举一个简单的例子：

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

In [38]: s
Out[38]: 
2020-01-01     0.0
2020-01-02     NaN
2020-01-11    10.0
dtype: float64

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

In [40]: 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. 缺失记号及其缺陷

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

In [41]: None == None
Out[41]: True

In [42]: None == False
Out[42]: False

In [43]: None == []
Out[43]: False

In [44]: None == ''
Out[44]: False

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

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

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

In [47]: 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])

print(s1 == 1)
print(s1 == s3)
print(s1.equals(s3))

前两个都输出如下
0 True
1 False
dtype: bool
第三个输出为True

在时间序列的对象中， pandas 利用 pd.NaT 来指代缺失值，它的作用和 np.nan 是一致的（时间序列的对象和构造将在第十章讨论）：

In [54]: pd.to_timedelta(['30s', np.nan]) # Timedelta中的NaT
Out[54]: TimedeltaIndex(['0 days 00:00:30', NaT], dtype='timedelta64[ns]', freq=None)

In [55]: pd.to_datetime(['20200101', np.nan]) # Datetime中的NaT
Out[55]: DatetimeIndex(['2020-01-01', 'NaT'], dtype='datetime64[ns]', freq=None)

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

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

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

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

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

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

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

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

2. Nullable类型的性质

从字面意义上看 Nullable 就是可空的，言下之意就是序列类型不受缺失值的影响。例如，在上述三个 Nullable 类型中存储缺失值，都会转为 pandas 内置的 pd.NA ：

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

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

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

在 Int 的序列中，返回的结果会尽可能地成为 Nullable 的类型,操作的时候缺失值保持不变。

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

第一点是带有缺失的布尔列表无法进行索引器中的选择，而 boolean 会把缺失值看作 False ：

s = pd.Series(['a', 'b'])
s_boolean = pd.Series([True, np.nan],dtype='boolean')
 #s_boolean 不指定类型下面的索引会报错
s[s_boolean]

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

In [70]: s_boolean & True
Out[70]: 
0    True
1    <NA>
dtype: boolean

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

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

关于 string 类型的具体性质将在下一章文本数据中进行讨论。

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

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

	0
School	string
Grade	string
Name	string
Gender	string
Height	float64
Weight	Int64
Transfer	string
Test_Number	Int64
Test_Date	string
Time_Record	string

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

当调用函数 sum, prob 使用加法和乘法的时候，缺失数据等价于被分别视作0和1，即不改变原来的计算结果。
当使用累计函数时，会自动跳过缺失值所处的位置。
下面是奇奇怪怪的比较结果：

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

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

In [82]: np.nan > 0
Out[82]: False

In [83]: pd.NA > 0
Out[83]: <NA>

In [84]: np.nan + 1
Out[84]: nan

In [85]: np.log(np.nan)
Out[85]: nan

In [86]: np.add(np.nan, 1)
Out[86]: nan

In [87]: np.nan ** 0
Out[87]: 1.0

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

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

In [90]: 1 ** pd.NA
Out[90]: 1

对于一些函数而言，缺失可以作为一个类别处理，例如在 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	value
a	2
b	5
nan	8

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 为二分类标签。

事实上，有时缺失值出现或者不出现本身就是一种特征，并且在一些场合下可能与标签的正负是相关的。关于缺失出现与否和标签的正负性，在统计学中可以利用卡方检验来断言它们是否存在相关性。按照特征缺失的正例、特征缺失的负例、特征不缺失的正例、特征不缺失的负例，可以分为四种情况，设它们分别对应的样例数为 n11,n10,n01,n00 。假若它们是不相关的，那么特征缺失中正例的理论值，就应该接近于特征缺失总数 × 总体正例的比例，即：
$$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}$$
其他的三种情况同理。现将实际值和理论值分别记作$E_{ij},F_{ij}$，那么希望下面的统计量越小越好，即代表实际值接近不相关情况的理论值：
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 的卡方分布，即 $S\stackrel{\cdot }{\sim }{\chi }^2(1)$。因此，可通过计算 $P({\chi }^2(1)>S)$ 的概率来进行相关性的判别，一般认为当此概率小于 0.05 时缺失情况与标签正负存在相关关系，即不相关条件下的理论值与实际值相差较大。

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

答案：

cat_1 = df.X_1.fillna('NaN').mask(df.X_1.notna()).fillna("NotNaN")
cat_2 = df.X_2.fillna('NaN').where(df.X_2.isna()).fillna("NotNaN")
df_1 = pd.crosstab(cat_1, df.y, margins=True)
df_2 = pd.crosstab(cat_2, df.y, margins=True)

首先将x1,x2两列的数据根据是否缺失，将元素都换对应的NaN和NotNa,这里用了两种方法。
然后使用了crosstab()，用于计算分组的频率，它是一种特殊的pivot_table()，pivot_table()也可以实现crosstab()的功能。显示y和x1，x2的情况。

def compute_S(my_df):
        S = []
        for i in range(2):
            for j in range(2):
                E = my_df.iat[i, j]
                F = my_df.iat[i, 2]*my_df.iat[2, j]/my_df.iat[2,2]
                S.append((E-F)**2/F)
        return sum(S)
        
res1 = compute_S(df_1)
res2 = compute_S(df_2)

定义函数，以及计算。

from scipy.stats import chi2
chi2.sf(res1, 1)# X_1检验的p值 # 不能认为相关，剔除
#输出 0.9712760884395901
chi2.sf(res2, 1)# X_2检验的p值 # 认为相关，保留
#输出 7.459641265637543e-166

结果与 scipy.stats.chi2_contingency 在不使用 Yates 修正的情况下完全一致：

from scipy.stats import chi2_contingency
chi2_contingency(pd.crosstab(cat_1, df.y), correction=False)[1]
#输出 0.9712760884395901

chi2_contingency(pd.crosstab(cat_2, df.y), correction=False)[1]
#输出 7.459641265637543e-166

Ex2：用回归模型解决分类问题

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

上面有色点的特征数据提供如下：
已知待预测的样本点为 X1=0.8,X2=−0.2 ，那么预测类别可以如下写出：

1. 对于回归问题而言，需要得到的是一个具体的数值，因此预测值由最近的 n 个样本对应的平均值获得。请把上面的这个分类问题转化为回归问题，仅使用 KNeighborsRegressor 来完成上述的 KNeighborsClassifier 功能。
   思路：
   首先获得one-hot型特征向量

from sklearn.neighbors import KNeighborsRegressor
df = pd.read_excel('data/color.xlsx')
df_dummies = pd.get_dummies(df.Color)
df_dummies.head()

	Blue	Green	Yellow
0	1	0	0
1	1	0	0
2	1	0	0
3	1	0	0
4	1	0	0

下面构建回归模型，将x1,x2位置作为输入，颜色特征（蓝绿黄三列）作为输出。然后每个颜色预测一下输入[0.8, -0.2]位置的点是该颜色的概率是多少，将预测概率最大的作为该位置最终预测颜色。

stack_list = []
for col in df_dummies.columns:
        clf = KNeighborsRegressor(n_neighbors=6)
        clf.fit(df.iloc[:,:2], df_dummies[col])
        res = clf.predict([[0.8, -0.2]]).reshape(-1,1)
        stack_list.append(res)
stack_list
# 输出为[array([[0.16666667]]), array([[0.33333333]]), array([[0.5]])]

预测l成蓝绿黄三个颜色的概率分别是16.7%，33.3%和50%。

取最大的概率作为最终预测结果，该位置最终预测为黄色。

code_res = pd.Series(np.hstack(stack_list).argmax(1))
df_dummies.columns[code_res[0]]
# 输出为'Yellow'

2. 请根据第1问中的方法，对 audit 数据集中的 Employment 变量进行缺失值插补。
   
   思路：

from sklearn.neighbors import KNeighborsRegressor

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

res_df = df.copy()

#将婚姻状况、性别变成one-hot向量，和年龄、收入、时间、雇用拼接在一起
# 年龄、收入、时间这三个属性还做了标准化处理
df = pd.concat([pd.get_dummies(df[['Marital', 'Gender']]),
        df[['Age','Income','Hours']].apply(
            lambda x:(x-x.min())/(x.max()-x.min())), df.Employment],1)
    

X_train = df[df.Employment.notna()]

X_test = df[df.Employment.isna()]

df_dummies = pd.get_dummies(X_train.Employment)

stack_list = []

for col in df_dummies.columns:
        clf = KNeighborsRegressor(n_neighbors=6)
        clf.fit(X_train.iloc[:,:-1], df_dummies[col])
        res = clf.predict(X_test.iloc[:,:-1]).reshape(-1,1)
        stack_list.append(res)
    
code_res = pd.Series(np.hstack(stack_list).argmax(1))

cat_res = code_res.replace(dict(zip(list(
               range(df_dummies.shape[0])),df_dummies.columns)))
    

res_df.loc[res_df.Employment.isna(), 'Employment'] = cat_res.values

res_df.isna().sum()


#输出为
# ID            0
# Age           0
# Employment    0
# Marital       0
# Income        0
# Gender        0
# Hours         0
# dtype: int64

这里按照提供的答案这样写会报错，可以改成我上面那样。

 X_train = df.query('Employment.notna()')

X_test = df.query('Employment.isna()')