1. 返回数组类型

  1. import pandas as pd
  2. import numpy as np
  4. a = np.nan
  5. print(type(a))
  6. print('当数组中有nan时，无论其他数据是什么类型，使用dtype返回的都是float64')
  7. val = np.array(([2, 1, 3, 4]))
  8. print(val.dtype)
  9. val = np.array(([2.1, 1, 3, 4]))
  10. print(val.dtype)
  11. val = np.array(([2, np.nan, 3.1, 4]))
  12. print(val.dtype)
  13. val = np.array(([2.2, np.nan, 3.1, 4.1]))
  14. print(val.dtype)
  15. val = np.array(([2, np.nan, 3, 4]))
  16. print(val.dtype)
  18. <class 'float'>
  19. 当数组中有nan时，无论其他数据是什么类型，使用dtype返回的都是float64
  20. int32
  21. float64
  22. float64
  23. float64
  24. float64

2. 返回数组维度和各维度大小

  1. print('ndim返回数组的维度')
  2. print(val.ndim)
  3. print('shape返回表示各维度大小的元组')
  4. print(val.shape)
  6. ndim返回数组的维度
  7. 1
  8. shape返回表示各维度大小的元组
  9. (4,)

3. 类型转换

int32 —> float64 完全ok
float64 —> int32 会将小数部分截断
string_ —> float64 如果字符串数组表示的全是数字，也可以用astype转化为数值类型

  1. print('astype改变数组的元素类型')
  2. arr1 = np.array(([1., 2., 3.]))
  3. arr2 = arr1.astype('int32')
  4. print(arr1.dtype)
  5. print(arr2.dtype)
  7. float64
  8. int32

4. 与NaN数据做计算

与NaN数据做任何操作，结果都是NaN

  1. print(1+np.nan, 2*np.nan)
  2. print(val.sum(), val.min(), val.max())
  4. nan nan
  5. nan nan nan
  1. # None
  2. val2 = np.array([1, None, 3, 4])
  3. print(val2)
  4. # print(val2.sum())  # None不能用与计算，直接使用这个会报错
  6. [1 None 3 4]

5. 发现缺失值

  1. print('发现缺失值')
  2. data = pd.Series([1, np.nan, 'hello', None])
  3. print(data.isnull())
  4. print('不是空值的有哪些')
  5. print(data[data.notnull()])
  7. 发现缺失值
  8. 0    False
  9. 1     True
  10. 2    False
  11. 3     True
  12. dtype: bool
  13. 不是空值的有哪些
  14. 0        1
  15. 2    hello
  16. dtype: object

6. 删除缺失值

  1. data2 = data.dropna()
  2. print(data)
  3. print(data2)
  5. 0        1
  6. 1      NaN
  7. 2    hello
  8. 3     None
  9. dtype: object
  10. 0        1
  11. 2    hello
  12. dtype: object

7. 剔除任何包含缺失值的数据

  1. df = pd.DataFrame([[1, np.nan, 2],
  2.                    [2, 3, 5],
  3.                    [np.nan,4, 6]])
  4. print(df)
  5. print("dropna()默认剔除任何包含缺失值的整行数据")
  6. print(df.dropna())
  8. dropna()默认剔除任何包含缺失值的整行数据
  9.      0    1  2
  10. 0  1.0  NaN  2
  11. 1  2.0  3.0  5
  12. 2  NaN  4.0  6
  13.      0    1  2
  14. 1  2.0  3.0  5
  1. print('剔除任何包含缺失值的整列数据')
  2. print(df.dropna(axis='columns'))
  4. 剔除任何包含缺失值的整列数据
  5.    2
  6. 0  2
  7. 1  5
  8. 2  6

8. 加一列数据

  1. print('加一列')
  2. df[3] = np.nan
  3. print(df)
  5. 加一列
  6.      0    1  2   3
  7. 0  1.0  NaN  2 NaN
  8. 1  2.0  3.0  5 NaN
  9. 2  NaN  4.0  6 NaN

9. 剔除全是NaN的列

  1. print(df.dropna(axis='columns', how='all'))
  3.      0    1  2
  4. 0  1.0  NaN  2
  5. 1  2.0  3.0  5
  6. 2  NaN  4.0  6

10. 填充缺失值

1）fillna()函数

  1. fillna(value=None, method=None, axis=None, inplace=False, 
  2.        limit=None, downcast=None, **kwargs)
  • value：用于填充的空值的值。
  • method： {‘backfill’, ‘bfill’, ‘pad’, ‘ffill’, None}, default None。定义了填充空值的方法， pad / ffill表示用前面行/列的值，填充当前行/列的空值， backfill / bfill表示用后面行/列的值，填充当前行/列的空值。
  • axis：轴。0或’index’，表示按行删除；1或’columns’，表示按列删除。
  • inplace：是否原地替换。布尔值，默认为False。如果为True，则在原DataFrame上进行操作，返回值为None。
  • limit：int， default None。如果method被指定，对于连续的空值，这段连续区域，最多填充前 limit 个空值（如果存在多段连续区域，每段最多填充前 limit 个空值）。如果method未被指定， 在该axis下，最多填充前 limit 个空值（不论空值连续区间是否间断）
  • downcast：dict, default is None，字典中的项为，为类型向下转换规则。或者为字符串“infer”，此时会在合适的等价类型之间进行向下转换，比如float64 to int64 if possible。

    2）填充特定字符

    ```python data = pd.Series([1, np.nan, 2, None, None, 3], index=list(‘abcdef’)) print(data) print(data.fillna(‘Missing’))

a 1.0 b NaN c 2.0 d NaN e NaN f 3.0 dtype: float64 a 1 b Missing c 2 d Missing e Missing f 3 dtype: object

  1. <a name="djZfe"></a>
  2. ## 3）用缺失值前面的有效值从前往后填充
  3. ```python
  4. data = pd.Series([1, np.nan, 2, None, None, 3], index=list('abcdef'))
  5. print(data)
  6. print('用缺失值前面的有效值从前往后填充')
  7. print(data.fillna(method='ffill'))
  8. # 下列用法结果相同。
  9. print(data.fillna(method='pad'))
  11. a    1.0
  12. b    NaN
  13. c    2.0
  14. d    NaN
  15. e    NaN
  16. f    3.0
  17. 用缺失值前面的有效值从前往后填充
  18. a    1.0
  19. b    1.0
  20. c    2.0
  21. d    2.0
  22. e    2.0
  23. f    3.0
  24. dtype: float64

4）用缺失值后面的有效值从后往前填充

  1. data = pd.Series([1, np.nan, 2, None, None, 3], index=list('abcdef'))
  2. print(data)
  3. print('用缺失值前面的有效值从前往后填充')
  4. print(data.fillna(method='backfill'))
  5. # 下列用法结果相同。
  6. print(data.fillna(method='bfill'))
  8. a    1.0
  9. b    NaN
  10. c    2.0
  11. d    NaN
  12. e    NaN
  13. f    3.0
  14. 用缺失值前面的有效值从前往后填充
  15. a    1.0
  16. b    2.0
  17. c    2.0
  18. d    3.0
  19. e    3.0
  20. f    3.0
  21. dtype: float64


5）用缺失值前后有效值构建等差数列填充

用到了interpolate函数

  1. DataFrame.interpolate(method=‘linear’, axis=0, limit=None, inplace=False, 
  2.           limit_direction=None, limit_area=None, downcast=None, **kwargs)

method ： str，默认为‘linear’，使用插值技术。之一：‘linear’：忽略索引，并将值等距地对待。这是MultiIndexes支持的唯一方法。‘time’: 处理每日和更高分辨率的数据，以内插给定的时间间隔长度。‘index’, ‘values’: 使用索引的实际数值。‘pad’：使用现有值填写NaN。‘nearest’, ‘zero’, ‘slinear’, ‘quadratic’, ‘cubic’, ‘spline’, ‘barycentric’, ‘polynomial’: 传递给 scipy.interpolate.interp1d。这些方法使用索引的数值。‘polynomial’ 和 ‘spline’ 都要求您还指定一个顺序（int），例如 :df.interpolate(method=’polynomial’, order=5)
‘krogh’, ‘piecewise_polynomial’, ‘spline’，’pchip’，’akima’：环绕类似名称的SciPy插值方法。请参阅注释。

axis ： {0或’index’，1或’columns’，None}，默认为None，沿轴进行interpolate。

limit ： 整数，可选，要填充的连续NaN的最大数量。必须大于0。

inplace ： bool，默认为False尽可能更新数据。

limit_direction ： {‘forward’，’backward’，’both’}，默认为’forward’，如果指定了限制，则将沿该方向填充连续的NaN。

limit_area ： {None, ‘inside’, ‘outside’}, 默认为None，如果指定了限制，则连续的NaN将填充此限制。None：无填充限制。‘inside’：仅填充有效值（interpolate）包围的NaN。‘outside’: 仅在有效值之外（extrapolate）填充NaN。0.23.0版中的新功能。

downcast ： 可选， ‘infer’ 或None，默认为None，如果可能，请向下转换dtype。

**kwargs，关键字参数传递给插值函数。

  1. data = pd.Series([1, np.nan, 2, None, None, 3], index=list('abcdef'))
  2. data1 = pd.DataFrame({"score": data})
  3. print(data1)
  4. print('用缺失值前后的平均值填充')
  5. print(data.fillna(data1['score'].interpolate(limit_direction='both')))
  7.    score
  8. a    1.0
  9. b    NaN
  10. c    2.0
  11. d    NaN
  12. e    NaN
  13. f    3.0
  14. 用缺失值前后的平均值填充
  15. a    1.000000
  16. b    1.500000
  17. c    2.000000
  18. d    2.333333
  19. e    2.666667
  20. f    3.000000
  22. # 也可以直接使用interpolate()函数
  23. data = pd.Series([1, np.nan, 2, None, None, 3], index=list('abcdef'))
  24. print(data)
  25. print(data.interpolate())
  28. a    1.0
  29. b    NaN
  30. c    2.0
  31. d    NaN
  32. e    NaN
  33. f    3.0
  34. dtype: float64
  35. a    1.000000
  36. b    1.500000
  37. c    2.000000
  38. d    2.333333
  39. e    2.666667
  40. f    3.000000