• 10.1 GroupBy机制
    • 对分组进行迭代
    • 选取一列或列的子集
    • 通过字典或Series进行分组
    • 通过函数进行分组
    • 根据索引级别分组

    10.1 GroupBy机制

    Hadley Wickham(许多热门R语言包的作者)创造了一个用于表示分组运算的术语”split-apply-combine”(拆分-应用-合并)。第一个阶段,pandas对象(无论是Series、DataFrame还是其他的)中的数据会根据你所提供的一个或多个键被拆分(split)为多组。拆分操作是在对象的特定轴上执行的。例如,DataFrame可以在其行(axis=0)或列(axis=1)上进行分组。然后,将一个函数应用(apply)到各个分组并产生一个新值。最后,所有这些函数的执行结果会被合并(combine)到最终的结果对象中。结果对象的形式一般取决于数据上所执行的操作。图10-1大致说明了一个简单的分组聚合过程。

    图10-1 分组聚合演示

    分组键可以有多种形式,且类型不必相同:

    • 列表或数组,其长度与待分组的轴一样。
    • 表示DataFrame某个列名的值。
    • 字典或Series,给出待分组轴上的值与分组名之间的对应关系。
    • 函数,用于处理轴索引或索引中的各个标签。

    注意,后三种都只是快捷方式而已,其最终目的仍然是产生一组用于拆分对象的值。如果觉得这些东西看起来很抽象,不用担心,我将在本章中给出大量有关于此的示例。首先来看看下面这个非常简单的表格型数据集(以DataFrame的形式):

    1. In [10]: df = pd.DataFrame({'key1' : ['a', 'a', 'b', 'b', 'a'],
    2. ....: 'key2' : ['one', 'two', 'one', 'two', 'one'],
    3. ....: 'data1' : np.random.randn(5),
    4. ....: 'data2' : np.random.randn(5)})
    5. In [11]: df
    6. Out[11]:
    7. data1 data2 key1 key2
    8. 0 -0.204708 1.393406 a one
    9. 1 0.478943 0.092908 a two
    10. 2 -0.519439 0.281746 b one
    11. 3 -0.555730 0.769023 b two
    12. 4 1.965781 1.246435 a one

    假设你想要按key1进行分组,并计算data1列的平均值。实现该功能的方式有很多,而我们这里要用的是:访问data1,并根据key1调用groupby:

    1. In [12]: grouped = df['data1'].groupby(df['key1'])
    2. In [13]: grouped
    3. Out[13]: <pandas.core.groupby.SeriesGroupBy object at 0x7faa31537390>

    变量grouped是一个GroupBy对象。它实际上还没有进行任何计算,只是含有一些有关分组键df[‘key1’]的中间数据而已。换句话说,该对象已经有了接下来对各分组执行运算所需的一切信息。例如,我们可以调用GroupBy的mean方法来计算分组平均值:

    1. In [14]: grouped.mean()
    2. Out[14]:
    3. key1
    4. a 0.746672
    5. b -0.537585
    6. Name: data1, dtype: float64

    稍后我将详细讲解.mean()的调用过程。这里最重要的是,数据(Series)根据分组键进行了聚合,产生了一个新的Series,其索引为key1列中的唯一值。之所以结果中索引的名称为key1,是因为原始DataFrame的列df[‘key1’]就叫这个名字。

    如果我们一次传入多个数组的列表,就会得到不同的结果:

    1. In [15]: means = df['data1'].groupby([df['key1'], df['key2']]).mean()
    2. In [16]: means
    3. Out[16]:
    4. key1 key2
    5. a one 0.880536
    6. two 0.478943
    7. b one -0.519439
    8. two -0.555730
    9. Name: data1, dtype: float64

    这里,我通过两个键对数据进行了分组,得到的Series具有一个层次化索引(由唯一的键对组成):

    1. In [17]: means.unstack()
    2. Out[17]:
    3. key2 one two
    4. key1
    5. a 0.880536 0.478943
    6. b -0.519439 -0.555730

    在这个例子中,分组键均为Series。实际上,分组键可以是任何长度适当的数组:

    1. In [18]: states = np.array(['Ohio', 'California', 'California', 'Ohio', 'Ohio'])
    2. In [19]: years = np.array([2005, 2005, 2006, 2005, 2006])
    3. In [20]: df['data1'].groupby([states, years]).mean()
    4. Out[20]:
    5. California 2005 0.478943
    6. 2006 -0.519439
    7. Ohio 2005 -0.380219
    8. 2006 1.965781
    9. Name: data1, dtype: float64

    通常,分组信息就位于相同的要处理DataFrame中。这里,你还可以将列名(可以是字符串、数字或其他Python对象)用作分组键:

    1. In [21]: df.groupby('key1').mean()
    2. Out[21]:
    3. data1 data2
    4. key1
    5. a 0.746672 0.910916
    6. b -0.537585 0.525384
    7. In [22]: df.groupby(['key1', 'key2']).mean()
    8. Out[22]:
    9. data1 data2
    10. key1 key2
    11. a one 0.880536 1.319920
    12. two 0.478943 0.092908
    13. b one -0.519439 0.281746
    14. two -0.555730 0.769023

    你可能已经注意到了,第一个例子在执行df.groupby(‘key1’).mean()时,结果中没有key2列。这是因为df[‘key2’]不是数值数据(俗称“麻烦列”),所以被从结果中排除了。默认情况下,所有数值列都会被聚合,虽然有时可能会被过滤为一个子集,稍后就会碰到。

    无论你准备拿groupby做什么,都有可能会用到GroupBy的size方法,它可以返回一个含有分组大小的Series:

    1. In [23]: df.groupby(['key1', 'key2']).size()
    2. Out[23]:
    3. key1 key2
    4. a one 2
    5. two 1
    6. b one 1
    7. two 1
    8. dtype: int64

    注意,任何分组关键词中的缺失值,都会被从结果中除去。

    对分组进行迭代

    GroupBy对象支持迭代,可以产生一组二元元组(由分组名和数据块组成)。看下面的例子:

    1. In [24]: for name, group in df.groupby('key1'):
    2. ....: print(name)
    3. ....: print(group)
    4. ....:
    5. a
    6. data1 data2 key1 key2
    7. 0 -0.204708 1.393406 a one
    8. 1 0.478943 0.092908 a two
    9. 4 1.965781 1.246435 a one
    10. b
    11. data1 data2 key1 key2
    12. 2 -0.519439 0.281746 b one
    13. 3 -0.555730 0.769023 b two

    对于多重键的情况,元组的第一个元素将会是由键值组成的元组:

    1. In [25]: for (k1, k2), group in df.groupby(['key1', 'key2']):
    2. ....: print((k1, k2))
    3. ....: print(group)
    4. ....:
    5. ('a', 'one')
    6. data1 data2 key1 key2
    7. 0 -0.204708 1.393406 a one
    8. 4 1.965781 1.246435 a one
    9. ('a', 'two')
    10. data1 data2 key1 key2
    11. 1 0.478943 0.092908 a two
    12. ('b', 'one')
    13. data1 data2 key1 key2
    14. 2 -0.519439 0.281746 b one
    15. ('b', 'two')
    16. data1 data2 key1 key2
    17. 3 -0.55573 0.769023 b two

    当然,你可以对这些数据片段做任何操作。有一个你可能会觉得有用的运算:将这些数据片段做成一个字典:

    1. In [26]: pieces = dict(list(df.groupby('key1')))
    2. In [27]: pieces['b']
    3. Out[27]:
    4. data1 data2 key1 key2
    5. 2 -0.519439 0.281746 b one
    6. 3 -0.555730 0.769023 b two

    groupby默认是在axis=0上进行分组的,通过设置也可以在其他任何轴上进行分组。拿上面例子中的df来说,我们可以根据dtype对列进行分组:

    1. In [28]: df.dtypes
    2. Out[28]:
    3. data1 float64
    4. data2 float64
    5. key1 object
    6. key2 object
    7. dtype: object
    8. In [29]: grouped = df.groupby(df.dtypes, axis=1)

    可以如下打印分组:

    1. In [30]: for dtype, group in grouped:
    2. ....: print(dtype)
    3. ....: print(group)
    4. ....:
    5. float64
    6. data1 data2
    7. 0 -0.204708 1.393406
    8. 1 0.478943 0.092908
    9. 2 -0.519439 0.281746
    10. 3 -0.555730 0.769023
    11. 4 1.965781 1.246435
    12. object
    13. key1 key2
    14. 0 a one
    15. 1 a two
    16. 2 b one
    17. 3 b two
    18. 4 a one

    选取一列或列的子集

    对于由DataFrame产生的GroupBy对象,如果用一个(单个字符串)或一组(字符串数组)列名对其进行索引,就能实现选取部分列进行聚合的目的。也就是说:

    1. df.groupby('key1')['data1']
    2. df.groupby('key1')[['data2']]

    是以下代码的语法糖:

    1. df['data1'].groupby(df['key1'])
    2. df[['data2']].groupby(df['key1'])

    尤其对于大数据集,很可能只需要对部分列进行聚合。例如,在前面那个数据集中,如果只需计算data2列的平均值并以DataFrame形式得到结果,可以这样写:

    1. In [31]: df.groupby(['key1', 'key2'])[['data2']].mean()
    2. Out[31]:
    3. data2
    4. key1 key2
    5. a one 1.319920
    6. two 0.092908
    7. b one 0.281746
    8. two 0.769023

    这种索引操作所返回的对象是一个已分组的DataFrame(如果传入的是列表或数组)或已分组的Series(如果传入的是标量形式的单个列名):

    1. In [32]: s_grouped = df.groupby(['key1', 'key2'])['data2']
    2. In [33]: s_grouped
    3. Out[33]: <pandas.core.groupby.SeriesGroupBy object at 0x7faa30c78da0>
    4. In [34]: s_grouped.mean()
    5. Out[34]:
    6. key1 key2
    7. a one 1.319920
    8. two 0.092908
    9. b one 0.281746
    10. two 0.769023
    11. Name: data2, dtype: float64

    通过字典或Series进行分组

    除数组以外,分组信息还可以其他形式存在。来看另一个示例DataFrame:

    1. In [35]: people = pd.DataFrame(np.random.randn(5, 5),
    2. ....: columns=['a', 'b', 'c', 'd', 'e'],
    3. ....: index=['Joe', 'Steve', 'Wes', 'Jim', 'Travis'])
    4. In [36]: people.iloc[2:3, [1, 2]] = np.nan # Add a few NA values
    5. In [37]: people
    6. Out[37]:
    7. a b c d e
    8. Joe 1.007189 -1.296221 0.274992 0.228913 1.352917
    9. Steve 0.886429 -2.001637 -0.371843 1.669025 -0.438570
    10. Wes -0.539741 NaN NaN -1.021228 -0.577087
    11. Jim 0.124121 0.302614 0.523772 0.000940 1.343810
    12. Travis -0.713544 -0.831154 -2.370232 -1.860761 -0.860757

    现在,假设已知列的分组关系,并希望根据分组计算列的和:

    1. In [38]: mapping = {'a': 'red', 'b': 'red', 'c': 'blue',
    2. ....: 'd': 'blue', 'e': 'red', 'f' : 'orange'}

    现在,你可以将这个字典传给groupby,来构造数组,但我们可以直接传递字典(我包含了键“f”来强调,存在未使用的分组键是可以的):

    1. In [39]: by_column = people.groupby(mapping, axis=1)
    2. In [40]: by_column.sum()
    3. Out[40]:
    4. blue red
    5. Joe 0.503905 1.063885
    6. Steve 1.297183 -1.553778
    7. Wes -1.021228 -1.116829
    8. Jim 0.524712 1.770545
    9. Travis -4.230992 -2.405455

    Series也有同样的功能,它可以被看做一个固定大小的映射:

    1. In [41]: map_series = pd.Series(mapping)
    2. In [42]: map_series
    3. Out[42]:
    4. a red
    5. b red
    6. c blue
    7. d blue
    8. e red
    9. f orange
    10. dtype: object
    11. In [43]: people.groupby(map_series, axis=1).count()
    12. Out[43]:
    13. blue red
    14. Joe 2 3
    15. Steve 2 3
    16. Wes 1 2
    17. Jim 2 3
    18. Travis 2 3

    通过函数进行分组

    比起使用字典或Series,使用Python函数是一种更原生的方法定义分组映射。任何被当做分组键的函数都会在各个索引值上被调用一次,其返回值就会被用作分组名称。具体点说,以上一小节的示例DataFrame为例,其索引值为人的名字。你可以计算一个字符串长度的数组,更简单的方法是传入len函数:

    1. In [44]: people.groupby(len).sum()
    2. Out[44]:
    3. a b c d e
    4. 3 0.591569 -0.993608 0.798764 -0.791374 2.119639
    5. 5 0.886429 -2.001637 -0.371843 1.669025 -0.438570
    6. 6 -0.713544 -0.831154 -2.370232 -1.860761 -0.860757

    将函数跟数组、列表、字典、Series混合使用也不是问题,因为任何东西在内部都会被转换为数组:

    1. In [45]: key_list = ['one', 'one', 'one', 'two', 'two']
    2. In [46]: people.groupby([len, key_list]).min()
    3. Out[46]:
    4. a b c d e
    5. 3 one -0.539741 -1.296221 0.274992 -1.021228 -0.577087
    6. two 0.124121 0.302614 0.523772 0.000940 1.343810
    7. 5 one 0.886429 -2.001637 -0.371843 1.669025 -0.438570
    8. 6 two -0.713544 -0.831154 -2.370232 -1.860761 -0.860757

    根据索引级别分组

    层次化索引数据集最方便的地方就在于它能够根据轴索引的一个级别进行聚合:

    1. In [47]: columns = pd.MultiIndex.from_arrays([['US', 'US', 'US', 'JP', 'JP'],
    2. ....: [1, 3, 5, 1, 3]],
    3. ....: names=['cty', 'tenor'])
    4. In [48]: hier_df = pd.DataFrame(np.random.randn(4, 5), columns=columns)
    5. In [49]: hier_df
    6. Out[49]:
    7. cty US JP
    8. tenor 1 3 5 1 3
    9. 0 0.560145 -1.265934 0.119827 -1.063512 0.332883
    10. 1 -2.359419 -0.199543 -1.541996 -0.970736 -1.307030
    11. 2 0.286350 0.377984 -0.753887 0.331286 1.349742
    12. 3 0.069877 0.246674 -0.011862 1.004812 1.327195

    要根据级别分组,使用level关键字传递级别序号或名字:

    1. In [50]: hier_df.groupby(level='cty', axis=1).count()
    2. Out[50]:
    3. cty JP US
    4. 0 2 3
    5. 1 2 3
    6. 2 2 3
    7. 3 2 3