使用pandas GroupBy.agg()对同一列进行多次聚合

Question

是否有 pandas 内置方法可以将两个不同的聚合函数

f1, f2

应用于同一列

df["returns"]

，而无需多次调用

agg()

？

示例数据框：

import pandas as pd
import datetime as dt
import numpy as np

pd.np.random.seed(0)
df = pd.DataFrame({
         "date"    :  [dt.date(2012, x, 1) for x in range(1, 11)], 
         "returns" :  0.05 * np.random.randn(10), 
         "dummy"   :  np.repeat(1, 10)
}) 

语法上错误但直观上正确的方法是：

# Assume `f1` and `f2` are defined for aggregating.
df.groupby("dummy").agg({"returns": f1, "returns": f2})

显然，Python 不允许重复的键。还有其他方式来表达

agg()

的输入吗？也许元组列表

[(column, function)]

会更好，以允许将多个函数应用于同一列？但是

agg()

好像只接受字典。

除了定义一个只应用其中两个函数的辅助函数之外，还有解决方法吗？ （无论如何，这如何与聚合一起使用？）

Answer 1

截至 2022 年 6 月 20 日，以下是公认的聚合做法：

df.groupby('dummy').agg(
    Mean=('returns', np.mean),
    Sum=('returns', np.sum))

请参阅此答案了解更多信息。

---

首屏包含

pandas

的历史版本。

您可以简单地将函数作为列表传递：

In [20]: df.groupby("dummy").agg({"returns": [np.mean, np.sum]})
Out[20]:         
           mean       sum
dummy                    
1      0.036901  0.369012

或作为字典：

In [21]: df.groupby('dummy').agg({'returns':
                                  {'Mean': np.mean, 'Sum': np.sum}})
Out[21]: 
        returns          
           Mean       Sum
dummy                    
1      0.036901  0.369012

Answer 2

TLDR； Pandas

groupby.agg

有一个新的、更简单的语法，用于指定 (1) 多列上的聚合，以及 (2) 列上的多个聚合。因此，要对 pandas >= 0.25 执行此操作，请使用

df.groupby('dummy').agg(Mean=('returns', 'mean'), Sum=('returns', 'sum'))

           Mean       Sum
dummy                    
1      0.036901  0.369012

或

df.groupby('dummy')['returns'].agg(Mean='mean', Sum='sum')

           Mean       Sum
dummy                    
1      0.036901  0.369012

---

Pandas >= 0.25：命名聚合

Pandas 改变了

GroupBy.agg

的行为，转而采用更直观的语法来指定命名聚合。请参阅有关增强功能的 0.25 文档部分以及相关 GitHub 问题 GH18366 和 GH26512。

从文档中，

支持特定于列的聚合并控制输出 列名，pandas 接受

GroupBy.agg()

中的特殊语法， 称为“命名聚合”，其中

• 关键字是输出列名称
• 这些值是元组，其第一个元素是要选择的列，第二个元素是要应用于该列的聚合。 Pandas 提供 pandas.NamedAgg 命名元组与字段 ['column', 'aggfunc'] 使参数更清楚。作为 通常，聚合可以是可调用的或字符串别名。

您现在可以通过关键字参数传递元组。元组遵循

(<colName>, <aggFunc>)

的格式。

import pandas as pd

pd.__version__                                                                                                                            
# '0.25.0.dev0+840.g989f912ee'

# Setup
df = pd.DataFrame({'kind': ['cat', 'dog', 'cat', 'dog'],
                   'height': [9.1, 6.0, 9.5, 34.0],
                   'weight': [7.9, 7.5, 9.9, 198.0]
})

df.groupby('kind').agg(
    max_height=('height', 'max'), min_weight=('weight', 'min'),)

      max_height  min_weight
kind                        
cat          9.5         7.9
dog         34.0         7.5

或者，您可以使用

pd.NamedAgg

（本质上是一个命名元组），这使得事情更加明确。

df.groupby('kind').agg(
    max_height=pd.NamedAgg(column='height', aggfunc='max'), 
    min_weight=pd.NamedAgg(column='weight', aggfunc='min')
)

      max_height  min_weight
kind                        
cat          9.5         7.9
dog         34.0         7.5

对于 Series 来说更简单，只需将 aggfunc 传递给关键字参数即可。

df.groupby('kind')['height'].agg(max_height='max', min_height='min')    

      max_height  min_height
kind                        
cat          9.5         9.1
dog         34.0         6.0       

最后，如果您的列名不是有效的 python 标识符，请使用字典进行解包：

df.groupby('kind')['height'].agg(**{'max height': 'max', ...})

---

熊猫< 0.25

在最新版本的 pandas 0.24 之前，如果使用字典来指定聚合输出的列名称，您将得到一个

FutureWarning

:

df.groupby('dummy').agg({'returns': {'Mean': 'mean', 'Sum': 'sum'}})
# FutureWarning: using a dict with renaming is deprecated and will be removed 
# in a future version

在 v0.20 中不推荐使用字典来重命名列。在更新版本的 pandas 上，可以通过传递元组列表来更简单地指定。如果以这种方式指定函数，则需要将该列的all函数指定为（名称，函数）对的元组。

df.groupby("dummy").agg({'returns': [('op1', 'sum'), ('op2', 'mean')]})

        returns          
            op1       op2
dummy                    
1      0.328953  0.032895

或者，

df.groupby("dummy")['returns'].agg([('op1', 'sum'), ('op2', 'mean')])

            op1       op2
dummy                    
1      0.328953  0.032895

Answer 3

这样的事情有用吗：

In [7]: df.groupby('dummy').returns.agg({'func1' : lambda x: x.sum(), 'func2' : lambda x: x.prod()})
Out[7]: 
              func2     func1
dummy                        
1     -4.263768e-16 -0.188565

Answer 4

如果您有多个列需要应用相同的多个聚合函数，最简单的方法（imo）是使用字典理解。

#setup
df = pd.DataFrame({'dummy': [0, 1, 1], 'A': range(3), 'B':range(1, 4), 'C':range(2, 5)})

# aggregation
df.groupby("dummy").agg({k: ['sum', 'mean'] for k in ['A', 'B', 'C']})

上面的结果是一个带有 MultiIndex 列的数据框。如果需要平面自定义列名称，则可以使用命名聚合（如此处其他答案中所建议的那样）。

如文档中所述，键应该是输出列名称，值应该是命名聚合的元组(column, aggregation function)

。由于有多个列和多个函数，这会导致嵌套结构。要将其扁平化为单个字典，您可以使用 

collections.ChainMap()

 或嵌套循环。

此外，如果您更喜欢将石斑鱼列 (

dummy

) 作为列（而不是索引），请在 

as_index=False

 中指定 

groupby()

。

from collections import ChainMap
# convert a list of dictionaries into a dictionary
dct = dict(ChainMap(*reversed([{f'{k}_total': (k, 'sum'), f'{k}_mean': (k, 'mean')} for k in ['A','B','C']])))
# {'A_total': ('A', 'sum'), 'A_avg': ('A', 'mean'), 'B_total': ('B', 'sum'), 'B_avg': ('B', 'mean'), 'C_total': ('C', 'sum'), 'C_avg': ('C', 'mean')}

# the same result obtained by a nested loop
# dct = {k:v for k in ['A','B','C'] for k,v in [(f'{k}_total', (k, 'sum')), (f'{k}_avg', (k, 'mean'))]}

# aggregation
df.groupby('dummy', as_index=False).agg(**dct)

Answer 5

您还可以在 NamedAggregation 中使用 lambda

df.groupby('dummy').returns.agg({
  'summed' : pd.NamedAgg(column='date', aggfunc=lambda series: sum(series.values()),
  'joined' : pd.NamedAgg(column='returns', aggfunc=lambda series: ','.join(series.values())),
})