pandas中的缺失数据表示

缺失数据在pandas中呈现的方式有些不完美，但对于大多数用户可以保证功能正常。对于数值数据，pandas使用浮点值NaN（Not a Number）表示缺失数据。我们称其为哨兵值，可以方便的检测出来

  1. In [3]: string_data = pd.Series(['aardvark', 'artichoke', np.nan, 'avocado'])
  3. In [4]: string_data
  4. Out[4]:
  5. 0     aardvark
  6. 1    artichoke
  7. 2          NaN
  8. 3      avocado
  9. dtype: object
  11. In [5]: string_data.isnull()
  12. Out[5]:
  13. 0    False
  14. 1    False
  15. 2     True
  16. 3    False
  17. dtype: bool

在pandas中，我们采用了R语言中的惯用法，即将缺失值表示为NA，它表示不可用not available。在统计应用中，NA数据可能是不存在的数据或者虽然存在，但是没有观察到（例如，数据采集中发生了问题）。当进行数据清洗以进行分析时，最好直接对缺失数据进行分析，以判断数据采集的问题或缺失数据可能导致的偏差
Python内置的 None 值在对象数组中也可以作为NA：

  1. In [6]: string_data[0] = None
  3. In [7]: string_data.isnull()
  4. Out[7]:
  5. 0     True
  6. 1    False
  7. 2     True
  8. 3    False
  9. dtype: bool

pandas项目中还在不断优化内部细节以更好处理缺失数据，像用户API功能，例如pandas.isnull() ，去除了许多恼人的细节。下表列出了一些关于缺失数据处理的函数
image.png

滤除缺失数据

过滤掉缺失数据的办法有很多种。你可以通过pandas.isnull() 或布尔索引的手工方法，但dropna() 可能会更实用一些。对于一个Series，dropna 返回一个仅含非空数据和索引值的Series

  1. In [10]: from numpy import nan as NA
  3. In [11]: data = pd.Series([1, NA, 3.5, NA, 7])
  5. In [12]: data.dropna()
  6. Out[12]:
  7. 0    1.0
  8. 2    3.5
  9. 4    7.0
  10. dtype: float64

这等价于

  1. In [13]: data[data.notnull()]
  2. Out[13]:
  3. 0    1.0
  4. 2    3.5
  5. 4    7.0
  6. dtype: float64

而对于DataFrame对象，事情就有点复杂了。你可能希望丢弃全NA或含有NA的行或列。dropna() 默认丢弃任何含有缺失值的行

  1. In [15]: data = pd.DataFrame([[1., 6.5, 3.], [1., NA, NA],
  2.     ...:                      [NA, NA, NA], [NA, 6.5, 3.]])
  4. In [16]: data
  5. Out[16]:
  6.      0    1    2
  7. 0  1.0  6.5  3.0
  8. 1  1.0  NaN  NaN
  9. 2  NaN  NaN  NaN
  10. 3  NaN  6.5  3.0
  12. In [17]: cleaned = data.dropna()
  14. In [18]: data
  15. Out[18]:
  16.      0    1    2
  17. 0  1.0  6.5  3.0
  18. 1  1.0  NaN  NaN
  19. 2  NaN  NaN  NaN
  20. 3  NaN  6.5  3.0
  22. In [19]: cleaned
  23. Out[19]:
  24.      0    1    2
  25. 0  1.0  6.5  3.0

传入 how='all' 将只丢弃全为NA的那些行

  1. In [20]: data.dropna(how='all')
  2. Out[20]:
  3.      0    1    2
  4. 0  1.0  6.5  3.0
  5. 1  1.0  NaN  NaN
  6. 3  NaN  6.5  3.0

用这种方式丢弃列，只需传入axis=1 即可

  1. In [21]: data[4] = NA
  3. In [22]: data
  4. Out[22]:
  5.      0    1    2   4
  6. 0  1.0  6.5  3.0 NaN
  7. 1  1.0  NaN  NaN NaN
  8. 2  NaN  NaN  NaN NaN
  9. 3  NaN  6.5  3.0 NaN
  11. In [24]: data.dropna(axis=1, how='all')
  12. Out[24]:
  13.      0    1    2
  14. 0  1.0  6.5  3.0
  15. 1  1.0  NaN  NaN
  16. 2  NaN  NaN  NaN
  17. 3  NaN  6.5  3.0

另一个滤除DataFrame行的问题涉及时间序列数据。假设你只想留下一部分观测数据，可以用 thresh 参数实现此目的

  1. In [25]: df = pd.DataFrame(np.random.randn(7, 3))
  3. In [26]: df.iloc[:4, 1] = NA
  5. In [27]: df.iloc[:2, 2] = NA
  7. In [28]: df
  8. Out[28]:
  9.           0         1         2
  10. 0  1.279066       NaN       NaN
  11. 1 -0.037111       NaN       NaN
  12. 2 -1.102988       NaN  1.282095
  13. 3  0.678465       NaN -0.244893
  14. 4  0.936922 -0.433543  0.501408
  15. 5  1.808474 -0.140179 -0.923943
  16. 6 -0.095324 -0.555709 -0.346352
  18. In [29]: df.dropna()
  19. Out[29]:
  20.           0         1         2
  21. 4  0.936922 -0.433543  0.501408
  22. 5  1.808474 -0.140179 -0.923943
  23. 6 -0.095324 -0.555709 -0.346352
  25. In [30]: df.dropna(thresh=2)
  26. Out[30]:
  27.           0         1         2
  28. 2 -1.102988       NaN  1.282095
  29. 3  0.678465       NaN -0.244893
  30. 4  0.936922 -0.433543  0.501408
  31. 5  1.808474 -0.140179 -0.923943
  32. 6 -0.095324 -0.555709 -0.346352

填充缺失数据

你可能不想滤除缺失数据（有可能会丢弃跟它有关的其他数据），而是希望通过其他方式填补那些“空洞”。 对于大多数情况而言，fillna() 方法是最主要的函数。通过一个常数调用fillna() 就会将缺失值替换为那个常数值

  1. In [31]: df.fillna(0)
  2. Out[31]:
  3.           0         1         2
  4. 0  1.279066  0.000000  0.000000
  5. 1 -0.037111  0.000000  0.000000
  6. 2 -1.102988  0.000000  1.282095
  7. 3  0.678465  0.000000 -0.244893
  8. 4  0.936922 -0.433543  0.501408
  9. 5  1.808474 -0.140179 -0.923943
  10. 6 -0.095324 -0.555709 -0.346352

若是通过一个字典调用 fillna() ，就可以实现对不同的列填充不同的值

  1. In [32]: df.fillna({1: 0.5, 2: 0})
  2. Out[32]:
  3.           0         1         2
  4. 0  1.279066  0.500000  0.000000
  5. 1 -0.037111  0.500000  0.000000
  6. 2 -1.102988  0.500000  1.282095
  7. 3  0.678465  0.500000 -0.244893
  8. 4  0.936922 -0.433543  0.501408
  9. 5  1.808474 -0.140179 -0.923943
  10. 6 -0.095324 -0.555709 -0.346352

fillna() 默认会返回新对象，但也可以对现有对象进行就地修改

  1. In [33]: df.fillna(0, inplace=True)
  3. In [34]: df
  4. Out[34]:
  5.           0         1         2
  6. 0  1.279066  0.000000  0.000000
  7. 1 -0.037111  0.000000  0.000000
  8. 2 -1.102988  0.000000  1.282095
  9. 3  0.678465  0.000000 -0.244893
  10. 4  0.936922 -0.433543  0.501408
  11. 5  1.808474 -0.140179 -0.923943
  12. 6 -0.095324 -0.555709 -0.346352

对reindexing有效的那些插值方法也可用于 fillna() 

  1. In [39]: df.fillna(method='ffill')
  2. Out[39]:
  3.           0         1         2
  4. 0 -0.892430  1.354326  1.183773
  5. 1 -0.358144  0.256747  0.309020
  6. 2  0.107312  0.256747 -0.017276
  7. 3 -0.643787  0.256747 -0.476113
  8. 4  0.709494  0.256747 -0.476113
  9. 5 -1.062814  0.256747 -0.476113
  11. In [40]: df.fillna(method='ffill', limit=2)
  12. Out[40]:
  13.           0         1         2
  14. 0 -0.892430  1.354326  1.183773
  15. 1 -0.358144  0.256747  0.309020
  16. 2  0.107312  0.256747 -0.017276
  17. 3 -0.643787  0.256747 -0.476113
  18. 4  0.709494       NaN -0.476113
  19. 5 -1.062814       NaN -0.476113

只要有些创新，你就可以利用fillna() 实现许多别的功能。比如说，你可以传入Series的平均值或中位数

  1. In [41]: data = pd.Series([1., NA, 3.5, NA, 7])
  3. In [42]: data.fillna(data.mean())
  4. Out[42]:
  5. 0    1.000000
  6. 1    3.833333
  7. 2    3.500000
  8. 3    3.833333
  9. 4    7.000000
  10. dtype: float64

下表列出了 fillna() 的参考
image.png