bea*_*rdc 183 python group-by aggregate-functions pandas
该文档说明如何将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(因为如果agg从DataFrame中调用键,则键必须是一个列).
有没有内置的方法来做我想做的事情,或者可能添加这个功能的可能性,还是我只需要手动迭代组合？
谢谢
Ted*_*rou 200
目前接受的答案的后半部分已过时,并且有两个弃用.首先也是最重要的是,您不能再将字典字典传递给agggroupby方法.第二,永远不要使用.ix.
如果您希望同时使用两个单独的列,我建议使用applyimplicity将DataFrame传递给应用函数的方法.让我们使用与上面类似的数据帧
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
Zel*_*ny7 162
对于第一部分,您可以传递键的列名称和字符串的函数列表:
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
r2e*_*ans 14
作为泰德·彼得鲁（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
我发现它更让人联想到dplyr管道和data.table链接的命令。并不是说它们更好，只是我更熟悉。（我当然认识到def对于这些类型的操作使用更正式的功能的功能，并且对于许多人而言，这是首选。这只是一种选择，不一定更好。）
我生成数据的方式与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
Erf*_*fan 11
Pandas >= 0.25.0，称为集合从pandas版本0.25.0或更高版本开始，我们正在远离基于字典的聚合和重命名，而转向接受a的命名聚合tuple。现在，我们可以同时聚合+重命名为更多信息的列名：
范例：
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
为了支持列特定聚合并控制输出列名称，pandas 接受GroupBy.agg() 中的特殊语法，称为“命名聚合”，其中
>>> 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
pandas.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() 部分应用它们。
命名聚合也适用于系列 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
这是使用命名聚合的“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