python pandas groupby


轉自 : 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


免責聲明!

本站轉載的文章為個人學習借鑒使用,本站對版權不負任何法律責任。如果侵犯了您的隱私權益,請聯系本站郵箱yoyou2525@163.com刪除。



 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM