12.1 分类数据

这一节介绍的是pandas的分类类型。我会向你展示通过使用它，提高性能和内存的使用率。我还会介绍一些在统计和机器学习中使用分类数据的工具。

背景和目的

表中的一列通常会有重复的包含不同值的小集合的情况。我们已经学过了unique和value_counts，它们可以从数组提取出不同的值，并分别计算频率：

  1. In [10]: import numpy as np; import pandas as pd
  3. In [11]: values = pd.Series(['apple', 'orange', 'apple',
  4.    ....:                     'apple'] * 2)
  6. In [12]: values
  7. Out[12]: 
  8. 0     apple
  9. 1    orange
  10. 2     apple
  11. 3     apple
  12. 4     apple
  13. 5    orange
  14. 6     apple
  15. 7     apple
  16. dtype: object
  18. In [13]: pd.unique(values)
  19. Out[13]: array(['apple', 'orange'], dtype=object)
  21. In [14]: pd.value_counts(values)
  22. Out[14]: 
  23. apple     6
  24. orange    2
  25. dtype: int64

许多数据系统（数据仓库、统计计算或其它应用）都发展出了特定的表征重复值的方法，以进行高效的存储和计算。在数据仓库中，最好的方法是使用所谓的包含不同值的维表(Dimension Table)，将主要的参数存储为引用维表整数键：

  1. In [15]: values = pd.Series([0, 1, 0, 0] * 2)
  3. In [16]: dim = pd.Series(['apple', 'orange'])
  5. In [17]: values
  6. Out[17]: 
  7. 0    0
  8. 1    1
  9. 2    0
  10. 3    0
  11. 4    0
  12. 5    1
  13. 6    0
  14. 7    0
  15. dtype: int64
  17. In [18]: dim
  18. Out[18]: 
  19. 0     apple
  20. 1    orange
  21. dtype: object

可以使用take方法存储原始的字符串Series：

  1. In [19]: dim.take(values)
  2. Out[19]: 
  3. 0     apple
  4. 1    orange
  5. 0     apple
  6. 0     apple
  7. 0     apple
  8. 1    orange
  9. 0     apple
  10. 0     apple
  11. dtype: object

这种用整数表示的方法称为分类或字典编码表示法。不同值得数组称为分类、字典或数据级。本书中，我们使用分类的说法。表示分类的整数值称为分类编码或简单地称为编码。

分类表示可以在进行分析时大大的提高性能。你也可以在保持编码不变的情况下，对分类进行转换。一些相对简单的转变例子包括：

  • 重命名分类。
  • 加入一个新的分类，不改变已经存在的分类的顺序或位置。

pandas的分类类型

pandas有一个特殊的分类类型，用于保存使用整数分类表示法的数据。看一个之前的Series例子：

  1. In [20]: fruits = ['apple', 'orange', 'apple', 'apple'] * 2
  3. In [21]: N = len(fruits)
  5. In [22]: df = pd.DataFrame({'fruit': fruits,
  6.    ....:                    'basket_id': np.arange(N),
  7.    ....:                    'count': np.random.randint(3, 15, size=N),
  8.    ....:                    'weight': np.random.uniform(0, 4, size=N)},
  9.    ....:                   columns=['basket_id', 'fruit', 'count', 'weight'])
  11. In [23]: df
  12. Out[23]: 
  13.    basket_id   fruit  count    weight
  14. 0          0   apple      5  3.858058
  15. 1          1  orange      8  2.612708
  16. 2          2   apple      4  2.995627
  17. 3          3   apple      7  2.614279
  18. 4          4   apple     12  2.990859
  19. 5          5  orange      8  3.845227
  20. 6          6   apple      5  0.033553
  21. 7          7   apple      4  0.425778

这里，df[‘fruit’]是一个Python字符串对象的数组。我们可以通过调用它，将它转变为分类：

  1. In [24]: fruit_cat = df['fruit'].astype('category')
  3. In [25]: fruit_cat
  4. Out[25]: 
  5. 0     apple
  6. 1    orange
  7. 2     apple
  8. 3     apple
  9. 4     apple
  10. 5    orange
  11. 6     apple
  12. 7     apple
  13. Name: fruit, dtype: category
  14. Categories (2, object): [apple, orange]

fruit_cat的值不是NumPy数组，而是一个pandas.Categorical实例：

  1. In [26]: c = fruit_cat.values
  3. In [27]: type(c)
  4. Out[27]: pandas.core.categorical.Categorical

分类对象有categories和codes属性：

  1. In [28]: c.categories
  2. Out[28]: Index(['apple', 'orange'], dtype='object')
  4. In [29]: c.codes
  5. Out[29]: array([0, 1, 0, 0, 0, 1, 0, 0], dtype=int8)

你可将DataFrame的列通过分配转换结果，转换为分类：

  1. In [30]: df['fruit'] = df['fruit'].astype('category')
  3. In [31]: df.fruit
  4. Out[31]:
  5. 0     apple
  6. 1    orange
  7. 2     apple
  8. 3     apple
  9. 4     apple
  10. 5    orange
  11. 6     apple
  12. 7     apple
  13. Name: fruit, dtype: category
  14. Categories (2, object): [apple, orange]

你还可以从其它Python序列直接创建pandas.Categorical：

  1. In [32]: my_categories = pd.Categorical(['foo', 'bar', 'baz', 'foo', 'bar'])
  3. In [33]: my_categories
  4. Out[33]: 
  5. [foo, bar, baz, foo, bar]
  6. Categories (3, object): [bar, baz, foo]

如果你已经从其它源获得了分类编码，你还可以使用from_codes构造器：

  1. In [34]: categories = ['foo', 'bar', 'baz']
  3. In [35]: codes = [0, 1, 2, 0, 0, 1]
  5. In [36]: my_cats_2 = pd.Categorical.from_codes(codes, categories)
  7. In [37]: my_cats_2
  8. Out[37]: 
  9. [foo, bar, baz, foo, foo, bar]
  10. Categories (3, object): [foo, bar, baz]

与显示指定不同，分类变换不认定指定的分类顺序。因此取决于输入数据的顺序，categories数组的顺序会不同。当使用from_codes或其它的构造器时，你可以指定分类一个有意义的顺序：

  1. In [38]: ordered_cat = pd.Categorical.from_codes(codes, categories,
  2.    ....:                                         ordered=True)
  4. In [39]: ordered_cat
  5. Out[39]: 
  6. [foo, bar, baz, foo, foo, bar]
  7. Categories (3, object): [foo < bar < baz]

输出[foo < bar < baz]指明‘foo’位于‘bar’的前面，以此类推。无序的分类实例可以通过as_ordered排序：

  1. In [40]: my_cats_2.as_ordered()
  2. Out[40]: 
  3. [foo, bar, baz, foo, foo, bar]
  4. Categories (3, object): [foo < bar < baz]

最后要注意，分类数据不需要字符串，尽管我仅仅展示了字符串的例子。分类数组可以包括任意不可变类型。

用分类进行计算

与非编码版本（比如字符串数组）相比，使用pandas的Categorical有些类似。某些pandas组件，比如groupby函数，更适合进行分类。还有一些函数可以使用有序标志位。

来看一些随机的数值数据，使用pandas.qcut面元函数。它会返回pandas.Categorical，我们之前使用过pandas.cut，但没解释分类是如何工作的：

  1. In [41]: np.random.seed(12345)
  3. In [42]: draws = np.random.randn(1000)
  5. In [43]: draws[:5]
  6. Out[43]: array([-0.2047,  0.4789, -0.5194, -0.5557,  1.9658])

计算这个数据的分位面元，提取一些统计信息：

  1. In [44]: bins = pd.qcut(draws, 4)
  3. In [45]: bins
  4. Out[45]: 
  5. [(-0.684, -0.0101], (-0.0101, 0.63], (-0.684, -0.0101], (-0.684, -0.0101], (0.63,
  6.  3.928], ..., (-0.0101, 0.63], (-0.684, -0.0101], (-2.95, -0.684], (-0.0101, 0.63
  7. ], (0.63, 3.928]]
  8. Length: 1000
  9. Categories (4, interval[float64]): [(-2.95, -0.684] < (-0.684, -0.0101] < (-0.010
  10. 1, 0.63] <
  11.                                     (0.63, 3.928]]

虽然有用，确切的样本分位数与分位的名称相比，不利于生成汇总。我们可以使用labels参数qcut，实现目的：

  1. In [46]: bins = pd.qcut(draws, 4, labels=['Q1', 'Q2', 'Q3', 'Q4'])
  3. In [47]: bins
  4. Out[47]: 
  5. [Q2, Q3, Q2, Q2, Q4, ..., Q3, Q2, Q1, Q3, Q4]
  6. Length: 1000
  7. Categories (4, object): [Q1 < Q2 < Q3 < Q4]
  9. In [48]: bins.codes[:10]
  10. Out[48]: array([1, 2, 1, 1, 3, 3, 2, 2, 3, 3], dtype=int8)

加上标签的面元分类不包含数据面元边界的信息，因此可以使用groupby提取一些汇总信息：

  1. In [49]: bins = pd.Series(bins, name='quartile')
  3. In [50]: results = (pd.Series(draws)
  4.    ....:            .groupby(bins)
  5.    ....:            .agg(['count', 'min', 'max'])
  6.    ....:            .reset_index())
  8. In [51]: results
  9. Out[51]: 
  10.   quartile  count       min       max
  11. 0       Q1    250 -2.949343 -0.685484
  12. 1       Q2    250 -0.683066 -0.010115
  13. 2       Q3    250 -0.010032  0.628894
  14. 3       Q4    250  0.634238  3.927528

分位数列保存了原始的面元分类信息，包括排序：

  1. In [52]: results['quartile']
  2. Out[52]:
  3. 0    Q1
  4. 1    Q2
  5. 2    Q3
  6. 3    Q4
  7. Name: quartile, dtype: category
  8. Categories (4, object): [Q1 < Q2 < Q3 < Q4]

用分类提高性能

如果你是在一个特定数据集上做大量分析，将其转换为分类可以极大地提高效率。DataFrame列的分类使用的内存通常少的多。来看一些包含一千万元素的Series，和一些不同的分类：

  1. In [53]: N = 10000000
  3. In [54]: draws = pd.Series(np.random.randn(N))
  5. In [55]: labels = pd.Series(['foo', 'bar', 'baz', 'qux'] * (N // 4))

现在，将标签转换为分类：

  1. In [56]: categories = labels.astype('category')

这时，可以看到标签使用的内存远比分类多：

  1. In [57]: labels.memory_usage()
  2. Out[57]: 80000080
  4. In [58]: categories.memory_usage()
  5. Out[58]: 10000272

转换为分类不是没有代价的，但这是一次性的代价：

  1. In [59]: %time _ = labels.astype('category')
  2. CPU times: user 490 ms, sys: 240 ms, total: 730 ms
  3. Wall time: 726 ms

GroupBy使用分类操作明显更快，是因为底层的算法使用整数编码数组，而不是字符串数组。

分类方法

包含分类数据的Series有一些特殊的方法，类似于Series.str字符串方法。它还提供了方便的分类和编码的使用方法。看下面的Series：

  1. In [60]: s = pd.Series(['a', 'b', 'c', 'd'] * 2)
  3. In [61]: cat_s = s.astype('category')
  5. In [62]: cat_s
  6. Out[62]: 
  7. 0    a
  8. 1    b
  9. 2    c
  10. 3    d
  11. 4    a
  12. 5    b
  13. 6    c
  14. 7    d
  15. dtype: category
  16. Categories (4, object): [a, b, c, d]

特别的cat属性提供了分类方法的入口：

  1. In [63]: cat_s.cat.codes
  2. Out[63]: 
  3. 0    0
  4. 1    1
  5. 2    2
  6. 3    3
  7. 4    0
  8. 5    1
  9. 6    2
  10. 7    3
  11. dtype: int8
  13. In [64]: cat_s.cat.categories
  14. Out[64]: Index(['a', 'b', 'c', 'd'], dtype='object')

假设我们知道这个数据的实际分类集，超出了数据中的四个值。我们可以使用set_categories方法改变它们：

  1. In [65]: actual_categories = ['a', 'b', 'c', 'd', 'e']
  3. In [66]: cat_s2 = cat_s.cat.set_categories(actual_categories)
  5. In [67]: cat_s2
  6. Out[67]: 
  7. 0    a
  8. 1    b
  9. 2    c
  10. 3    d
  11. 4    a
  12. 5    b
  13. 6    c
  14. 7    d
  15. dtype: category
  16. Categories (5, object): [a, b, c, d, e]

虽然数据看起来没变，新的分类将反映在它们的操作中。例如，如果有的话，value_counts表示分类：

  1. In [68]: cat_s.value_counts()
  2. Out[68]: 
  3. d    2
  4. c    2
  5. b    2
  6. a    2
  7. dtype: int64
  9. In [69]: cat_s2.value_counts()
  10. Out[69]: 
  11. d    2
  12. c    2
  13. b    2
  14. a    2
  15. e    0
  16. dtype: int64

在大数据集中，分类经常作为节省内存和高性能的便捷工具。过滤完大DataFrame或Series之后，许多分类可能不会出现在数据中。我们可以使用remove_unused_categories方法删除没看到的分类：

  1. In [70]: cat_s3 = cat_s[cat_s.isin(['a', 'b'])]
  3. In [71]: cat_s3
  4. Out[71]: 
  5. 0    a
  6. 1    b
  7. 4    a
  8. 5    b
  9. dtype: category
  10. Categories (4, object): [a, b, c, d]
  12. In [72]: cat_s3.cat.remove_unused_categories()
  13. Out[72]: 
  14. 0    a
  15. 1    b
  16. 4    a
  17. 5    b
  18. dtype: category
  19. Categories (2, object): [a, b]

表12-1列出了可用的分类方法。

表12-1 pandas的Series的分类方法

为建模创建虚拟变量

当你使用统计或机器学习工具时，通常会将分类数据转换为虚拟变量，也称为one-hot编码。这包括创建一个不同类别的列的DataFrame；这些列包含给定分类的1s，其它为0。

看前面的例子：

  1. In [73]: cat_s = pd.Series(['a', 'b', 'c', 'd'] * 2, dtype='category')

前面的第7章提到过，pandas.get_dummies函数可以转换这个分类数据为包含虚拟变量的DataFrame：

  1. In [74]: pd.get_dummies(cat_s)
  2. Out[74]: 
  3.    a  b  c  d
  4. 0  1  0  0  0
  5. 1  0  1  0  0
  6. 2  0  0  1  0
  7. 3  0  0  0  1
  8. 4  1  0  0  0
  9. 5  0  1  0  0
  10. 6  0  0  1  0
  11. 7  0  0  0  1