《利用Python进行数据分析·第2版》第10章（上） 数据聚合与分组运算

作者：SeanCheney   Python爱好者社区专栏作者

简书专栏：https://www.jianshu.com/u/130f76596b02

前文传送门：

对数据集进行分组并对各组应用一个函数（无论是聚合还是转换），通常是数据分析工作中的重要环节。在将数据集加载、融合、准备好之后，通常就是计算分组统计或生成透视表。pandas提供了一个灵活高效的gruopby功能，它使你能以一种自然的方式对数据集进行切片、切块、摘要等操作。

关系型数据库和SQL（Structured Query Language，结构化查询语言）能够如此流行的原因之一就是其能够方便地对数据进行连接、过滤、转换和聚合。但是，像SQL这样的查询语言所能执行的分组运算的种类很有限。在本章中你将会看到，由于Python和pandas强大的表达能力，我们可以执行复杂得多的分组运算（利用任何可以接受pandas对象或NumPy数组的函数）。在本章中，你将会学到：

• 计算分组摘要统计，如计数、平均值、标准差，或用户自定义函数。

• 计算分组的概述统计，比如数量、平均值或标准差，或是用户定义的函数。

• 应用组内转换或其他运算，如规格化、线性回归、排名或选取子集等。

• 计算透视表或交叉表。

• 执行分位数分析以及其它统计分组分析。

笔记：对时间序列数据的聚合（groupby的特殊用法之一）也称作重采样（resampling），本书将在第11章中单独对其进行讲解。

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的形式）：

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

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

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

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

In [14]: grouped.mean() Out[14]: key1 a    0.746672 b   -0.537585 Name: data1, dtype: float64

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

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

In [15]: means = df['data1'].groupby([df['key1'], df['key2']]).mean() In [16]: means Out[16]: key1  key2 a     one     0.880536      two     0.478943 b     one    -0.519439      two    -0.555730 Name: data1, dtype: float64

这里，我通过两个键对数据进行了分组，得到的Series具有一个层次化索引（由唯一的键对组成）：

In [17]: means.unstack() Out[17]: key2       one       two key1                     a     0.880536  0.478943 b    -0.519439 -0.555730

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

In [18]: states = np.array(['Ohio', 'California', 'California', 'Ohio', 'Ohio']) In [19]: years = np.array([2005, 2005, 2006, 2005, 2006]) In [20]: df['data1'].groupby([states, years]).mean() Out[20]: California  2005    0.478943            2006   -0.519439 Ohio        2005   -0.380219            2006    1.965781 Name: data1, dtype: float64

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

In [21]: df.groupby('key1').mean() Out[21]:         data1     data2 key1 a     0.746672  0.910916 b    -0.537585  0.525384 In [22]: df.groupby(['key1', 'key2']).mean() Out[22]:              data1     data2 key1 key2                     a    one   0.880536  1.319920     two   0.478943  0.092908 b    one  -0.519439  0.281746     two  -0.555730  0.769023

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

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

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

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

对分组进行迭代

GroupBy对象支持迭代，可以产生一组二元元组（由分组名和数据块组成）。看下面的例子：

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

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

In [25]: for (k1, k2), group in df.groupby(['key1', 'key2']):   ....:     print((k1, k2))   ....:     print(group)   ....: ('a', 'one')      data1     data2 key1 key2 0 -0.204708  1.393406    a  one 4  1.965781  1.246435    a  one ('a', 'two')      data1     data2 key1 key2 1  0.478943  0.092908    a  two ('b', 'one')      data1     data2 key1 key2 2 -0.519439  0.281746    b  one ('b', 'two')     data1     data2 key1 key2 3 -0.55573  0.769023    b  two

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

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

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

In [28]: df.dtypes Out[28]: data1    float64 data2    float64 key1      object key2      object dtype: object In [29]: grouped = df.groupby(df.dtypes, axis=1)

可以如下打印分组：

In [30]: for dtype, group in grouped:   ....:     print(dtype)   ....:     print(group)   ....: float64      data1     data2 0 -0.204708  1.393406 1  0.478943  0.092908 2 -0.519439  0.281746 3 -0.555730  0.769023 4  1.965781  1.246435 object  key1 key2 0    a  one 1    a  two 2    b  one 3    b  two 4    a  one

选取一列或列的子集

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

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

是以下代码的语法糖：

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

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

In [31]: df.groupby(['key1', 'key2'])[['data2']].mean() Out[31]:              data2 key1 key2           a    one   1.319920     two   0.092908 b    one   0.281746     two   0.769023

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

In [32]: s_grouped = df.groupby(['key1', 'key2'])['data2'] In [33]: s_grouped Out[33]: <pandas.core.groupby.SeriesGroupBy object at 0x7faa30c78da0> In [34]: s_grouped.mean() Out[34]: key1  key2 a     one     1.319920      two     0.092908 b     one     0.281746      two     0.769023 Name: data2, dtype: float64

通过字典或Series进行分组

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

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

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

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

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

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

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

In [41]: map_series = pd.Series(mapping) In [42]: map_series Out[42]: a       red b       red c      blue d      blue e       red f    orange dtype: object In [43]: people.groupby(map_series, axis=1).count() Out[43]:        blue  red Joe        2    3 Steve      2    3 Wes        1    2 Jim        2    3 Travis     2    3

通过函数进行分组

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

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

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

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

赞赏作者

Python爱好者社区历史文章大合集：

福利：文末扫码立刻关注公众号，“Python爱好者社区”，开始学习Python课程：

关注后在公众号内回复“课程”即可获取：

小编的Python入门视频课程！！！

崔老师爬虫实战案例免费学习视频。

丘老师数据科学入门指导免费学习视频。

陈老师数据分析报告制作免费学习视频。

玩转大数据分析！Spark2.X+Python 精华实战课程免费学习视频。

丘老师Python网络爬虫实战免费学习视频。