轉自 ： https://blog.csdn.net/Leonis_v/article/details/51832916
pandas提供了一個靈活高效的groupby功能，它使你能以一種自然的方式對數據集進行切片、切塊、摘要等操作。根據一個或多個鍵（可以是函數、數組或DataFrame列名）拆分pandas對象。計算分組摘要統計，如計數、平均值、標准差，或用戶自定義函數。對DataFrame的列應用各種各樣的函數。應用組內轉換或其他運算，如規格化、線性回歸、排名或選取子集等。計算透視表或交叉表。執行分位數分析以及其他分組分析。
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'
,
'b'
,
'a'
],
...
'key2'
:[
'one'
,
'two'
,
'one'
,
'two'
,
'one'
],
...
'data1'
:np.random.randn(
5
),
...
'data2'
:np.random.randn(
5
)})
>>> df
data1 data2 key1 key2
0
-
0.410673
0.519378
a one
1
-
2.120793
0.199074
a two
2
0.642216
-
0.143671
b one
3
0.975133
-
0.592994
b two
4
-
1.017495
-
0.530459
a one
|
假設你想要按key1進行分組，並計算data1列的平均值，我們可以訪問data1，並根據key1調用groupby：
|
1
2
3
|
>>> grouped
=
df[
'data1'
].groupby(df[
'key1'
])
>>> grouped
<pandas.core.groupby.SeriesGroupBy
object
at
0x04120D70
>
|
變量grouped是一個GroupBy對象，它實際上還沒有進行任何計算，只是含有一些有關分組鍵df['key1']的中間數據而已，然后我們可以調用GroupBy的mean方法來計算分組平均值：
|
1
2
3
4
5
|
>>> grouped.mean()
key1
a
-
1.182987
b
0.808674
dtype: float64
|
說明：數據（Series）根據分組鍵進行了聚合，產生了一個新的Series，其索引為key1列中的唯一值。之所以結果中索引的名稱為key1，是因為原始DataFrame的列df['key1']就叫這個名字。
2、如果我們一次傳入多個數組，就會得到不同的結果：
|
1
2
3
4
5
6
7
8
|
>>> means
=
df[
'data1'
].groupby([df[
'key1'
], df[
'key2'
]]).mean()
>>> means
key1 key2
a one
-
0.714084
two
-
2.120793
b one
0.642216
two
0.975133
dtype: float64
|
通過兩個鍵對數據進行了分組，得到的Series具有一個層次化索引（由唯一的鍵對組成）：
|
1
2
3
4
5
|
>>> means.unstack()
key2 one two
key1
a
-
0.714084
-
2.120793
b
0.642216
0.975133
|
在上面這些示例中，分組鍵均為Series。實際上，分組鍵可以是任何長度適當的數組：
|
1
2
3
4
5
6
7
8
|
>>> states
=
np.array([
'Ohio'
,
'California'
,
'California'
,
'Ohio'
,
'Ohio'
])
>>> years
=
np.array([
2005
,
2005
,
2006
,
2005
,
2006
])
>>> df[
'data1'
].groupby([states, years]).mean()
California
2005
-
2.120793
2006
0.642216
Ohio
2005
0.282230
2006
-
1.017495
dtype: float64
|
3、此外，你還可以將列名（可以是字符串、數字或其他Python對象）用作分組將：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
>>> df.groupby(
'key1'
).mean()
data1 data2
key1
a
-
1.182987
0.062665
b
0.808674
-
0.368333
>>> df.groupby([
'key1'
,
'key2'
]).mean()
data1 data2
key1 key2
a one
-
0.714084
-
0.005540
two
-
2.120793
0.199074
b one
0.642216
-
0.143671
two
0.975133
-
0.592994
|
說明：在執行df.groupby('key1').mean()時，結果中沒有key2列。這是因為df['key2']不是數值數據，所以被從結果中排除了。默認情況下，所有數值列都會被聚合，雖然有時可能會被過濾為一個子集。
無論你准備拿groupby做什么，都有可能會用到GroupBy的size方法，它可以返回一個含有分組大小的Series：
|
1
2
3
4
5
6
7
|
>>> df.groupby([
'key1'
,
'key2'
]).size()
key1 key2
a one
2
two
1
b one
1
two
1
dtype: int64
|
注意：分組鍵中的任何缺失值都會被排除在結果之外。
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
0
-
0.410673
0.519378
a one
1
-
2.120793
0.199074
a two
4
-
1.017495
-
0.530459
a one
b
data1 data2 key1 key2
2
0.642216
-
0.143671
b one
3
0.975133
-
0.592994
b two
|
對於多重鍵的情況，元組的第一個元素將會是由鍵值組成的元組：
|
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
0
-
0.410673
0.519378
a one
4
-
1.017495
-
0.530459
a one
a two
data1 data2 key1 key2
1
-
2.120793
0.199074
a two
b one
data1 data2 key1 key2
2
0.642216
-
0.143671
b one
b two
data1 data2 key1 key2
3
0.975133
-
0.592994
b two
|
當然，你可以對這些數據片段做任何操作。有一個你可能會覺得有用的運算：將這些數據片段做成一個字典：
|
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
2
0.642216
-
0.143671
b one
3
0.975133
-
0.592994
b two
>>> df.groupby(
'key1'
)
<pandas.core.groupby.DataFrameGroupBy
object
at
0x0413AE30
>
>>>
list
(df.groupby(
'key1'
))
[(
'a'
, data1 data2 key1 key2
0
-
0.410673
0.519378
a one
1
-
2.120793
0.199074
a two
4
-
1.017495
-
0.530459
a one), (
'b'
, data1 data2 key1 key2
2
0.642216
-
0.143671
b one
3
0.975133
-
0.592994
b two)]
|
groupby默認是在axis=0上進行分組的，通過設置也可以在其他任何軸上進行分組。那上面例子中的df來說，我們可以根據dtype對列進行分組：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
>>> df.dtypes
data1 float64
data2 float64
key1
object
key2
object
dtype:
object
>>> grouped
=
df.groupby(df.dtypes, axis
=
1
)
>>>
dict
(
list
(grouped))
{dtype(
'O'
): key1 key2
0
a one
1
a two
2
b one
3
b two
4
a one, dtype(
'float64'
): data1 data2
0
-
0.410673
0.519378
1
-
2.120793
0.199074
2
0.642216
-
0.143671
3
0.975133
-
0.592994
4
-
1.017495
-
0.530459
}
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
>>> grouped
<pandas.core.groupby.DataFrameGroupBy
object
at
0x041288F0
>
>>>
list
(grouped)
[(dtype(
'float64'
), data1 data2
0
-
0.410673
0.519378
1
-
2.120793
0.199074
2
0.642216
-
0.143671
3
0.975133
-
0.592994
4
-
1.017495
-
0.530459
), (dtype(
'O'
), key1 key2
0
a one
1
a two
2
b one
3
b two
4
a one)]
|
5、選取一個或一組列
對於由DataFrame產生的GroupBy對象，如果用一個（單個字符串）或一組（字符串數組）列名對其進行索引，就能實現選取部分列進行聚合的目的，即：
|
1
2
3
4
5
6
|
>>> df.groupby(
'key1'
)[
'data1'
]
<pandas.core.groupby.SeriesGroupBy
object
at
0x06615FD0
>
>>> df.groupby(
'key1'
)[
'data2'
]
<pandas.core.groupby.SeriesGroupBy
object
at
0x06615CB0
>
>>> df.groupby(
'key1'
)[[
'data2'
]]
<pandas.core.groupby.DataFrameGroupBy
object
at
0x06615F10
>
|
和以下代碼是等效的：
|
1
2
3
4
5
6
|
>>> df[
'data1'
].groupby([df[
'key1'
]])
<pandas.core.groupby.SeriesGroupBy
object
at
0x06615FD0
>
>>> df[[
'data2'
]].groupby([df[
'key1'
]])
<pandas.core.groupby.DataFrameGroupBy
object
at
0x06615F10
>
>>> df[
'data2'
].groupby([df[
'key1'
]])
<pandas.core.groupby.SeriesGroupBy
object
at
0x06615E30
>
|
尤其對於大數據集，很可能只需要對部分列進行聚合。例如，在前面那個數據集中，如果只需計算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
a one
-
0.005540
two
0.199074
b one
-
0.143671
two
-
0.592994
>>> df.groupby([
'key1'
,
'key2'
])[
'data2'
].mean()
key1 key2
a one
-
0.005540
two
0.199074
b one
-
0.143671
two
-
0.592994
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
<pandas.core.groupby.SeriesGroupBy
object
at
0x06615B10
>
>>> s_grouped.mean()
key1 key2
a one
-
0.005540
two
0.199074
b one
-
0.143671
two
-
0.592994
Name: data2, dtype: float64
|
6、通過字典或Series進行分組
除數組以外，分組信息還可以其他形式存在，來看一個DataFrame示例：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
>>> people
=
pd.DataFrame(np.random.randn(
5
,
5
),
... columns
=
[
'a'
,
'b'
,
'c'
,
'd'
,
'e'
],
... index
=
[
'Joe'
,
'Steve'
,
'Wes'
,
'Jim'
,
'Travis'
]
... )
>>> people
a b c d e
Joe
0.306336
-
0.139431
0.210028
-
1.489001
-
0.172998
Steve
0.998335
0.494229
0.337624
-
1.222726
-
0.402655
Wes
1.415329
0.450839
-
1.052199
0.731721
0.317225
Jim
0.550551
3.201369
0.669713
0.725751
0.577687
Travis
-
2.013278
-
2.010304
0.117713
-
0.545000
-
1.228323
>>> people.ix[
2
:
3
, [
'b'
,
'c'
]]
=
np.nan
|
假設已知列的分組關系，並希望根據分組計算列的總計：
|
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
=
people.groupby(mapping, axis
=
1
)
>>> by_column
<pandas.core.groupby.DataFrameGroupBy
object
at
0x066150F0
>
>>> by_column.
sum
()
blue red
Joe
-
1.278973
-
0.006092
Steve
-
0.885102
1.089908
Wes
0.731721
1.732554
Jim
1.395465
4.329606
Travis
-
0.427287
-
5.251905
|
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
>>> people.groupby(map_series, axis
=
1
).count()
blue red
Joe
2
3
Steve
2
3
Wes
1
2
Jim
2
3
Travis
2
3
|
7、通過函數進行分組
相較於字典或Series，Python函數在定義分組映射關系時可以更有創意且更為抽象。任何被當做分組鍵的函數都會在各個索引值上被調用一次，其返回值就會被用作分組名稱。
具體點說，以DataFrame為例，其索引值為人的名字。假設你希望根據人名的長度進行分組，雖然可以求取一個字符串長度數組，但其實僅僅傳入len函數即可：
|
1
2
3
4
5
|
>> people.groupby(
len
).
sum
()
a b c d e
3
2.272216
3.061938
0.879741
-
0.031529
0.721914
5
0.998335
0.494229
0.337624
-
1.222726
-
0.402655
6
-
2.013278
-
2.010304
0.117713
-
0.545000
-
1.228323
|
將函數跟數組、列表、字典、Series混合使用也不是問題，因為任何東西最終都會被轉換為數組：
|
1
2
3
4
5
6
7
|
>>> key_list
=
[
'one'
,
'one'
,
'one'
,
'two'
,
'two'
]
>>> people.groupby([
len
, key_list]).
min
()
a b c d e
3
one
0.306336
-
0.139431
0.210028
-
1.489001
-
0.172998
two
0.550551
3.201369
0.669713
0.725751
0.577687
5
one
0.998335
0.494229
0.337624
-
1.222726
-
0.402655
6
two
-
2.013278
-
2.010304
0.117713
-
0.545000
-
1.228323
|
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'
,
'US'
,
'JP'
,
'JP'
],
... [
1
,
3
,
5
,
1
,
3
]], names
=
[
'cty'
,
'tenor'
])
>>> columns
MultiIndex
[US
1
,
3
,
5
, JP
1
,
3
]
>>> hier_df
=
pd.DataFrame(np.random.randn(
4
,
5
), columns
=
columns)
>>> hier_df
cty US JP
tenor
1
3
5
1
3
0
-
0.166600
0.248159
-
0.082408
-
0.710841
-
0.097131
1
-
1.762270
0.687458
1.235950
-
1.407513
1.304055
2
1.089944
0.258175
-
0.749688
-
0.851948
1.687768
3
-
0.378311
-
0.078268
0.247147
-
0.018829
0.744540
>>> hier_df.groupby(level
=
'cty'
, axis
=
1
).count()
cty JP US
0
2
3
1
2
3
2
2
3
3
2
3
|