1、首先来看看下面这个非常简单的表格型数据集（以DataFrame的形式）：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
>>>
import
pandas as pd
>>> df
=
pd.DataFrame({
'key1'
:[
'a'
,
'a'
,
'b'
,
'a'
],
...
'key2'
:[
'one'
,
'two'
,
'one'
,
'one'
],
>>> df
data1 data2 key1 key2
|
假设你想要按key1进行分组，并计算data1列的平均值，我们可以访问data1，并根据key1调用groupby：
|
1
2
3
|
>>> grouped
=
df[
'data1'
].groupby(df[
'key1'
])
>>> grouped
|
变量grouped是一个GroupBy对象，它实际上还没有进行任何计算，只是含有一些有关分组键df['key1']的中间数据而已，然后我们可以调用GroupBy的mean方法来计算分组平均值：
说明：数据（Series）根据分组键进行了聚合，产生了一个新的Series，其索引为key1列中的唯一值。之所以结果中索引的名称为key1，是因为原始DataFrame的列df['key1']就叫这个名字。
2、如果我们一次传入多个数组，就会得到不同的结果：
通过两个键对数据进行了分组，得到的Series具有一个层次化索引（由唯一的键对组成）：
在上面这些示例中，分组键均为Series。实际上，分组键可以是任何长度适当的数组：
|
1
2
3
4
5
6
7
8
|
>>> states
=
np.array([
'Ohio'
,
'California'
,
'Ohio'
,
'Ohio'
])
>>> df[
'data1'
].groupby([states,years]).mean()
dtype: float64
|
3、此外，你还可以将列名（可以是字符串、数字或其他Python对象）用作分组将：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
>>> df.groupby(
'key1'
).mean()
data1 data2
key1
>>> df.groupby([
'key1'
,
'key2'
]).mean()
data1 data2
key1 key2
|
说明：在执行df.groupby('key1').mean()时，结果中没有key2列。这是因为df['key2']不是数值数据，所以被从结果中排除了。默认情况下，所有数值列都会被聚合，虽然有时可能会被过滤为一个子集。
无论你准备拿groupby做什么，都有可能会用到GroupBy的size方法，它可以返回一个含有分组大小的Series：
注意：分组键中的任何缺失值都会被排除在结果之外。
4、对分组进行迭代
GroupBy对象支持迭代，可以产生一组二元元组（由分组名和数据块组成）。看看下面这个简单的数据集：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
>>>
for
name,group
in
df.groupby(
'key1'
):
...
print
(name)
...
print
(group)
...
a
data1 data2 key1 key2
b
data1 data2 key1 key2
|
对于多重键的情况，元组的第一个元素将会是由键值组成的元组：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
>>>
for
(k1,k2),group
in
df.groupby([
'key1'
,
'key2'
]):
...
print
k1,k2
...
print
group
...
a one
data1 data2 key1 key2
a two
data1 data2 key1 key2
b one
data1 data2 key1 key2
b two
data1 data2 key1 key2
|
当然，你可以对这些数据片段做任何操作。有一个你可能会觉得有用的运算：将这些数据片段做成一个字典：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
>>> pieces
=
dict
(
list
(df.groupby(
'key1'
)))
>>> pieces[
'b'
]
data1 data2 key1 key2
>>> df.groupby(
'key1'
)
>>>
list
(df.groupby(
'key1'
))
[(
'a'
,data1 data2 key1 key2
|
groupby默认是在axis=0上进行分组的，通过设置也可以在其他任何轴上进行分组。那上面例子中的df来说，我们可以根据dtype对列进行分组：
5、选取一个或一组列
对于由DataFrame产生的GroupBy对象，如果用一个（单个字符串）或一组（字符串数组）列名对其进行索引，就能实现选取部分列进行聚合的目的，即：
|
1
2
3
4
5
6
|
>>> df.groupby(
'key1'
)[
'data1'
]
>>> df.groupby(
'key1'
)[
'data2'
]
>>> df.groupby(
'key1'
)[[
'data2'
]]
|
和以下代码是等效的：
|
1
2
3
4
5
6
|
>>> df[
'data1'
].groupby([df[
'key1'
]])
>>> df[[
'data2'
]].groupby([df[
'key1'
]])
>>> df[
'data2'
].groupby([df[
'key1'
]])
|
尤其对于大数据集，很可能只需要对部分列进行聚合。例如，在前面那个数据集中，如果只需计算data2列的平均值并以DataFrame形式得到结果，代码如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
>>> df.groupby([
'key1'
,
'key2'
])[[
'data2'
]].mean()
data2
key1 key2
>>> df.groupby([
'key1'
,
'key2'
])[
'data2'
].mean()
key1 key2
Name: data2,dtype: float64
|
这种索引操作所返回的对象是一个已分组的DataFrame（如果传入的是列表或数组）或已分组的Series（如果传入的是标量形式的单个列明）：
|
1
2
3
4
5
6
7
8
9
10
|
>>> s_grouped
=
df.groupby([
'key1'
,
'key2'
])[
'data2'
]
>>> s_grouped
>>> s_grouped.mean()
key1 key2
Name: data2,dtype: float64
|
6、通过字典或Series进行分组
除数组以外，分组信息还可以其他形式存在，来看一个DataFrame示例：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
... columns
=
[
'a'
,
'c'
,
'd'
,
'e'
],
... index
=
[
'Joe'
,
'Steve'
,
'Wes'
,
'Jim'
,
'Travis'
]
... )
>>> people
a b c d e
Joe
@H_404_103@0.306336
-
@H_404_103@0.139431
@H_404_103@ 0.210028
-
@H_404_103@1.489001
-
@H_404_103@0.172998
Steve
@H_404_103@0.998335
@H_404_103@0.494229
@H_404_103@0.337624
-
@H_404_103@1.222726
-
@H_404_103@0.402655
Wes
@H_404_103@1.415329
@H_404_103@0.450839
-
@H_404_103@1.052199
@H_404_103@0.731721
@H_404_103@0.317225
Jim
@H_404_103@0.550551
@H_404_103@3.201369
@H_404_103@0.669713
@H_404_103@0.725751
@H_404_103@0.577687
|
假设已知列的分组关系，并希望根据分组计算列的总计：
|
1
2
3
4
5
6
|
>>> mapping
=
{
'a'
:
'red'
,
'b'
:
'red'
,
'c'
:
'blue'
,
...
'd'
:
'blue'
,
'e'
:
'red'
,
'f'
:
'orange'
}
>>> mapping
{
'a'
:
'red'
,
'c'
:
'blue'
,
'b'
:
'red'
,
'e'
:
'red'
,
'd'
:
'blue'
,
'f'
:
'orange'
}
>>>
type
(mapping)
<
type
'dict'
>
|
现在，只需将这个字典传给groupby即可：
|
1
2
3
4
5
6
7
8
9
10
|
>>> by_column
>>> by_column.
sum
()
blue red
|
Series也有同样的功能，它可以被看做一个固定大小的映射。对于上面那个例子，如果用Series作为分组键，则pandas会检查Series以确保其索引跟分组轴是对齐的：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
>>> map_series
=
pd.Series(mapping)
>>> map_series
a red
b red
c blue
d blue
e red
f orange
dtype:
object
blue red
|
7、通过函数进行分组
相较于字典或Series，Python函数在定义分组映射关系时可以更有创意且更为抽象。任何被当做分组键的函数都会在各个索引值上被调用一次，其返回值就会被用作分组名称。
具体点说，以DataFrame为例，其索引值为人的名字。假设你希望根据人名的长度进行分组，虽然可以求取一个字符串长度数组，但其实仅仅传入len函数即可：
将函数跟数组、列表、字典、Series混合使用也不是问题，因为任何东西最终都会被转换为数组：
|
1
2
3
4
5
6
7
|
>>> key_list
=
[
'one'
,
'two'
]
>>> people.groupby([
len
,key_list]).
min
()
a b c d e
@H_404_103@3
one
@H_404_103@0.306336
-
@H_404_103@0.139431
@H_404_103@0.210028
-
@H_404_103@1.489001
-
@H_404_103@0.172998
two
@H_404_103@0.550551
@H_404_103@3.201369
@H_404_103@0.669713
@H_404_103@0.725751
@H_404_103@0.577687
|
8、根据索引级别分组
层次化索引数据集最方便的地方在于它能够根据索引级别进行聚合。要实现该目的，通过level关键字传入级别编号或名称即可：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
>>> columns
=
pd.MultiIndex.from_arrays([[
'US'
,
'US'
,
'JP'
,
'JP'
],
... [
@H_404_103@1
,
@H_404_103@3
,
@H_404_103@5
,
@H_404_103@1
,
@H_404_103@3
]],names
=
[
'cty'
,
'tenor'
])
>>> columns
MultiIndex
>>> hier_df
cty US JP
@H_404_103@0
-
@H_404_103@0.166600
@H_404_103@0.248159
-
@H_404_103@0.082408
-
@H_404_103@0.710841
-
@H_404_103@0.097131
@H_404_103@1
-
@H_404_103@1.762270
@H_404_103@0.687458
@H_404_103@1.235950
-
@H_404_103@1.407513
@H_404_103@1.304055
@H_404_103@2
@H_404_103@ 1.089944
@H_404_103@0.258175
-
@H_404_103@0.749688
-
@H_404_103@0.851948
@H_404_103@1.687768
@H_404_103@3
-
@H_404_103@0.378311
-
@H_404_103@0.078268
@H_404_103@0.247147
-
@H_404_103@0.018829
@H_404_103@0.744540
cty JP US
|
