数据分析特征工程之缺失值填充

平均值补值和fillna的bfill和ffill补值。

对于大方差数据我们通常采用bfill和ffill；对于小方差数据我们通常用平均值补值。

In [1]:

#先创建一个数据集：
import numpy as np
import pandas as pd
ser1=pd.Series(np.random.randint(3,23,20))
ser1[[2,6,11,17]]=np.nan
ser1

Out[1]:

0     19.0
1     16.0
2      NaN
3     22.0
4     18.0
5     20.0
6      NaN
7      4.0
8      7.0
9     13.0
10    19.0
11     NaN
12    20.0
13     4.0
14    15.0
15    12.0
16     7.0
17     NaN
18     3.0
19    15.0
dtype: float64

fill采用缺失值前面的值填充
In [2]:

#fill采用缺失值前面的值填充
ser1.fillna(method='ffill')

Out[2]:

0     19.0
1     16.0
2     16.0
3     22.0
4     18.0
5     20.0
6     20.0
7      4.0
8      7.0
9     13.0
10    19.0
11    19.0
12    20.0
13     4.0
14    15.0
15    12.0
16     7.0
17     7.0
18     3.0
19    15.0
dtype: float64

bfill采用缺失值后面的值填充
In [3]:

#bfill采用缺失值后面的值填充
ser1.fillna(method='bfill')

Out[3]:

0     19.0
1     16.0
2     22.0
3     22.0
4     18.0
5     20.0
6      4.0
7      4.0
8      7.0
9     13.0
10    19.0
11    20.0
12    20.0
13     4.0
14    15.0
15    12.0
16     7.0
17     3.0
18     3.0
19    15.0
dtype: float64

用平均值进行补值
In [4]:

#用平均值进行补值
data_inf=ser1.describe()
ser1.fillna(data_inf['mean'])

Out[4]:

0     19.000
1     16.000
2     13.375
3     22.000
4     18.000
5     20.000
6     13.375
7      4.000
8      7.000
9     13.000
10    19.000
11    13.375
12    20.000
13     4.000
14    15.000
15    12.000
16     7.000
17    13.375
18     3.000
19    15.000
dtype: float64

通过拉格朗日插值多项式实现，（即通过已知点缺点多项式，然后用此多项式去预测未知点）python已经有可用的内置函数。 lagrange(x, w)： 给定两个一维数组“x”和“w”，返回通过这些点“(x, w)”的拉格朗日插值多项式。

警告:这个方法在数值上是不稳定的。不要期望能够使用超过20点(通常10点以内)，即使他们是最佳选择。也就是要求我们在空值或无效值附近进行Lagrange计算。

In [5]:

from scipy.interpolate import lagrange
ser1=pd.Series(np.random.randint(3,23,30))
ser1[[6,18]]=np.nan
ser1

Out[5]:

0      9.0
1     22.0
2      6.0
3     14.0
4     16.0
5     22.0
6      NaN
7     20.0
8     10.0
9     14.0
10    15.0
11    21.0
12    16.0
13    10.0
14     7.0
15    18.0
16     9.0
17    12.0
18     NaN
19     9.0
20    18.0
21    22.0
22    18.0
23    17.0
24    18.0
25     5.0
26    12.0
27     3.0
28    16.0
29     5.0
dtype: float64

In [6]:

ser1_n1=ser1[0:13].dropna(0)#在空值位‘6’前后各选6个位置点进行多项式确定

p1=lagrange(list(ser1_n1.index),ser1_n1.values)#生成多项式函数

p1(6)#预测空值点‘6’对应的值。

Out[6]:

27.76948051917691

In [7]:

#同理对空值位‘18’进行值预测
ser1_n1=ser1[12:25].dropna(0)

p1=lagrange(list(ser1_n1.index),ser1_n1.values)

p1(18)

Out[7]:

11.587867021560669

In [20]:

#然后用fillna把空值补充
ser1_after_dealing=ser1.fillna({6:27.76948051917691,18:11.587867021560669})
ser1_after_dealing

Out[20]:

0      9.000000
1     22.000000
2      6.000000
3     14.000000
4     16.000000
5     22.000000
6     27.769481
7     20.000000
8     10.000000
9     14.000000
10    15.000000
11    21.000000
12    16.000000
13    10.000000
14     7.000000
15    18.000000
16     9.000000
17    12.000000
18    11.587867
19     9.000000
20    18.000000
21    22.000000
22    18.000000
23    17.000000
24    18.000000
25     5.000000
26    12.000000
27     3.000000
28    16.000000
29     5.000000
dtype: float64

In [21]:

#补值后以一维数组形式返回
ser1_after_dealing.apply(lambda x:'%d'%x).values.astype(np.int32)

Out[21]:

array([ 9, 22,  6, 14, 16, 22, 27, 20, 10, 14, 15, 21, 16, 10,  7, 18,  9,
       12, 11,  9, 18, 22, 18, 17, 18,  5, 12,  3, 16,  5])

插值法填补缺失值

DataFrame.interpolate（method ='linear'，axis = 0，limit = None，inplace = False，limit_direction ='forward'，limit_area = None，downcast = None，** kwargs ）根据不同的方法插值。

method：默认'linear'

• 'linear'：忽略索引并将值视为等间距。这是MultiIndexes支持的唯一方法。
• 'time'：适用于每日和更高分辨率的数据，以插入给定的间隔长度。
• 'index'，'values'：使用索引的实际数值。
• 'pad'：使用现有值填写NaN。
• 'nearest','zero','slinear','quadratic','cubic','spline','barycentric','polynomial'：传递给 scipy.interpolate.interp1d。'polynomial'和'spline'都要求你也指定一个order（int），例如。这些使用索引的数值。df.interpolate(method='polynomial', order=4)

填充NaN在Series通过线性插值。

In [10]:

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

Out[10]:

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

In [11]:

s.interpolate(method='linear')

Out[11]:

0      1.00
1     25.75
2     50.50
3     75.25
4    100.00
dtype: float64

In [12]:

s.interpolate(method='slinear')

Out[12]:

0      1.00
1     25.75
2     50.50
3     75.25
4    100.00
dtype: float64

填写NaN由填充一个系列，而是填充至多两个连续NaN在同一时间。

In [13]:

s = pd.Series([np.nan, "single_one", np.nan,"fill_two_more", np.nan, np.nan, np.nan,4.71, np.nan])
s

Out[13]:

0              NaN
1       single_one
2              NaN
3    fill_two_more
4              NaN
5              NaN
6              NaN
7             4.71
8              NaN
dtype: object

In [14]:

s.interpolate(method='pad', limit=2)

Out[14]:

0              NaN
1       single_one
2       single_one
3    fill_two_more
4    fill_two_more
5    fill_two_more
6              NaN
7             4.71
8             4.71
dtype: object

NaN通过多项式插值或样条函数填充系列：“多项式”和“样条”方法都要求您还指定order（int）。

In [15]:

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

Out[15]:

0    0.0
1    2.0
2    NaN
3    8.0
dtype: float64

In [16]:

s.interpolate(method='polynomial', order=2)

Out[16]:

0    0.000000
1    2.000000
2    4.666667
3    8.000000
dtype: float64

使用线性插值沿每列填充DataFrame（即，向下）。

请注意列'a'中的最后一个条目是如何以不同方式进行插值的，因为在它之后没有用于插值的条目。注意列'b'中的第一个条目是如何保留的NaN，因为它没有用于插值的条目。

In [17]:

df = pd.DataFrame([(0.0,  np.nan, -1.0, 1.0),(np.nan, 2.0, np.nan, np.nan),(2.0, 3.0, np.nan, 9.0),(np.nan, 4.0, -4.0, 16.0)],columns=list('abcd'))
df

Out[17]:

In [18]:

df.interpolate(method='linear', limit_direction='forward', axis=0)

Out[18]:

In [19]:

df['d'].interpolate(method='polynomial', order=2)

Out[19]:

0     1.0
1     4.0
2     9.0
3    16.0
Name: d, dtype: float64