pandas提供了一个灵活高效的groupby功能，它使你能以一种自然的方式对数据集进行切片、切块、摘要等操作。根据一个或多个键（可以是函数、数组或DataFrame列名）拆分pandas对象。计算分组摘要统计，如计数、平均值、标准差，或用户自定义函数。对DataFrame的列应用各种各样的函数。应用组内转换或其他运算，如规格化、线性回归、排名或选取子集等。计算透视表或交叉表。执行分位数分析以及其他分组分析。

DataFrame.groupby(by=None, axis=0, level=None, as_index=True, sort=True, group_keys=True, squeeze=False,**kwargs)[source]

Group series using mapper (dict or key function, apply given function to group, return result as series) or by a series of columns.

Parameters:

by : mapping, function, str, or iterable

Used to determine the groups for the groupby. If by is a function, it’s called on each value of the object’s index. If a dict or Series is passed, the Series or dict VALUES will be used to determine the groups (the Series’ values are first aligned; see .align()method). If an ndarray is passed, the values are used as-is determine the groups. A str or list of strs may be passed to group by the columns in self

axis : int, default 0

level : int, level name, or sequence of such, default None

If the axis is a MultiIndex (hierarchical), group by a particular level or levels

as_index : boolean, default True

For aggregated output, return object with group labels as the index. Only relevant for DataFrame input. as_index=False is effectively “SQL-style” grouped output

sort : boolean, default True

Sort group keys. Get better performance by turning this off. Note this does not influence the order of observations within each group. groupby preserves the order of rows within each group.

group_keys : boolean, default True

When calling apply, add group keys to index to identify pieces

squeeze : boolean, default False

reduce the dimensionality of the return type if possible, otherwise return a consistent type
Returns:

GroupBy object

Examples

DataFrame results

>>> data.groupby(func, axis=0).mean()
>>> data.groupby(['col1', 'col2'])['col3'].mean()

DataFrame with hierarchical index

>>> data.groupby(['col1', 'col2']).mean()

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

转载。原文：http://blog.csdn.net/leonis_v/article/details/51832916

pandas.DataFrame.groupby相关推荐

  1. Pandas DataFrame GroupBy.Apply

    https://pandas.pydata.org/docs/reference/api/pandas.core.groupby.GroupBy.apply.html?highlight=apply# ...

  2. python的dataframe的groupby_python pandas.DataFrame.groupby()方法详解

    文章目录 DataFrame.groupby()概览应用举例 概览内容参考自官方文档详情应用参考文档 DataFrame.groupby()概览 DataFrame.groupby(self, by= ...

  3. 【debug】Python pandas dataframe.groupby（）.sum不显示结果，只显示groupby中的条件列

    简单介绍 在使用pandas的groupby功能时,输出的结果只显示了用于筛选的groupby中的条件列,而不显示最后sum加总的结果 import pandas as pddf.columns = ...

  4. Pandas DataFrame: groupby agg的使用

    @创建于:2022.07.01 @修改于:2022.07.01,2022.07.09 文章目录 1.构建样例数据(无Null值和有Null值) 2.agg常见聚合函数 3.agg匿名聚合函数 4.ag ...

  5. 分组统计 - DataFrame.groupby() 所见的各种用法 - Python代码

    目录 所见 1 :日常用法 所见 2 :解决groupby.sum() 后层级索引levels上移的问题 所见 3 :解决groupby.apply() 后层级索引levels上移的问题 所见 4 : ...

  6. 熊猫DataFrame groupby（）函数

    1.熊猫groupby()函数 (1. Pandas groupby() function) Pandas DataFrame groupby() function is used to group ...

  7. python boxplot用法_python pandas DataFrame.boxplot用法及代码示例

    从DataFrame列制作箱形图. 从DataFrame列制作box-and-whisker图,可以选择按其他一些列进行分组.箱形图是一种通过四分位数以图形方式描绘数字数据组的方法.该框从数据的Q1四 ...

  8. pandas使用groupby函数计算dataframe数据中每个分组的N个数值的指数权重移动（滚动）平均、例如，计算某公司的多个店铺每N天（5天）的滚动销售额指数权重移动（滚动）平均

    pandas使用groupby函数计算dataframe数据中每个分组的N个数值的指数权重移动(滚动)平均(Exponential Moving Average).例如,计算某公司的多个店铺每N天(5 ...

  9. pandas使用groupby函数计算dataframe数据中每个分组的N个数值的滚动最大值(rolling max)、例如，计算某公司的多个店铺每N天（5天）的滚动销售额最大值

    pandas使用groupby函数计算dataframe数据中每个分组的N个数值的滚动最大值(rolling max).例如,计算某公司的多个店铺每N天(5天)的滚动销售额最大值 目录

最新文章

  1. 数据库大型应用解决方案总结(转)
  2. GO语言实现RSA 加密和解密的实现
  3. 攻防世界 Web进阶(一)
  4. spring 学习总结
  5. 好书推荐之《活着》 隐私策略（Privacy policy）
  6. Linux 练习题-3文件与磁盘 问答
  7. SpringCloud Feign注解导入失败
  8. LeetCode OJ 160. Intersection of Two Linked Lists
  9. 【Win32 API学习】模拟键盘输入和鼠标输入
  10. 阿里矢量图库 当前页全选
  11. 5年500台达芬奇手术，和睦家实现技术升级
  12. 1.0 Android基础入门教程
  13. Actor-Critic：强化学习中的参与者-评价者算法简介
  14. Gym - 101177K Kiwis vs Kangaroos 水题手动打表
  15. 开放式耳机新巅峰！南卡OE Pro兼备澎湃音质、舒适佩戴、创新设计
  16. 感动世界的50首歌和他们背后的故事3
  17. 我的博客也开通了，誓要戒骄，戒躁，每天学习，每天总结
  18. 好分数一个等第是什么意思_DPI是什么意思 鼠标DPI越高越好吗？
  19. python从入门到实践19章答案
  20. windows NTFS文件系统手动数据恢复

热门文章

  1. Qt新建项目No valid kits found解决思路
  2. mySQL Slow Query Log Rotation(慢查询日志轮循设置)
  3. eclipse运行 Maven Test命令时控制台输出乱码的解决办法
  4. 4月份阿里云ECS和VPC升级公告
  5. 工程路径网站图片路径的问题 绝对路径
  6. 录制元素基于smartgwt框架项目如何开展自动化（一）
  7. 如何设置VSS源代码管理工具使用KDiff3
  8. GO小知识之实例演示 json 如何转化为 map 和 struct
  9. 《C语言程序设计：问题与求解方法》——3.8节不同类型数据之间的类型转换
  10. CentOS卸载Apache Mysql 和php