移除重复数据

DataFrame中出现重复行有多种原因。下面就是一个例子

  1. In [43]: data = pd.DataFrame({'k1': ['one', 'two'] * 3 + ['two'],
  2.     ...:                      'k2': [1,1,2,3,3,4,4]})
  4. In [44]: data
  5. Out[44]:
  6.     k1  k2
  7. 0  one   1
  8. 1  two   1
  9. 2  one   2
  10. 3  two   3
  11. 4  one   3
  12. 5  two   4
  13. 6  two   4

DataFrame的duplicated 方法返回一个布尔型Series，表示各行是否是重复行（前面出现过的行）

  1. In [45]: data.duplicated()
  2. Out[45]:
  3. 0    False
  4. 1    False
  5. 2    False
  6. 3    False
  7. 4    False
  8. 5    False
  9. 6     True
  10. dtype: bool

还有一个与此相关的drop_duplicates 方法，它会返回一个DataFrame，重复的数组会标为False

  1. In [46]: data.drop_duplicates()
  2. Out[46]:
  3.     k1  k2
  4. 0  one   1
  5. 1  two   1
  6. 2  one   2
  7. 3  two   3
  8. 4  one   3
  9. 5  two   4

这两个方法默认会判断全部列，你也可以指定部分列进行重复项判断。假设我们还有一列值，且只希望根据k1 列过滤重复项

  1. In [47]: data['v1'] = range(7)
  3. In [48]: data.drop_duplicates(['k1'])
  4. Out[48]:
  5.     k1  k2  v1
  6. 0  one   1   0
  7. 1  two   1   1

duplicated 和drop_duplicates 默认保留的是第一个出现的值组合。传入keep='last' 则保留最后一个

  1. In [49]: data.drop_duplicates(['k1', 'k2'], keep='last')
  2. Out[49]:
  3.     k1  k2  v1
  4. 0  one   1   0
  5. 1  two   1   1
  6. 2  one   2   2
  7. 3  two   3   3
  8. 4  one   3   4
  9. 6  two   4   6

利用函数或映射进行数据转换

对于许多数据集，你可能希望根据数组、Series或DataFrame列中的值来实现转换工作。我们来看看下面这组有关肉类的数据

  1. In [2]: data = pd.DataFrame({'food': ['bacon', 'pulled pork', 'bacon',
  2.    ...:                               'Pastrami', 'corned beef', 'Bacon',
  3.    ...:                               'pastrami', 'honey ham', 'nova lox'],
  4.    ...:                      'ounces': [4,3,12,6,7.5,8,3,5,6]})
  6. In [3]: data
  7. Out[3]:
  8.           food  ounces
  9. 0        bacon     4.0
  10. 1  pulled pork     3.0
  11. 2        bacon    12.0
  12. 3     Pastrami     6.0
  13. 4  corned beef     7.5
  14. 5        Bacon     8.0
  15. 6     pastrami     3.0
  16. 7    honey ham     5.0
  17. 8     nova lox     6.0

假设你想要添加一列表示该肉类食物来源的动物类型。我们先编写一个不同肉类到动物的映射

  1. In [4]: meat_to_animal = {
  2.    ...:     'bacon': 'pig',
  3.    ...:     'pulled pork': 'pig',
  4.    ...:     'pastrami': 'cow',
  5.    ...:     'corned beef': 'cow',
  6.    ...:     'honey ham': 'pig',
  7.    ...:     'nova lox': 'salmon'
  8. }

Series的 map 方法可以接受一个函数或含有映射关系的字典型对象，但是这里有一个小问题，即有些肉类的首字母大写了，而另一些则没有。因此，我们还需要使用Series的str.lower 方法，将各个值转换为小写

  1. In [5]: lowercased = data['food'].str.lower()
  3. In [6]: lowercased
  4. Out[6]:
  5. 0          bacon
  6. 1    pulled pork
  7. 2          bacon
  8. 3       pastrami
  9. 4    corned beef
  10. 5          bacon
  11. 6       pastrami
  12. 7      honey ham
  13. 8       nova lox
  14. Name: food, dtype: object
  16. In [7]: data['animal'] = lowercased.map(meat_to_animal)
  18. In [8]: data
  19. Out[8]:
  20.           food  ounces  animal
  21. 0        bacon     4.0     pig
  22. 1  pulled pork     3.0     pig
  23. 2        bacon    12.0     pig
  24. 3     Pastrami     6.0     cow
  25. 4  corned beef     7.5     cow
  26. 5        Bacon     8.0     pig
  27. 6     pastrami     3.0     cow
  28. 7    honey ham     5.0     pig
  29. 8     nova lox     6.0  salmon

我们也可以传入一个能够完成全部这些工作的函数

  1. In [9]: data['food'].map(lambda x: meat_to_animal[x.lower()])
  2. Out[9]:
  3. 0       pig
  4. 1       pig
  5. 2       pig
  6. 3       cow
  7. 4       cow
  8. 5       pig
  9. 6       cow
  10. 7       pig
  11. 8    salmon
  12. Name: food, dtype: object

使用map 是一种实现元素级转换以及其他数据清理工作的便捷方式

替换值

利用fillna 方法填充缺失数据可以看做值替换的一种特殊情况。前面已经看到，map 可用于修改对象的数据子集，而replace 则提供了一种实现该功能的更简单、更灵活的方式。我们来看看下面这个Series 

  1. In [13]: data = pd.Series([1., -999., 2., -999., -1000., 3.])
  3. In [14]: data
  4. Out[14]:
  5. 0       1.0
  6. 1    -999.0
  7. 2       2.0
  8. 3    -999.0
  9. 4   -1000.0
  10. 5       3.0
  11. dtype: float64

-999这个值可能是一个表示缺失数据的标记值。要将其替换为pandas能够理解的NA值，我们可以利用replace 来产生一个新的Series（除非传入inplace=True ）

  1. In [17]: data.replace(-999, np.nan)
  2. Out[17]:
  3. 0       1.0
  4. 1       NaN
  5. 2       2.0
  6. 3       NaN
  7. 4   -1000.0
  8. 5       3.0
  9. dtype: float64

如果你希望一次性替换多个值，可以传入一个由待替换值组成的列表以及一个替换值

  1. In [18]: data.replace([-999, -1000], np.nan)
  2. Out[18]:
  3. 0    1.0
  4. 1    NaN
  5. 2    2.0
  6. 3    NaN
  7. 4    NaN
  8. 5    3.0
  9. dtype: float64

要让每个值有不同的替换值，可以传递一个替换列表

  1. In [19]: data.replace([-999, -1000], [np.nan, 0])
  2. Out[19]:
  3. 0    1.0
  4. 1    NaN
  5. 2    2.0
  6. 3    NaN
  7. 4    0.0
  8. 5    3.0
  9. dtype: float64

传入的参数也可以是字典

  1. In [20]: data.replace({-999: np.nan, -1000: 0})
  2. Out[20]:
  3. 0    1.0
  4. 1    NaN
  5. 2    2.0
  6. 3    NaN
  7. 4    0.0
  8. 5    3.0
  9. dtype: float64

data.replace 方法与data.str.replace 不同， 后者做的是字符串的元素级替换。

重命名索引

跟Series中的值一样，轴标签也可以通过函数或映射进行转换，从而得到一个新的不同标签的对象。轴还可以被就地修改，而无需新建一个数据结构。接下来看看下面这个简单的例子

  1. In [22]: transform = lambda x: x[:4].upper()
  3. In [23]: data.index.map(transform)
  4. Out[23]: Index(['OHIO', 'COLO', 'NEW '], dtype='object')

你可以将其赋值给 index ，这样就可以对DataFrame进行就地修改

  1. In [24]: data.index = data.index.map(transform)
  3. In [25]: data
  4. Out[25]:
  5.       one  two  three  four
  6. OHIO    0    1      2     3
  7. COLO    4    5      6     7
  8. NEW     8    9     10    11

特别说明一下，rename 可以结合字典型对象实现对部分轴标签的更新

  1. In [27]: data.rename(index={'OHIO': 'INDIANA'},
  2.     ...:             columns={'three': 'peekaboo'})
  3. Out[27]:
  4.          one  two  peekaboo  four
  5. INDIANA    0    1         2     3
  6. COLO       4    5         6     7
  7. NEW        8    9        10    11

rename 可以实现复制DataFrame并对其索引和列标签进行赋值。如果希望就地修改某个数据集，传入inplace=True 即可

  1. In [28]: data.rename(index={'OHIO': 'INDIANA'}, inplace=True)
  3. In [29]: data
  4. Out[29]:
  5.          one  two  three  four
  6. INDIANA    0    1      2     3
  7. COLO       4    5      6     7
  8. NEW        8    9     10    11

离散化和面元划分

为了便于分析，连续数据常常被离散化或拆分为“面元”（bin）假设有一组人员数据，而你希望将它们划分为不同的年龄组

  1. In [30]: ages = [20, 22, 25, 27, 21, 23, 37, 31, 61, 45, 41 ,32]
  3. In [31]: bins = [18, 25, 35, 60, 100]
  5. In [32]: cats = pd.cut(ages, bins)
  7. In [33]: cats
  8. Out[33]:
  9. [(18, 25], (18, 25], (18, 25], (25, 35], (18, 25], ..., (25, 35], (60, 100], (35, 60], (35, 60], (25, 35]]
  10. Length: 12
  11. Categories (4, interval[int64]): [(18, 25] < (25, 35] < (35, 60] < (60, 100]]

pandas返回的是一个特殊的Categorical对象。结果展示了pandas.cut 划分的面元。你可以将其看做一组表示面元名称的字符串。 它的底层含有一个表示不同分类名称的类型数组， 以及一个codes 属性中的年龄数据的标签

  1. In [34]: cats.codes
  2. Out[34]: array([0, 0, 0, 1, 0, 0, 2, 1, 3, 2, 2, 1], dtype=int8)
  4. In [35]: cats.categories
  5. Out[35]:
  6. IntervalIndex([(18, 25], (25, 35], (35, 60], (60, 100]],
  7.               closed='right',
  8.               dtype='interval[int64]')
  10. In [36]: pd.value_counts(cats)
  11. Out[36]:
  12. (18, 25]     5
  13. (35, 60]     3
  14. (25, 35]     3
  15. (60, 100]    1
  16. dtype: int64

pd.value_counts(cats) 是 pandas.cut 结果的面元计数
跟“区间”的数学符号一样，圆括号表示开端，而方括号则表示闭端（包括）。哪边是闭端可以通right=False 进行修改

  1. In [37]: pd.cut(ages, [18, 26, 36, 61, 100], right=False)
  2. Out[37]:
  3. [[18, 26), [18, 26), [18, 26), [26, 36), [18, 26), ..., [26, 36), [61, 100), [36, 61), [36, 61), [26, 36)]
  4. Length: 12
  5. Categories (4, interval[int64]): [[18, 26) < [26, 36) < [36, 61) < [61, 100)]

你可以通过传递一个列表或数组到lables ，设置自己的面元名称

  1. In [38]: group_names = ['Youth', 'YoungAdult', 'MiddleAged', 'Seniro']
  3. In [39]: pd.cut(ages, bins, labels=group_names)
  4. Out[39]:
  5. [Youth, Youth, Youth, YoungAdult, Youth, ..., YoungAdult, Seniro, MiddleAged, MiddleAged, YoungAdult]
  6. Length: 12
  7. Categories (4, object): [Youth < YoungAdult < MiddleAged < Seniro]

如果向cut 传入的是面元的数量而不是确切的面元边界， 则它会根据数据的最小值和最大值计算等长面元。 下面这个例子中， 我们将一些均匀分布的数据分成四组

  1. In [40]: data = np.random.rand(20)
  3. In [41]: pd.cut(data, 4, precision=2)
  4. Out[41]:
  5. [(0.76, 0.99], (0.76, 0.99], (0.53, 0.76], (0.067, 0.3], (0.53, 0.76], ..., (0.3, 0.53], (0.067, 0.3], (0.76, 0.99], (0.76, 0.99], (0.76, 0.99]]
  6. Length: 20
  7. Categories (4, interval[float64]): [(0.067, 0.3] < (0.3, 0.53] < (0.53, 0.76] < (0.76, 0.99]]

选项 precision=2 限定小数点的位数
qcut 是一个非常类似于cut 的函数，它可以根据样本分位数对数据进行面元划分。根据数据的分布情况，cut 可能无法使各个面元中含有相同数量的数据点。 而qcut由于使用的是样本分位数， 因此可以得到大小基本相等的面元 

  1. In [42]: data = np.random.rand(1000)
  3. In [43]: cats = pd.qcut(data, 4)
  5. In [44]: cats
  6. Out[44]:
  7. [(0.496, 0.742], (0.003, 0.233], (0.233, 0.496], (0.233, 0.496], (0.003, 0.233], ..., (0.496, 0.742], (0.496, 0.742], (0.233, 0.496], (0.233, 0.496], (0.233, 0.496]]
  8. Length: 1000
  9. Categories (4, interval[float64]): [(0.003, 0.233] < (0.233, 0.496] < (0.496, 0.742] < (0.742, 0.999]]
  11. In [45]: pd.value_counts(cats)
  12. Out[45]:
  13. (0.742, 0.999]    250
  14. (0.496, 0.742]    250
  15. (0.233, 0.496]    250
  16. (0.003, 0.233]    250
  17. dtype: int64

与cut 类似，你也可以传递自定义的分位数（0到1之间的数值，包含端点）

  1. In [46]: pd.qcut(data, [0, 0.1, 0.5, 0.9, 1.])
  2. Out[46]:
  3. [(0.496, 0.9], (0.003, 0.0805], (0.0805, 0.496], (0.0805, 0.496], (0.0805, 0.496], ..., (0.496, 0.9], (0.496, 0.9], (0.0805, 0.496], (0.0805, 0.496], (0.0805, 0.496]]
  4. Length: 1000
  5. Categories (4, interval[float64]): [(0.003, 0.0805] < (0.0805, 0.496] < (0.496, 0.9] < (0.9, 0.999]]

检测和过滤异常值

过滤或变换异常值（outlier） 在很大程度上就是运用数组运算

  1. In [3]: data = pd.DataFrame(np.random.randn(1000, 4))
  3. In [4]: data.describe()
  4. Out[4]:
  5.                  0            1            2            3
  6. count  1000.000000  1000.000000  1000.000000  1000.000000
  7. mean      0.033135     0.032570    -0.095518    -0.017979
  8. std       0.986617     0.977234     1.024877     1.020564
  9. min      -2.914406    -2.664110    -3.506253    -3.940899
  10. 25%      -0.644735    -0.640543    -0.804517    -0.729601
  11. 50%       0.000484     0.061080    -0.124947     0.031138
  12. 75%       0.716358     0.665481     0.557026     0.625428
  13. max       3.112172     3.163979     3.495929     3.114999

假设你想要找出某列中绝对值大小超过3的值

  1. In [5]: col = data[2]
  3. In [6]: col[np.abs(col) > 3]
  4. Out[6]:
  5. 34     3.495929
  6. 98     3.315447
  7. 579   -3.007528
  8. 825   -3.186834
  9. 893   -3.506253
  10. Name: 2, dtype: float64

要选出全部含有“超过3或-3的值”的行，你可以在布尔型DataFrame中使用 any 方法

  1. In [7]: data[(np.abs(data) > 3).any(1)]
  2. Out[7]:
  3.             0         1         2         3
  4. 34  -1.784538  0.445514  3.495929  1.829886
  5. 43   3.112172  0.411621  1.468454 -1.652965
  6. 84   0.503056  3.038186 -1.127855  0.400907
  7. 98  -0.863137  1.232352  3.315447  2.187843
  8. 122  0.378206  3.163979 -2.019452  0.313086
  9. 253  1.968076 -1.584542  0.401178 -3.050984
  10. 403 -0.861885  3.022449 -0.494384  0.895285
  11. 414 -0.757196  0.155083 -1.797796 -3.022605
  12. 579  1.167474  0.243371 -3.007528 -1.252314
  13. 593  3.073241  1.438949 -0.865515 -1.809210
  14. 646 -0.950297  1.460927 -1.230396 -3.940899
  15. 773 -1.075818 -0.408849 -0.375849  3.114999
  16. 825  0.703684  0.260653 -3.186834  0.859110
  17. 893 -0.213223 -0.880939 -3.506253  0.726953
  18. 915  1.940736  0.464242 -0.003480 -3.296612

根据这些条件，就可以对值进行设置。下面的代码可以将值限制在区间-3到3以内

  1. In [9]: data[np.abs(data) > 3] = np.sign(data) * 3
  3. In [10]: data.describe()
  4. Out[10]:
  5.                  0            1            2            3
  6. count  1000.000000  1000.000000  1000.000000  1000.000000
  7. mean      0.032949     0.032346    -0.095629    -0.016783
  8. std       0.986050     0.976536     1.020114     1.015892
  9. min      -2.914406    -2.664110    -3.000000    -3.000000
  10. 25%      -0.644735    -0.640543    -0.804517    -0.729601
  11. 50%       0.000484     0.061080    -0.124947     0.031138
  12. 75%       0.716358     0.665481     0.557026     0.625428
  13. max       3.000000     3.000000     3.000000     3.000000

根据数据的值是正还是负，np.sign(data) 可以生成1和-1

  1. In [11]: np.sign(data).head()
  2. Out[11]:
  3.      0    1    2    3
  4. 0 -1.0  1.0 -1.0 -1.0
  5. 1 -1.0  1.0 -1.0  1.0
  6. 2 -1.0 -1.0 -1.0 -1.0
  7. 3 -1.0 -1.0  1.0  1.0
  8. 4 -1.0  1.0  1.0  1.0

排列和随机采样

利用numpy.random.permutation 函数可以轻松实现对Series或DataFrame的列的排列工作（permuting， 随机重排序）。通过需要排列的轴的长度调用permutation ，可产生一个表示新顺序的整数数组

  1. In [12]: df = pd.DataFrame(np.arange(5 * 4).reshape((5,4)))
  3. In [13]: sampler = np.random.permutation(5)
  5. In [14]: sampler
  6. Out[14]: array([4, 0, 2, 1, 3])

然后就可以在基于iloc 的索引操作或take 函数中使用该数组了

  1. In [15]: df
  2. Out[15]:
  3.     0   1   2   3
  4. 0   0   1   2   3
  5. 1   4   5   6   7
  6. 2   8   9  10  11
  7. 3  12  13  14  15
  8. 4  16  17  18  19
  10. In [16]: df.take(sampler)
  11. Out[16]:
  12.     0   1   2   3
  13. 4  16  17  18  19
  14. 0   0   1   2   3
  15. 2   8   9  10  11
  16. 1   4   5   6   7
  17. 3  12  13  14  15

如果不想用替换的方式选取随机子集，可以在Series和DataFrame上使用sample 方法

  1. In [17]: df.sample(n=3)
  2. Out[17]:
  3.     0   1   2   3
  4. 3  12  13  14  15
  5. 2   8   9  10  11
  6. 4  16  17  18  19

要通过替换的方式产生样本（允许重复选择），可以传递replace=True 到sample 

  1. In [18]: choices = pd.Series([5, 7, -1, 6, 4])
  3. In [19]: draws = choices.sample(n=10, replace=True)
  5. In [20]: draws
  6. Out[20]:
  7. 1    7
  8. 1    7
  9. 0    5
  10. 4    4
  11. 2   -1
  12. 3    6
  13. 1    7
  14. 2   -1
  15. 4    4
  16. 0    5
  17. dtype: int64