Pandas分组聚合：groupby与agg的两种写法对比-代码聚汇网

Pandas分组聚合：groupby与agg的两种写法对比

吴佳晗

1. 理解groupby+agg的基本概念

在Pandas数据分析中，groupby和agg是两个经常配合使用的核心方法。它们共同构成了数据分组聚合的完整流程，这也是数据分析中最常见的操作模式之一。

groupby操作的本质是将DataFrame按照指定的键（可以是列名、函数或数组）进行分组，生成一个GroupBy对象。这个对象本身并不存储数据，而是存储了如何分组的信息。只有当对这个对象应用聚合函数（如sum、mean等）时，实际的计算才会发生。

agg（aggregate的缩写）则是应用于GroupBy对象的聚合方法，它允许我们对每个分组应用一个或多个聚合函数。agg的强大之处在于它的灵活性 - 我们可以同时对不同的列应用不同的聚合函数，也可以对同一列应用多个聚合函数。

2. 两种常见写法的语法对比

2.1 链式调用写法

第一种也是最直观的写法是链式调用（Method Chaining），即直接在groupby()后接agg()：

python复制df.groupby('分组列').agg({'聚合列':'聚合函数'})

这种写法的特点是：

语法简洁，符合从左到右的阅读习惯
一次完成分组和聚合两个操作
适合简单的聚合场景

例如，我们有一个销售数据表，想按产品类别统计销售额总和：

python复制sales.groupby('category').agg({'revenue':'sum'})

2.2 分步调用写法

第二种写法是将groupby和agg分开调用：

python复制grouped = df.groupby('分组列')
result = grouped.agg({'聚合列':'聚合函数'})

这种写法的特点是：

更清晰的代码结构，便于调试
中间GroupBy对象可以重复使用
适合复杂的多步聚合操作

同样的销售数据统计可以写成：

python复制grouped = sales.groupby('category')
revenue_sum = grouped.agg({'revenue':'sum'})

3. 两种写法的性能差异与适用场景

3.1 性能对比

在大多数情况下，两种写法在性能上没有显著差异。Pandas内部会对这两种写法进行相同的优化处理。但在一些特殊场景下：

简单聚合：链式写法可能略微快一点，因为减少了中间变量的创建
复杂聚合：分步写法可能更优，因为避免了重复计算

3.2 适用场景分析

链式调用更适合：

简单的单次聚合操作
交互式数据分析（如Jupyter Notebook）
需要保持代码简洁的场景

分步调用更适合：

需要多次使用同一个GroupBy对象的场景
复杂的多步聚合流程
需要调试中间结果的场景
代码可读性要求高的项目

4. 高级用法与注意事项

4.1 多列聚合与自定义函数

两种写法都支持对多列应用多种聚合函数：

python复制# 链式写法
df.groupby('group_col').agg({
    'col1': ['sum', 'mean'],
    'col2': ['max', 'min']
})

# 分步写法
grouped = df.groupby('group_col')
result = grouped.agg({
    'col1': ['sum', 'mean'],
    'col2': ['max', 'min']
})

还可以使用自定义聚合函数：

python复制def my_agg(x):
    return x.max() - x.min()

df.groupby('group_col').agg({'value_col': my_agg})

4.2 处理MultiIndex结果

聚合操作后经常会得到MultiIndex的列。两种写法处理方式相同：

python复制result = df.groupby('group_col').agg({
    'col1': ['sum', 'mean'],
    'col2': ['max', 'min']
})

# 访问特定聚合结果
result[('col1', 'sum')]

4.3 常见问题与解决方案

列名冲突问题：
- 当对同一列应用多个聚合函数时，结果列名会变成MultiIndex
- 可以使用result.columns = ['_'.join(col) for col in result.columns.values]展平列名
内存消耗问题：
- 对于大数据集，分步写法可能更节省内存，因为可以及时释放中间变量
- 考虑使用dtype参数指定数据类型减少内存占用
性能优化技巧：
- 对于数值列，先使用pd.to_numeric()转换类型
- 对于分类数据，先转换为category类型
- 考虑使用engine='numba'参数加速（Pandas 1.0+）

5. 实际案例分析

让我们通过一个完整的销售数据分析案例来比较两种写法：

python复制import pandas as pd
import numpy as np

# 创建示例数据
np.random.seed(42)
dates = pd.date_range('20230101', periods=100)
data = {
    'date': np.random.choice(dates, 500),
    'product': np.random.choice(['A', 'B', 'C'], 500),
    'region': np.random.choice(['East', 'West'], 500),
    'sales': np.random.randint(100, 1000, 500),
    'cost': np.random.randint(50, 500, 500)
}
df = pd.DataFrame(data)
df['profit'] = df['sales'] - df['cost']

# 链式写法 - 按产品和地区统计销售和利润的总和与平均值
result1 = (df.groupby(['product', 'region'])
           .agg({
               'sales': ['sum', 'mean'],
               'profit': ['sum', 'mean']
           })
           .round(2))

# 分步写法 - 同样的统计
grouped = df.groupby(['product', 'region'])
result2 = grouped.agg({
    'sales': ['sum', 'mean'],
    'profit': ['sum', 'mean']
}).round(2)

# 验证结果是否相同
print(result1.equals(result2))  # 输出True

这个案例展示了：

两种写法可以得到完全相同的结果
链式写法更紧凑，适合简单分析
分步写法更清晰，适合复杂分析
两种写法都支持多列多函数的聚合

6. 深入理解GroupBy对象

要真正掌握这两种写法，需要理解GroupBy对象的特性：

GroupBy对象是惰性求值的：
- 仅当调用聚合方法时才会实际计算
- 这使得Pandas可以进行优化

GroupBy对象支持迭代：

python复制for name, group in df.groupby('product'):
    print(f"Product: {name}")
    print(group.head())

GroupBy对象有多个聚合方法：
- agg(): 最通用的聚合方法
- sum(), mean()等: 快捷方法
- apply(): 更灵活的自定义操作
- transform(): 返回与原始数据相同形状的结果

7. 性能优化实践

对于大数据集，性能优化尤为重要：

使用更高效的数据类型：

python复制df['category_col'] = df['category_col'].astype('category')

只选择需要的列：

python复制df[['group_col', 'agg_col']].groupby('group_col').agg('sum')

使用as_index=False避免不必要的索引操作：

python复制df.groupby('group_col', as_index=False).agg('sum')

考虑使用Dask或Modin处理超大数据集

8. 与其他Pandas方法的结合

groupby+agg可以与其他Pandas方法无缝结合：

与query()结合：

python复制(df.query('sales > 500')
   .groupby('product')
   .agg({'profit':'mean'}))

与sort_values()结合：

python复制(df.groupby('product')
   .agg({'sales':'sum'})
   .sort_values('sales', ascending=False))

与assign()结合：

python复制(df.groupby('product')
   .agg({'sales':'sum'})
   .assign(sales_percent=lambda x: x/x.sum()))

9. 实际项目中的选择建议

根据多年数据分析经验，我建议：

在Jupyter Notebook中进行探索性分析时：
- 优先使用链式写法，保持代码简洁
- 复杂的中间步骤可以拆分成多个cell
在生产代码或脚本中：
- 考虑使用分步写法，提高可读性和可维护性
- 为中间GroupBy对象使用有意义的变量名
团队协作项目：
- 保持风格一致，要么都用链式，要么都用分步
- 添加必要的注释说明复杂的聚合逻辑
性能关键型应用：
- 两种写法都可以，重点优化数据预处理
- 使用%timeit测试两种写法的实际性能差异

10. 扩展知识：agg与apply的区别

虽然本文重点是比较groupby+agg的两种写法，但有必要简单说明agg与apply的区别：

agg()：
- 专为聚合设计
- 每个分组产生一个标量值
- 支持同时对多列应用不同函数
apply()：
- 更通用的操作
- 每个分组可以返回任意形状的结果
- 灵活性更高但性能通常较低

例如，计算每个产品的销售排名：

python复制# 使用apply
(df.groupby('product')['sales']
   .apply(lambda x: x.rank(ascending=False)))

这种操作无法用agg完成，因为agg只能返回聚合结果。