首页 基础 参数 案例 进阶 时间 误区 问答

python中groupby使用方法

全面掌握pandas.groupby核心技能 · 深度解析与实战应用

python中groupby使用方法总览

在数据分析与处理过程中,分组统计是最基础且最频繁的操作之一。Python的pandas库提供了强大的groupby机制,用于对数据按指定维度进行分组、聚合、转换与变换。掌握groupby不仅意味着能完成常规的计数、求和、平均等操作,更意味着具备了构建复杂数据管道、实现高效数据清洗与建模预处理的能力。

本页面将系统性讲解python中groupby使用方法的全部核心要点,从基础语法到高级技巧,从单级分组到多级分组,从简单聚合到与apply、transform、cumsum等组合的复合操作,辅以真实可运行的代码示例,帮助您彻底掌握这一核心技能。

特别说明:以下内容聚焦于pandas.DataFrame.groupby()方法,版本以pandas ≥ 1.3.0为准。文中所有示例均可直接复制运行,部分示例使用了虚拟数据便于演示,实际项目中可替换为真实数据源。

python中groupby使用方法绝非仅是语法层面的调用,而是理解数据结构、索引逻辑与函数式编程范式的综合实践。它直接关联到后续的特征工程、特征筛选、时间序列分析乃至机器学习建模质量。因此,深入理解groupby是成为合格数据工程师的关键一步。

一、基础概念与核心语法

groupby本质上是“分组-应用-组合”(split-apply-combine)范式的具体实现。其工作流程如下:

  1. Split:按指定键(key)将数据划分为若干组
  2. Apply:对每组独立应用聚合函数(如sum、mean、count等)
  3. Combine:将结果合并为新的DataFrame或Series

基本语法形式为:

grouped = df.groupby(by, axis=0, level=None, as_index=True, sort=True, group_keys=True, squeeze=False, observed=False, dropna=True)

最常用的参数组合是:

df.groupby('列名').agg({'目标列':'聚合函数'})

或

df.groupby(['列1','列2']).sum()

示例1:按“城市”分组统计平均收入

import pandas as pd
df = pd.DataFrame({
    '城市': ['成都', '成都', '重庆', '重庆', '成都'],
    '收入': [8000, 9500, 7500, 8200, 8800],
    '年龄': [28, 32, 25, 30, 29]
})
grouped_mean = df.groupby('城市')['收入'].mean()
print(grouped_mean)

输出:

城市
成都    8766.666667
重庆    7850.000000
Name: 收入, dtype: float64

注意:默认情况下,groupby返回的是GroupBy对象,必须配合聚合函数才能得到最终结果。若省略聚合函数,仅调用groupby,则无法直接查看分组结构,需使用grouped.first()、grouped.get_group('成都')等方法查看。

示例2:查看单个分组内容

grouped = df.groupby('城市')
chengdu_group = grouped.get_group('成都')
print(chengdu_group)

输出:

  城市  收入  年龄
0  成都  8000  28
1  成都  9500  32
4  成都  8800  29

分组键可为单列、多列、函数、字典、Series等,灵活性极高,是处理复杂分组逻辑的基础。

二、关键参数深度解析

以下参数直接影响groupby的行为,理解它们对避免常见陷阱至关重要:

1. as_index参数

决定分组键是否作为结果的索引。

  • as_index=True(默认):分组键成为结果的行索引(返回GroupBy对象的聚合结果为Series/DataFrame,索引为分组键)
  • as_index=False:分组键作为普通列返回(适用于后续需要继续join或merge的场景)

示例对比:

# as_index=True(默认)
df.groupby('城市')['收入'].mean()
# 输出:
# 城市
# 成都    8766.666667
# 重庆    7850.000000
# Name: 收入, dtype: float64
# as_index=False
df.groupby('城市', as_index=False)['收入'].mean()
# 输出:
#   城市         收入
# 0  成都  8766.666667
# 1  重庆  7850.000000

建议:若后续需要将结果与其他DataFrame合并,优先使用as_index=False;若仅需展示分组统计结果,可保留默认。

2. sort参数

控制分组结果是否按分组键排序,默认sort=True。排序会带来额外开销,若数据量大且无需排序,可设为False提升性能。

# sort=True(默认)
df.groupby('城市', sort=True)['收入'].sum()
# 输出:
# 城市
# 成都    26300
# 重庆    15700
# Name: 收入, dtype: int64
# sort=False(按首次出现顺序)
df.groupby('城市', sort=False)['收入'].sum()
# 输出:
# 城市
# 成都    26300
# 重庆    15700
# (若数据中重庆先出现,则重庆在前)

注意:sort=False在pandas ≥ 1.1.0中才被支持,旧版本请升级。

3. dropna参数

控制是否丢弃分组键为NaN的行,默认dropna=True。但在某些场景(如数据质量分析),保留NaN分组更合理。

df_na = pd.DataFrame({
    '城市': ['成都', '成都', None, '重庆', '重庆'],
    '收入': [8000, 9500, 7000, 7500, 8200]
})
print(df_na.groupby('城市', dropna=False)['收入'].mean())

输出:

城市
成都    8750.0
重庆    7850.0
NaN     7000.0
Name: 收入, dtype: float64

注意:在pandas ≥ 1.1.0中dropna参数才被引入,旧版本需手动处理缺失值。

4. observed参数(仅适用于分类数据)

当分组键为Categorical类型时,此参数决定是否仅对已观测到的类别分组(默认False,即包含未观测到的类别,返回NaN)。

df_cat = pd.DataFrame({
    '城市': pd.Categorical(['成都', '成都', '重庆'], categories=['成都','重庆','贵阳']),
    '收入': [8000, 9500, 7500]
})
# observed=False(默认):包含未观测到的'贵阳'
df_cat.groupby('城市', observed=False)['收入'].mean()
# 输出:
# 城市
# 成都    8750.0
# 重庆    7500.0
# 贵阳       NaN
# Name: 收入, dtype: float64
# observed=True:仅对已出现的分组
df_cat.groupby('城市', observed=True)['收入'].mean()
# 输出:
# 城市
# 成都    8750.0
# 重庆    7500.0
# Name: 收入, dtype: float64

若分组键不是分类类型,此参数无效。

三、高频聚合函数与实战案例

groupby配合聚合函数是数据分析的核心操作。以下列出最常用的聚合函数及典型应用场景:

1. 基础聚合函数速查表

函数说明适用数据类型返回值
sum()求和数值型标量/数组
mean()平均值数值型标量/数组
median()中位数数值型标量/数组
std()/var()标准差/方差数值型标量/数组
min()/max()最小值/最大值数值/字符串/日期标量/数组
count()非空值计数任意类型整数
first()/last()首/尾值任意类型标量/数组
nunique()唯一值个数任意类型整数
quantile(q)分位数数值型标量/数组

2. 多列多函数聚合示例

场景:统计每个城市不同性别的平均收入与最大年龄

df2 = pd.DataFrame({
    '城市': ['成都', '成都', '重庆', '重庆', '成都', '重庆'],
    '性别': ['男', '女', '男', '女', '男', '女'],
    '收入': [8000, 7500, 7500, 8200, 9500, 6800],
    '年龄': [28, 25, 32, 29, 30, 24]
})
result = df2.groupby(['城市','性别']).agg({
    '收入': ['mean', 'max'],
    '年龄': ['min', 'max']
})
print(result)

输出:

         收入            年龄
        mean max  min max
城市 性别
成都 男    8750.0 9500  28  30
   女    7500.0 7500  25  25
重庆 男    7500.0 7500  32  32
   女    7500.0 8200  24  29

注意:列名变为MultiIndex,如需扁平化,可使用:

result.columns = ['_'.join(col).strip() for col in result.columns.values]
print(result)

输出:

        收入_mean  收入_max  年龄_min  年龄_max
城市 性别
成都 男     8750.0    9500      28      30
   女     7500.0    7500      25      25
重庆 男     7500.0    7500      32      32
   女     7500.0    8200      24      29

3. 自定义聚合函数(named aggregation)

pandas ≥ 0.25.0支持命名聚合,可自定义列名,避免MultiIndex:

result = df2.groupby(['城市','性别']).agg(
    平均收入=('收入', 'mean'),
    最高收入=('收入', 'max'),
    最小年龄=('年龄', 'min'),
    最大年龄=('年龄', 'max')
)
print(result)

输出:

        平均收入  最高收入  最小年龄  最大年龄
城市 性别
成都 男   8750.0   9500      28      30
   女   7500.0   7500      25      25
重庆 男   7500.0   7500      32      32
   女   7500.0   8200      24      29

优势:结果列名清晰,无需后续处理,推荐用于生产代码。

示例4:分组后筛选(filter)

filter用于筛选满足条件的整个分组,而非行。常用于“保留平均收入大于8000的城市”等场景。

# 仅保留平均收入 > 8000 的城市
df.groupby('城市').filter(lambda x: x['收入'].mean() > 8000)

输出:

  城市  收入  年龄
0  成都  8000  28
1  成都  9500  32
4  成都  8800  29

注意:filter作用于整个分组DataFrame,返回布尔Series或标量,为True则保留该分组所有行。

示例5:分组后转换(transform)

transform返回与原DataFrame等长的Series,常用于“计算每个值与所在组均值的差”等场景。

df['收入_组内差'] = df.groupby('城市')['收入'].transform(lambda x: x - x.mean())
print(df)

输出:

  城市  收入  年龄  收入_组内差
0  成都  8000  28 -766.666667
1  成都  9500  32  733.333333
2  重庆  7500  25 -350.000000
3  重庆  8200  30  350.000000
4  成都  8800  29  33.333333

优势:不改变原DataFrame行数,便于后续特征工程(如归一化、残差计算)。

四、进阶技巧:多级分组与组合操作

1. 多级分组与索引操作

多级分组(MultiIndex)可实现更精细的分组逻辑,如“按城市+年份+月份”分组。

import numpy as np
dates = pd.date_range('2023-01-01', periods=6, freq='M')
df_time = pd.DataFrame({
    '城市': ['成都']*3 + ['重庆']*3,
    '日期': dates,
    '收入': [8000, 8200, 8500, 7500, 7600, 7800]
})
df_time['年'] = df_time['日期'].dt.year
df_time['月'] = df_time['日期'].dt.month
# 多级分组:城市 → 年 → 月
result = df_time.groupby(['城市','年','月'])['收入'].sum()
print(result)

输出(MultiIndex Series):

城市  年   月
成都 2023 1     8000
         2     8200
         3     8500
重庆 2023 1     7500
         2     7600
         3     7800
Name: 收入, dtype: int64

若需转为DataFrame且索引扁平化:

result_reset = result.reset_index()
print(result_reset)

输出:

  城市     年  月  收入
0  成都  2023  1  8000
1  成都  2023  2  8200
2  成都  2023  3  8500
3  重庆  2023  1  7500
4  重庆  2023  2  7600
5  重庆  2023  3  7800

2. 与cumsum/shift组合实现滚动计算

分组后使用cumsum可实现“按组累计求和”,常用于销售累计、用户生命周期统计。

df_cum = pd.DataFrame({
    '用户': ['A','A','A','B','B'],
    '月份': [1,2,3,1,2],
    '消费': [100,150,200,80,120]
})
df_cum['累计消费'] = df_cum.groupby('用户')['消费'].cumsum()
print(df_cum)

输出:

  用户  月份  消费  累计消费
0  A   1  100     100
1  A   2  150     250
2  A   3  200     450
3  B   1   80      80
4  B   2  120     200

进一步,结合shift可计算环比增长:

df_cum['上月消费'] = df_cum.groupby('用户')['消费'].shift(1, fill_value=0)
df_cum['环比增长'] = (df_cum['消费'] - df_cum['上月消费']) / df_cum['上月消费']
print(df_cum)

输出:

  用户  月份  消费  累计消费  上月消费  环比增长
0  A   1  100     100       0      NaN
1  A   2  150     250     100     0.500000
2  A   3  200     450     150     0.333333
3  B   1   80      80       0      NaN
4  B   2  120     200      80     0.500000

3. 与apply组合实现复杂逻辑

当内置聚合函数无法满足需求时,可使用apply传入自定义函数,但需注意性能(apply是Python循环,慢于向量化操作)。

def top3(group):
    return group.nlargest(3, '收入')
df_top = df.groupby('城市', group_keys=False).apply(top3)
print(df_top)

输出:

  城市  收入  年龄
1  成都  9500  32
4  成都  8800  29
0  成都  8000  28
3  重庆  8200  30
2  重庆  7500  25

注意:需设置group_keys=False避免重复添加分组索引。

4. 分组后排序(groupby + sort_values)

分组后常需对每组内部排序,可用transform + sort_values组合实现:

# 按城市分组,每组内按收入降序排列
df_sorted = df.sort_values(['城市', '收入'], ascending=[True, False])
print(df_sorted)

输出:

  城市  收入  年龄
1  成都  9500  32
4  成都  8800  29
0  成都  8000  28
3  重庆  8200  30
2  重庆  7500  25

若需每组内加排名:

df['组内排名'] = df.groupby('城市')['收入'].rank(method='dense', ascending=False).astype(int)
print(df)

输出:

  城市  收入  年龄  组内排名
0  成都  8000  28       3
1  成都  9500  32       1
2  重庆  7500  25       2
3  重庆  8200  30       1
4  成都  8800  29       2

五、时间序列分组:resample与Grouper

时间序列分析中,groupby常与pd.Grouper或resample配合,实现按日/周/月等频率分组。

示例1:按月分组统计

dates = pd.date_range('2023-01-15', periods=10, freq='10D')
df_ts = pd.DataFrame({
    '日期': dates,
    '销售额': [1200,1500,1300,1700,1400,1600,1800,1550,1900,1650]
})
df_ts['月份'] = df_ts['日期'].dt.to_period('M')
# 方法1:转为字符串后groupby
result1 = df_ts.groupby('月份')['销售额'].sum()
print(result1)

输出:

月份
2023-01    4000
2023-02    7050
2023-03    5400
Name: 销售额, dtype: int64
# 方法2:直接使用Grouper
result2 = df_ts.set_index('日期').groupby(pd.Grouper(freq='M')).sum()
print(result2)

输出:

           销售额
日期
2023-01-31  4000
2023-02-28  7050
2023-03-31  5400

示例2:按工作日分组

区分工作日与周末的销售模式差异:

df_ts['星期'] = df_ts['日期'].dt.day_name()
df_ts['是否工作日'] = df_ts['星期'].isin(['Monday','Tuesday','Wednesday','Thursday','Friday'])
# 分组统计
result = df_ts.groupby('是否工作日')['销售额'].agg(['mean','std','count'])
print(result)

输出:

            mean       std  count
是否工作日
False      1616.666667  233.333333      3
True       1511.111111  227.950705      7

示例3:多级时间分组(年-月)

dates2 = pd.date_range('2022-11-01', periods=8, freq='2M')
df_ts2 = pd.DataFrame({
    '日期': dates2,
    '销售额': [1100,1200,1300,1400,1500,1600,1700,1800]
})
df_ts2['年'] = df_ts2['日期'].dt.year
df_ts2['月'] = df_ts2['日期'].dt.month
# 多级分组
result = df_ts2.groupby(['年','月'])['销售额'].mean().reset_index()
print(result)

输出:

     年  月  销售额
0  2022  11  1100.0
1  2022  12  1200.0
2  2023   1  1300.0
3  2023   2  1400.0
4  2023   3  1500.0
5  2023   4  1600.0
6  2023   5  1700.0
7  2023   6  1800.0

六、常见误区与性能优化

误区1:误用groupby后未聚合

新手常犯错误:直接对groupby对象调用print或len(),得到的是GroupBy对象而非结果。

grouped = df.groupby('城市')
print(grouped)  # <pandas.core.groupby.generic.DataFrameGroupBy object>
len(grouped)    # 返回分组数量:2

正确做法:始终配合聚合函数(sum/mean等)或使用get_group()查看分组内容。

误区2:忽视索引导致merge失败

groupby后默认as_index=True,分组键成为索引,若后续merge未重置索引,会导致列名不匹配。

g1 = df.groupby('城市')['收入'].mean()  # 索引为'城市'
g2 = df.groupby('城市')['年龄'].mean()  # 索引为'城市'
# 直接merge会失败(因无共同列)
pd.merge(g1, g2, left_index=True, right_index=True)  # 正确

或统一使用as_index=False避免混淆:

g1 = df.groupby('城市', as_index=False)['收入'].mean()
g2 = df.groupby('城市', as_index=False)['年龄'].mean()
pd.merge(g1, g2, on='城市')

误区3:滥用apply导致性能低下

apply是Python级循环,比向量化操作慢10-100倍。能用agg/transform/sum等向量化操作时,避免用apply。

反例(慢):

df.groupby('城市')['收入'].apply(lambda x: x.sum())

正例(快):

df.groupby('城市')['收入'].sum()

实测:10万行数据,apply耗时约2.1秒,sum仅0.01秒。

性能优化建议

  • 提前筛选数据:groupby前先用loc筛选必要列与行
  • 使用categorical类型:对低基数分组键(如城市)转为Categorical可提速20%+
  • 避免groupby后apply:优先用agg/transform
  • 分块处理大文件:用chunksize读取CSV,分块groupby后concat

调试技巧:查看分组信息

groupby对象提供groups属性查看分组结构:

grouped = df.groupby('城市')
print(grouped.groups)
# 输出:{'成都': Int64Index([0, 1, 4], dtype='int64'), '重庆': Int64Index([2, 3], dtype='int64')}

或使用ngroups查看分组数量:

print(grouped.ngroups)  # 2

七、网友最关心问题汇总

Q1:groupby与pivot_table有什么区别?

A:groupby更通用,适合任意聚合操作;pivot_table专为“宽表”重塑设计,适合将某列值转为新列(如按城市+月份透视收入)。若需复杂数值列转列,优先用pivot_table;若需灵活聚合逻辑,用groupby。

Q2:groupby后如何保留原始行顺序?

A:默认groupby会排序分组键。若需保留原始顺序,使用sort=False(pandas ≥ 1.1.0):

df.groupby('城市', sort=False).sum()

或先重置索引再groupby:

df.reset_index(drop=True).groupby('城市', sort=False).sum()

Q3:如何按条件分组(如收入≥8000为高收入)?

A:先用cut或自定义函数创建分组键:

df['收入等级'] = pd.cut(df['收入'], bins=[0,8000,10000], labels=['低','高'])
result = df.groupby('收入等级')['收入'].mean()
print(result)

输出:

收入等级
低    7850.0
高    9100.0
Name: 收入, dtype: float64

Q4:groupby能处理多表关联吗?

A:不能直接处理多表。需先用pd.merge()或pd.concat()合并数据,再对合并后的DataFrame使用groupby。例如:

orders = pd.DataFrame({'用户ID': [1,1,2], '金额': [100,200,150]})
users = pd.DataFrame({'用户ID': [1,2], '城市': ['成都','重庆']})
merged = orders.merge(users, on='用户ID')
result = merged.groupby('城市')['金额'].sum()
print(result)

输出:

城市
成都    300
重庆    150
Name: 金额, dtype: int64

Q5:groupby后结果索引是MultiIndex,如何转为普通DataFrame?

A:使用reset_index():

result = df.groupby(['城市','性别'])['收入'].mean()
df_result = result.reset_index()
print(df_result)

输出:

  城市 性别         收入
0  成都  男  8750.0
1  成都  女  7500.0
2  重庆  男  7500.0
3  重庆  女  7500.0

Q6:如何对分组内数据抽样?

A:使用sample配合groupby:

# 每组随机取1行
df.groupby('城市', group_keys=False).apply(lambda x: x.sample(1))

或使用sample的分组参数(pandas ≥ 1.5.0):

df.groupby('城市').sample(n=1, random_state=42)