docs显示如何使用带有输出列名称作为键的dict一次在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对象。当一个dict类似地传递给一个由DataFrame组成的组时，它希望键是该函数将应用于的列名。
我想要做的是将多个函数应用于多个列（但某些列将多次运行）。此外，某些函数将依赖于groupby对象中的其他列（如sumif函数）。我目前的解决方案是逐列，并执行类似上面的代码，使用lambdas作为依赖于其他行的函数。但这需要很长时间，（我认为迭代一个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，则键必须是一个列。）
是否有任何内置方法可以执行我想要执行的操作，或者是否可能添加此功能，或者我是否只需要手动迭代群组？
由于
答案 0 :(得分：154)
对于第一部分，您可以传递键的列名称和字符串的函数列表：
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函数中的组索引对其进行索引。
这是一个hacky解决方法：
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将是一个系列。将g.index传递给df.ix[]会从df中选择当前组。然后我测试C列是否小于0.5。返回的布尔系列传递给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
仅选择符合条件的那些行。
{{1}}
答案 1 :(得分：147)
目前接受的答案的后半部分已过时，并且有两个弃用。首先也是最重要的是，您不能再将字典字典传递给agg groupby方法。其次，永远不要使用.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并返回系列现在，如果您有多个需要进行交互的列，则无法使用agg，它会隐式地将Series传递给聚合函数。使用apply时，整个组作为DataFrame传递给函数。
我建议制作一个返回所有聚合系列的自定义函数。使用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
答案 2 :(得分：12)
Pandas >= 0.25.0，命名为聚合从0.25.0版或更高版本开始，我们就不再使用基于字典的聚合和重命名，而转向接受tuple的{{3}}。现在，我们可以同时聚合+重命名为更多信息的列名称：
示例：
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
答案 3 :(得分：7)
作为泰德·彼得鲁（Ted Petrou）的替代方案（主要是美学方面），我发现我更喜欢紧凑的清单。请不要考虑接受它，它只是对Ted的答案以及代码/数据的更详细的评论。 Python / pandas不是我的第一个/最好的，但是我发现它读起来不错：
[ 'David John Michael','David Michael John', 'John David Michael', 'JohnMichael David', 'Michael John David', 'Michael David John' ]
我发现它更让人联想到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
管道和dplyr链接的命令。并不是说它们更好，只是我更熟悉。 （我当然认识到对于这些类型的操作使用更正式的data.table函数的功能，并且对于许多类型的操作的偏好。这只是一种替代方法，不一定更好。）
我以与Ted相同的方式生成数据，我将添加一个可重复性的种子。
def答案 4 :(得分：3)
为了支持特定列的聚合并控制输出列名称，pandas在 GroupBy.agg（）中接受了特殊语法，称为“命名聚合” ，在哪里
In [79]: 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]})
....:
In [80]: animals
Out[80]:
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
In [81]: 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),
....: )
....:
Out[81]:
min_height max_height average_weight
kind
cat 9.1 9.5 8.90
dog 6.0 34.0 102.75
pandas.NamedAgg只是一个namedtuple。也可以使用普通的元组。
In [82]: animals.groupby("kind").agg(
....: min_height=('height', 'min'),
....: max_height=('height', 'max'),
....: average_weight=('weight', np.mean),
....: )
....:
Out[82]:
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聚合。在这种情况下，没有选择列，因此值只是函数。
In [84]: animals.groupby("kind").height.agg(
....: min_height='min',
....: max_height='max',
....: )
....:
Out[84]:
min_height max_height
kind
cat 9.1 9.5
dog 6.0 34.0
答案 5 :(得分：1)
Ted的答案令人惊讶。我最终使用了一个较小的版本，以防有人感兴趣。在寻找一种取决于多个列中的值的聚合时很有用：
df=pd.DataFrame({'a': [1,2,3,4,5,6], 'b': [1,1,0,1,1,0], 'c': ['x','x','y','y','z','z']})
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
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之后选择感兴趣的列，您就可以从聚合函数中访问数据框的所有列。
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())
我希望这会有所帮助。
答案 6 :(得分：1)
这是对使用命名聚合的“ 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