提问人：beardc 提问时间：1/26/2013 最后编辑：Asclepiusbeardc 更新时间：9/29/2023 访问量：474761
将多个函数应用于多个 groupby 列
Apply multiple functions to multiple groupby columns
问：
这些文档展示了如何使用以输出列名称为键的字典一次对 groupby 对象应用多个函数：
In [563]: grouped['D'].agg({'result1' : np.sum,
.....: 'result2' : np.mean})
.....:
Out[563]:
result2 result1
A
bar -0.579846 -1.739537
foo -0.280588 -1.402938
但是，这仅适用于 Series groupby 对象。当字典以类似方式传递给 groupby DataFrame 时，它期望键是将应用函数的列名。
我想做的是将多个函数应用于多个列（但某些列将被多次操作）。此外，某些函数将依赖于 groupby 对象中的其他列（如 sumif 函数）。我目前的解决方案是逐列进行，并执行类似于上面代码的操作，将 lambda 用于依赖于其他行的函数。但这需要很长时间，（我认为迭代一个 groupby 对象需要很长时间）。我必须更改它，以便在一次运行中遍历整个 groupby 对象，但我想知道 pandas 中是否有一种内置的方法可以干净利落地做到这一点。
例如，我尝试过类似
grouped.agg({'C_sum' : lambda x: x['C'].sum(),
'C_std': lambda x: x['C'].std(),
'D_sum' : lambda x: x['D'].sum()},
'D_sumifC3': lambda x: x['D'][x['C'] == 3].sum(), ...)
但正如预期的那样，我得到了一个 KeyError（因为键必须是从 DataFrame 调用的列）。agg
是否有任何内置方法可以执行我想做的事情，或者可以添加此功能，或者我只需要手动遍历 groupby？
答：
187赞
Zelazny7
1/26/2013
#1
对于第一部分，您可以传递键的列名字典和值的函数列表：
In [28]: df
Out[28]:
A B C D E GRP
0 0.395670 0.219560 0.600644 0.613445 0.242893 0
1 0.323911 0.464584 0.107215 0.204072 0.927325 0
2 0.321358 0.076037 0.166946 0.439661 0.914612 1
3 0.133466 0.447946 0.014815 0.130781 0.268290 1
In [26]: f = {'A':['sum','mean'], 'B':['prod']}
In [27]: df.groupby('GRP').agg(f)
Out[27]:
A B
sum mean prod
GRP
0 0.719580 0.359790 0.102004
1 0.454824 0.227412 0.034060
更新1：
由于聚合函数适用于 Series，因此会丢失对其他列名的引用。要解决此问题，您可以引用完整的数据帧并使用 lambda 函数中的组索引对其进行索引。
这里有一个黑客解决方法：
In [67]: f = {'A':['sum','mean'], 'B':['prod'], 'D': lambda g: df.loc[g.index].E.sum()}
In [69]: df.groupby('GRP').agg(f)
Out[69]:
A B D
sum mean prod <lambda>
GRP
0 0.719580 0.359790 0.102004 1.170219
1 0.454824 0.227412 0.034060 1.182901
在这里，生成的“D”列由总和的“E”值组成。
更新2：
这里有一种方法，我认为可以做你问的一切。首先创建一个自定义 lambda 函数。下面，g 引用了该组。聚合时，g 将是一个系列。传递 to 从 df 中选择当前组。然后，我测试C列是否小于0.5。返回的布尔序列将传递给该数组，该数组仅选择符合条件的行。g.indexdf.ix[]g[]
In [95]: cust = lambda g: g[df.loc[g.index]['C'] < 0.5].sum()
In [96]: f = {'A':['sum','mean'], 'B':['prod'], 'D': {'my name': cust}}
In [97]: df.groupby('GRP').agg(f)
Out[97]:
A B D
sum mean prod my name
GRP
0 0.719580 0.359790 0.102004 0.204072
1 0.454824 0.227412 0.034060 0.570441
评论
0赞
beardc
1/26/2013
有趣的是，我还可以传递 as 值而不是列表的字典来保留我的自定义名称。但无论哪种情况，我都无法传递使用其他列的 （如上所示：“KeyError： 'D'”）。知道这是否可能吗？{funcname: func}lambdalambda x: x['D'][x['C'] < 3].sum()
598赞
Ted Petrou
11/4/2017
#2
当前接受的答案的后半部分已过时，并且有两个弃用。首先，也是最重要的一点是，不能再将字典字典传递给 groupby 方法。其次，永远不要使用 .agg.ix
如果您希望同时使用两个单独的列，我建议使用隐式将 DataFrame 传递给应用函数的方法。让我们使用与上面类似的数据帧apply
df = pd.DataFrame(np.random.rand(4,4), columns=list('abcd'))
df['group'] = [0, 0, 1, 1]
df
a b c d group
0 0.418500 0.030955 0.874869 0.145641 0
1 0.446069 0.901153 0.095052 0.487040 0
2 0.843026 0.936169 0.926090 0.041722 1
3 0.635846 0.439175 0.828787 0.714123 1
从列名映射到聚合函数的字典仍然是执行聚合的完美方法。
df.groupby('group').agg({'a':['sum', 'max'],
'b':'mean',
'c':'sum',
'd': lambda x: x.max() - x.min()})
a b c d
sum max mean sum <lambda>
group
0 0.864569 0.446069 0.466054 0.969921 0.341399
1 1.478872 0.843026 0.687672 1.754877 0.672401
如果你不喜欢那个丑陋的 lambda 列名，你可以使用一个普通函数，并为特殊属性提供一个自定义名称，如下所示：__name__
def max_min(x):
return x.max() - x.min()
max_min.__name__ = 'Max minus Min'
df.groupby('group').agg({'a':['sum', 'max'],
'b':'mean',
'c':'sum',
'd': max_min})
a b c d
sum max mean sum Max minus Min
group
0 0.864569 0.446069 0.466054 0.969921 0.341399
1 1.478872 0.843026 0.687672 1.754877 0.672401
使用和返回系列apply
现在，如果有多个列需要一起交互，则不能使用 ，它会将 Series 隐式传递给聚合函数。当将整个组用作 DataFrame 时，会传递到函数中。aggapply
我建议创建一个自定义函数，返回所有聚合的 Series。使用“系列”索引作为新列的标签：
def f(x):
d = {}
d['a_sum'] = x['a'].sum()
d['a_max'] = x['a'].max()
d['b_mean'] = x['b'].mean()
d['c_d_prodsum'] = (x['c'] * x['d']).sum()
return pd.Series(d, index=['a_sum', 'a_max', 'b_mean', 'c_d_prodsum'])
df.groupby('group').apply(f)
a_sum a_max b_mean c_d_prodsum
group
0 0.864569 0.446069 0.466054 0.173711
1 1.478872 0.843026 0.687672 0.630494
如果你爱上了 MultiIndexes，你仍然可以返回一个系列，如下所示：
def f_mi(x):
d = []
d.append(x['a'].sum())
d.append(x['a'].max())
d.append(x['b'].mean())
d.append((x['c'] * x['d']).sum())
return pd.Series(d, index=[['a', 'a', 'b', 'c_d'],
['sum', 'max', 'mean', 'prodsum']])
df.groupby('group').apply(f_mi)
a b c_d
sum max mean prodsum
group
0 0.864569 0.446069 0.466054 0.173711
1 1.478872 0.843026 0.687672 0.630494
4赞
campo
7/12/2018
#3
泰德的回答令人惊叹。我最终使用了它的较小版本，以防有人感兴趣。当您查找依赖于多个列中的值的聚合时，这很有用：
创建数据帧
df = pd.DataFrame({
'a': [1, 2, 3, 4, 5, 6],
'b': [1, 1, 0, 1, 1, 0],
'c': ['x', 'x', 'y', 'y', 'z', 'z']
})
print(df)
a b c
0 1 1 x
1 2 1 x
2 3 0 y
3 4 1 y
4 5 1 z
5 6 0 z
使用 apply 进行分组和聚合（使用多列）
print(
df
.groupby('c')
.apply(lambda x: x['a'][(x['a'] > 1) & (x['b'] == 1)]
.mean()
)
c
x 2.0
y 4.0
z 5.0
使用聚合进行分组和聚合（使用多列）
我喜欢这种方法，因为我仍然可以使用聚合。也许人们会让我知道为什么在对组进行聚合时需要申请来获取多个列。
现在看来很明显，但只要您不直接在 groupby 之后选择感兴趣的列，您就可以从聚合函数中访问 dataframe 的所有列。
仅访问所选列
df.groupby('c')['a'].aggregate(lambda x: x[x > 1].mean())
自选择以来访问所有列毕竟是魔术
df.groupby('c').aggregate(lambda x: x[(x['a'] > 1) & (x['b'] == 1)].mean())['a']
或类似
df.groupby('c').aggregate(lambda x: x['a'][(x['a'] > 1) & (x['b'] == 1)].mean())
我希望这会有所帮助。
55赞
r2evans
11/1/2018
#4
作为 Ted Petrou 答案的替代方案（主要是美学），我发现我更喜欢稍微紧凑的列表。请不要考虑接受它，它只是对 Ted 的回答的更详细的评论，加上代码/数据。Python/pandas 不是我的第一个/最好的，但我发现这个读起来很好：
df.groupby('group') \
.apply(lambda x: pd.Series({
'a_sum' : x['a'].sum(),
'a_max' : x['a'].max(),
'b_mean' : x['b'].mean(),
'c_d_prodsum' : (x['c'] * x['d']).sum()
})
)
a_sum a_max b_mean c_d_prodsum
group
0 0.530559 0.374540 0.553354 0.488525
1 1.433558 0.832443 0.460206 0.053313
我发现它更让人想起管道和链式命令。不是说它们更好，只是我更熟悉。（我当然认识到为这些类型的操作使用更正式的函数的力量，并且对许多人来说，更喜欢使用更正式的函数。这只是一种选择，不一定更好。dplyrdata.tabledef
我以与 Ted 相同的方式生成数据，我将添加一个可重复性的种子。
import numpy as np
np.random.seed(42)
df = pd.DataFrame(np.random.rand(4,4), columns=list('abcd'))
df['group'] = [0, 0, 1, 1]
df
a b c d group
0 0.374540 0.950714 0.731994 0.598658 0
1 0.156019 0.155995 0.058084 0.866176 0
2 0.601115 0.708073 0.020584 0.969910 1
3 0.832443 0.212339 0.181825 0.183405 1
76赞
Erfan
8/3/2019
#5
Pandas >= 0.25.0，命名为聚合
从 pandas 版本或更高版本开始，我们正在摆脱基于字典的聚合和重命名，并转向接受 .现在我们可以同时聚合 + 重命名为信息量更大的列名：0.25.0tuple
示例：
df = pd.DataFrame(np.random.rand(4,4), columns=list('abcd'))
df['group'] = [0, 0, 1, 1]
a b c d group
0 0.521279 0.914988 0.054057 0.125668 0
1 0.426058 0.828890 0.784093 0.446211 0
2 0.363136 0.843751 0.184967 0.467351 1
3 0.241012 0.470053 0.358018 0.525032 1
使用命名聚合应用：GroupBy.agg
df.groupby('group').agg(
a_sum=('a', 'sum'),
a_mean=('a', 'mean'),
b_mean=('b', 'mean'),
c_sum=('c', 'sum'),
d_range=('d', lambda x: x.max() - x.min())
)
a_sum a_mean b_mean c_sum d_range
group
0 0.947337 0.473668 0.871939 0.838150 0.320543
1 0.604149 0.302074 0.656902 0.542985 0.057681
19赞
exan
11/21/2019
#6
为了支持特定于列的聚合并控制输出列名称，pandas 接受 GroupBy.agg（） 中的特殊语法，称为“命名聚合”，其中
- 关键字是输出列名称
- 这些值是元组，其第一个元素是要选择的列，第二个元素是要应用于该列的聚合。熊猫提供熊猫。NamedAgg 命名元组，并带有字段 ['column'， 'aggfunc']，以便更清楚地说明参数是什么。像往常一样，聚合可以是可调用对象，也可以是字符串别名。
>>> animals = 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]
... })
>>> print(animals)
kind height weight
0 cat 9.1 7.9
1 dog 6.0 7.5
2 cat 9.5 9.9
3 dog 34.0 198.0
>>> print(
... animals
... .groupby('kind')
... .agg(
... min_height=pd.NamedAgg(column='height', aggfunc='min'),
... max_height=pd.NamedAgg(column='height', aggfunc='max'),
... average_weight=pd.NamedAgg(column='weight', aggfunc=np.mean),
... )
... )
min_height max_height average_weight
kind
cat 9.1 9.5 8.90
dog 6.0 34.0 102.75
熊猫。NamedAgg 只是一个命名元组。也允许使用纯元组。
>>> print(
... animals
... .groupby('kind')
... .agg(
... min_height=('height', 'min'),
... max_height=('height', 'max'),
... average_weight=('weight', np.mean),
... )
... )
min_height max_height average_weight
kind
cat 9.1 9.5 8.90
dog 6.0 34.0 102.75
其他关键字参数不会传递到聚合函数。只有成对的 （column， aggfunc） 应作为 **kwargs 传递。如果您的聚合函数需要额外的参数，请使用 functools.partial（） 部分应用它们。
命名聚合也适用于 Series groupby 聚合。在本例中，没有列选择，因此值只是函数。
>>> print(
... animals
... .groupby('kind')
... .height
... .agg(
... min_height='min',
... max_height='max',
... )
... )
min_height max_height
kind
cat 9.1 9.5
dog 6.0 34.0
7赞
Mint
7/23/2020
#7
这是对使用命名聚合的“exans”答案的扭曲。它是相同的，但具有参数解压缩功能，它允许您仍然将字典传递给 agg 函数。
命名的 aggs 是一个不错的功能，但乍一看似乎很难以编程方式编写，因为它们使用关键字，但实际上使用参数/关键字解包很简单。
animals = 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]})
agg_dict = {
"min_height": pd.NamedAgg(column='height', aggfunc='min'),
"max_height": pd.NamedAgg(column='height', aggfunc='max'),
"average_weight": pd.NamedAgg(column='weight', aggfunc=np.mean)
}
animals.groupby("kind").agg(**agg_dict)
结果
min_height max_height average_weight
kind
cat 9.1 9.5 8.90
dog 6.0 34.0 102.75
0赞
Xinwei Sher
9/29/2023
#8
df.groupby('c').aggregate(lambda x: x[(x['a'] > 1) & (x['b'] == 1)].mean())['a']
和
df.groupby('c').aggregate(lambda x: x['a'][(x['a'] > 1) & (x['b'] == 1)].mean())
不工作。抛出关键错误： “键错误：'a'”
这个有效（@r2evans的答案）：
df.groupby('group') \
.apply(lambda x: pd.Series({
'a_sum' : x['a'].sum(),
'a_max' : x['a'].max(),
'b_mean' : x['b'].mean(),
'c_d_prodsum' : (x['c'] * x['d']).sum()
})
)
评论