• 12.2 GroupBy高级应用
    • 分组转换和“解封”GroupBy
    • 分组的时间重采样

    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的索引。