12.2 GroupBy高级应用

尽管我们在第10章已经深度学习了Series和DataFrame的Groupby方法，还有一些方法也是很有用的。

分组转换和“解封”GroupBy

在第10章，我们在分组操作中学习了apply方法，进行转换。还有另一个transform方法，它与apply很像，但是对使用的函数有一定限制：

  • 它可以产生向分组形状广播标量值
  • 它可以产生一个和输入组形状相同的对象
  • 它不能修改输入

来看一个简单的例子：

  1. In [75]: df = pd.DataFrame({'key': ['a', 'b', 'c'] * 4,
  2.    ....:                    'value': np.arange(12.)})
  4. In [76]: df
  5. Out[76]: 
  6.    key  value
  7. 0    a    0.0
  8. 1    b    1.0
  9. 2    c    2.0
  10. 3    a    3.0
  11. 4    b    4.0
  12. 5    c    5.0
  13. 6    a    6.0
  14. 7    b    7.0
  15. 8    c    8.0
  16. 9    a    9.0
  17. 10   b   10.0
  18. 11   c   11.0

按键进行分组：

  1. In [77]: g = df.groupby('key').value
  3. In [78]: g.mean()
  4. Out[78]: 
  5. key
  6. a    4.5
  7. b    5.5
  8. c    6.5
  9. Name: value, dtype: float64

假设我们想产生一个和df[‘value’]形状相同的Series，但值替换为按键分组的平均值。我们可以传递函数lambda x: x.mean()进行转换：

  1. In [79]: g.transform(lambda x: x.mean())
  2. Out[79]: 
  3. 0     4.5
  4. 1     5.5
  5. 2     6.5
  6. 3     4.5
  7. 4     5.5
  8. 5     6.5
  9. 6     4.5
  10. 7     5.5
  11. 8     6.5
  12. 9     4.5
  13. 10    5.5
  14. 11    6.5
  15. Name: value, dtype: float64

对于内置的聚合函数，我们可以传递一个字符串假名作为GroupBy的agg方法：

  1. In [80]: g.transform('mean')
  2. Out[80]: 
  3. 0     4.5
  4. 1     5.5
  5. 2     6.5
  6. 3     4.5
  7. 4     5.5
  8. 5     6.5
  9. 6     4.5
  10. 7     5.5
  11. 8     6.5
  12. 9     4.5
  13. 10    5.5
  14. 11    6.5
  15. Name: value, dtype: float64

与apply类似，transform的函数会返回Series，但是结果必须与输入大小相同。举个例子，我们可以用lambda函数将每个分组乘以2：

  1. In [81]: g.transform(lambda x: x * 2)
  2. Out[81]: 
  3. 0      0.0
  4. 1      2.0
  5. 2      4.0
  6. 3      6.0
  7. 4      8.0
  8. 5     10.0
  9. 6     12.0
  10. 7     14.0
  11. 8     16.0
  12. 9     18.0
  13. 10    20.0
  14. 11    22.0
  15. Name: value, dtype: float64

再举一个复杂的例子，我们可以计算每个分组的降序排名：

  1. In [82]: g.transform(lambda x: x.rank(ascending=False))
  2. Out[82]: 
  3. 0     4.0
  4. 1     4.0
  5. 2     4.0
  6. 3     3.0
  7. 4     3.0
  8. 5     3.0
  9. 6     2.0
  10. 7     2.0
  11. 8     2.0
  12. 9     1.0
  13. 10    1.0
  14. 11    1.0
  15. Name: value, dtype: float64

看一个由简单聚合构造的的分组转换函数：

  1. def normalize(x):
  2.     return (x - x.mean()) / x.std()

我们用transform或apply可以获得等价的结果：

  1. In [84]: g.transform(normalize)
  2. Out[84]: 
  3. 0    -1.161895
  4. 1    -1.161895
  5. 2    -1.161895
  6. 3    -0.387298
  7. 4    -0.387298
  8. 5    -0.387298
  9. 6     0.387298
  10. 7     0.387298
  11. 8     0.387298
  12. 9     1.161895
  13. 10    1.161895
  14. 11    1.161895
  15. Name: value, dtype: float64
  17. In [85]: g.apply(normalize)
  18. Out[85]: 
  19. 0    -1.161895
  20. 1    -1.161895
  21. 2    -1.161895
  22. 3    -0.387298
  23. 4    -0.387298
  24. 5    -0.387298
  25. 6     0.387298
  26. 7     0.387298
  27. 8     0.387298
  28. 9     1.161895
  29. 10    1.161895
  30. 11    1.161895
  31. Name: value, dtype: float64

内置的聚合函数，比如mean或sum，通常比apply函数快，也比transform快。这允许我们进行一个所谓的解封（unwrapped）分组操作：

  1. In [86]: g.transform('mean')
  2. Out[86]: 
  3. 0     4.5
  4. 1     5.5
  5. 2     6.5
  6. 3     4.5
  7. 4     5.5
  8. 5     6.5
  9. 6     4.5
  10. 7     5.5
  11. 8     6.5
  12. 9     4.5
  13. 10    5.5
  14. 11    6.5
  15. Name: value, dtype: float64
  17. In [87]: normalized = (df['value'] - g.transform('mean')) / g.transform('std')
  19. In [88]: normalized
  20. Out[88]: 
  21. 0    -1.161895
  22. 1    -1.161895
  23. 2    -1.161895
  24. 3    -0.387298
  25. 4    -0.387298
  26. 5    -0.387298
  27. 6     0.387298
  28. 7     0.387298
  29. 8     0.387298
  30. 9     1.161895
  31. 10    1.161895
  32. 11    1.161895
  33. Name: value, dtype: float64

解封分组操作可能包括多个分组聚合，但是矢量化操作还是会带来收益。

分组的时间重采样

对于时间序列数据，resample方法从语义上是一个基于内在时间的分组操作。下面是一个示例表：

  1. In [89]: N = 15
  3. In [90]: times = pd.date_range('2017-05-20 00:00', freq='1min', periods=N)
  5. In [91]: df = pd.DataFrame({'time': times,
  6.    ....:                    'value': np.arange(N)})
  8. In [92]: df
  9. Out[92]: 
  10.                   time  value
  11. 0  2017-05-20 00:00:00      0
  12. 1  2017-05-20 00:01:00      1
  13. 2  2017-05-20 00:02:00      2
  14. 3  2017-05-20 00:03:00      3
  15. 4  2017-05-20 00:04:00      4
  16. 5  2017-05-20 00:05:00      5
  17. 6  2017-05-20 00:06:00      6
  18. 7  2017-05-20 00:07:00      7
  19. 8  2017-05-20 00:08:00      8
  20. 9  2017-05-20 00:09:00      9
  21. 10 2017-05-20 00:10:00     10
  22. 11 2017-05-20 00:11:00     11
  23. 12 2017-05-20 00:12:00     12
  24. 13 2017-05-20 00:13:00     13
  25. 14 2017-05-20 00:14:00     14

这里，我们可以用time作为索引，然后重采样：

  1. In [93]: df.set_index('time').resample('5min').count()
  2. Out[93]: 
  3.                      value
  4. time                      
  5. 2017-05-20 00:00:00      5
  6. 2017-05-20 00:05:00      5
  7. 2017-05-20 00:10:00      5

假设DataFrame包含多个时间序列，用一个额外的分组键的列进行标记：

  1. In [94]: df2 = pd.DataFrame({'time': times.repeat(3),
  2.    ....:                     'key': np.tile(['a', 'b', 'c'], N),
  3.    ....:                     'value': np.arange(N * 3.)})
  5. In [95]: df2[:7]
  6. Out[95]: 
  7.   key                time  value
  8. 0   a 2017-05-20 00:00:00    0.0
  9. 1   b 2017-05-20 00:00:00    1.0
  10. 2   c 2017-05-20 00:00:00    2.0
  11. 3   a 2017-05-20 00:01:00    3.0
  12. 4   b 2017-05-20 00:01:00    4.0
  13. 5   c 2017-05-20 00:01:00    5.0
  14. 6   a 2017-05-20 00:02:00    6.0

要对每个key值进行相同的重采样，我们引入pandas.TimeGrouper对象：

  1. In [96]: time_key = pd.TimeGrouper('5min')

我们然后设定时间索引，用key和time_key分组，然后聚合：

  1. In [97]: resampled = (df2.set_index('time')
  2.    ....:              .groupby(['key', time_key])
  3.    ....:              .sum())
  5. In [98]: resampled
  6. Out[98]: 
  7.                          value
  8. key time                      
  9. a   2017-05-20 00:00:00   30.0
  10.     2017-05-20 00:05:00  105.0
  11.     2017-05-20 00:10:00  180.0
  12. b   2017-05-20 00:00:00   35.0
  13.     2017-05-20 00:05:00  110.0
  14.     2017-05-20 00:10:00  185.0
  15. c   2017-05-20 00:00:00   40.0
  16.     2017-05-20 00:05:00  115.0
  17.     2017-05-20 00:10:00  190.0
  19. In [99]: resampled.reset_index()
  20. Out[99]:
  21. key                time  value
  22. 0   a 2017-05-20 00:00:00   30.0
  23. 1   a 2017-05-20 00:05:00  105.0
  24. 2   a 2017-05-20 00:10:00  180.0
  25. 3   b 2017-05-20 00:00:00   35.0
  26. 4   b 2017-05-20 00:05:00  110.0
  27. 5   b 2017-05-20 00:10:00  185.0
  28. 6   c 2017-05-20 00:00:00   40.0
  29. 7   c 2017-05-20 00:05:00  115.0
  30. 8   c 2017-05-20 00:10:00  190.0

使用TimeGrouper的限制是时间必须是Series或DataFrame的索引。