Python Pandas使用Groupby()创建新列.Sum()
fe *_*ner 57 python pandas pandas-groupby
尝试使用groupby计算创建新列.在下面的代码中,我得到了每个日期的正确计算值(参见下面的组),但是当我尝试用它创建一个新列(df ['Data4'])时,我得到了NaN.因此,我尝试在数据框中创建一个新列,其中包含所有日期的"Data3"总和,并将其应用于每个日期行.例如,2015-05-08分为2行(总数为50 + 5 = 55),在这个新列中,我想在两行中都有55行.
import pandas as pd
import numpy as np
from pandas import DataFrame
df = pd.DataFrame({'Date': ['2015-05-08', '2015-05-07', '2015-05-06', '2015-05-05', '2015-05-08', '2015-05-07', '2015-05-06', '2015-05-05'], 'Sym': ['aapl', 'aapl', 'aapl', 'aapl', 'aaww', 'aaww', 'aaww', 'aaww'], 'Data2': [11, 8, 10, 15, 110, 60, 100, 40],'Data3': [5, 8, 6, 1, 50, 100, 60, 120]})
group = df['Data3'].groupby(df['Date']).sum()
df['Data4'] = group
EdC*_*ica 161
您想要使用transform它将返回一个索引与df对齐的系列,以便您可以将其添加为新列:
In [74]:
df = pd.DataFrame({'Date': ['2015-05-08', '2015-05-07', '2015-05-06', '2015-05-05', '2015-05-08', '2015-05-07', '2015-05-06', '2015-05-05'], 'Sym': ['aapl', 'aapl', 'aapl', 'aapl', 'aaww', 'aaww', 'aaww', 'aaww'], 'Data2': [11, 8, 10, 15, 110, 60, 100, 40],'Data3': [5, 8, 6, 1, 50, 100, 60, 120]})
?
df['Data4'] = df['Data3'].groupby(df['Date']).transform('sum')
df
Out[74]:
Data2 Data3 Date Sym Data4
0 11 5 2015-05-08 aapl 55
1 8 8 2015-05-07 aapl 108
2 10 6 2015-05-06 aapl 66
3 15 1 2015-05-05 aapl 121
4 110 50 2015-05-08 aaww 55
5 60 100 2015-05-07 aaww 108
6 100 60 2015-05-06 aaww 66
7 40 120 2015-05-05 aaww 121
- 或者,可以使用`df.groupby('Date')['Data3'].transform('sum')`(我发现它更容易记住). (9认同)
cs9*_*s95 19
如何使用Groupby（）。Sum（）创建新列？
有两种方法-一种简单明了，另一种更有趣。
每个人都喜欢的：GroupBy.transform()与'sum'
@Ed Chum的答案可以简化一点。致电DataFrame.groupby而不是Series.groupby。这样可以简化语法。
# The setup.
df[['Date', 'Data3']]
Date Data3
0 2015-05-08 5
1 2015-05-07 8
2 2015-05-06 6
3 2015-05-05 1
4 2015-05-08 50
5 2015-05-07 100
6 2015-05-06 60
7 2015-05-05 120
df.groupby('Date')['Data3'].transform('sum')
0 55
1 108
2 66
3 121
4 55
5 108
6 66
7 121
Name: Data3, dtype: int64
快一点
df2 = pd.concat([df] * 12345)
%timeit df2['Data3'].groupby(df['Date']).transform('sum')
%timeit df2.groupby('Date')['Data3'].transform('sum')
10.4 ms ± 367 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
8.58 ms ± 559 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
非常规，但值得您考虑：GroupBy.sum()+Series.map()
我偶然发现了API中的一个有趣的特质。据我所知，您可以在0.20以上的任何主要版本上重现此代码（我在0.23和0.24上进行了测试）。transform如果您改为使用的直接功能GroupBy并使用map以下命令进行广播，则似乎可以始终节省几毫秒的时间：
df.Date.map(df.groupby('Date')['Data3'].sum())
0 55
1 108
2 66
3 121
4 55
5 108
6 66
7 121
Name: Date, dtype: int64
与之比较
df.groupby('Date')['Data3'].transform('sum')
0 55
1 108
2 66
3 121
4 55
5 108
6 66
7 121
Name: Data3, dtype: int64
我的测试表明，map有点更快，如果你能负担得起使用直接GroupBy函数（如mean，min，max，first，等）。在大多数情况下，大约快至20万条记录时，它或多或少地更快。在那之后，性能实际上取决于数据。
（左：v0.23，右：v0.24）
更好的选择，如果您的框架较小且组数较少，则更好。。。但我建议您将其transform作为首选。认为这还是值得分享的。
基准测试代码，以供参考：
import perfplot
perfplot.show(
setup=lambda n: pd.DataFrame({'A': np.random.choice(n//10, n), 'B': np.ones(n)}),
kernels=[
lambda df: df.groupby('A')['B'].transform('sum'),
lambda df: df.A.map(df.groupby('A')['B'].sum()),
],
labels=['GroupBy.transform', 'GroupBy.sum + map'],
n_range=[2**k for k in range(5, 20)],
xlabel='N',
logy=True,
logx=True
)
我通常建议使用功能更强大的apply，即使对于更复杂的用途，您也可以使用它在单个表达式中编写查询，例如定义一个新列，其值被定义为对组的操作，并且也可以具有不同的值内同组！
这比为每个组定义具有相同值的列的简单情况更通用（就像sum在这个问题中一样，它因组而异，在同一组内是相同的）。
简单情况（组内具有相同值的新列，组间不同）：
# I'm assuming the name of your dataframe is something long, like
# `my_data_frame`, to show the power of being able to write your
# data processing in a single expression without multiple statements and
# multiple references to your long name, which is the normal style
# that the pandas API naturally makes you adopt, but which make the
# code often verbose, sparse, and a pain to generalize or refactor
my_data_frame = pd.DataFrame({
'Date': ['2015-05-08', '2015-05-07', '2015-05-06', '2015-05-05', '2015-05-08', '2015-05-07', '2015-05-06', '2015-05-05'],
'Sym': ['aapl', 'aapl', 'aapl', 'aapl', 'aaww', 'aaww', 'aaww', 'aaww'],
'Data2': [11, 8, 10, 15, 110, 60, 100, 40],
'Data3': [5, 8, 6, 1, 50, 100, 60, 120]})
?
(my_data_frame
# create groups by 'Date'
.groupby(['Date'])
# for every small Group DataFrame `gdf` with the same 'Date', do:
# assign a new column 'Data4' to it, with the value being
# the sum of 'Data3' for the small dataframe `gdf`
.apply(lambda gdf: gdf.assign(Data4=lambda gdf: gdf['Data3'].sum()))
# after groupby operations, the variable(s) you grouped by on
# are set as indices. In this case, 'Date' was set as an additional
# level for the (multi)index. But it is still also present as a
# column. Thus, we drop it from the index:
.droplevel(0)
)
### OR
# We don't even need to define a variable for our dataframe.
# We can chain everything in one expression
(pd
.DataFrame({
'Date': ['2015-05-08', '2015-05-07', '2015-05-06', '2015-05-05', '2015-05-08', '2015-05-07', '2015-05-06', '2015-05-05'],
'Sym': ['aapl', 'aapl', 'aapl', 'aapl', 'aaww', 'aaww', 'aaww', 'aaww'],
'Data2': [11, 8, 10, 15, 110, 60, 100, 40],
'Data3': [5, 8, 6, 1, 50, 100, 60, 120]})
.groupby(['Date'])
.apply(lambda gdf: gdf.assign(Data4=lambda gdf: gdf['Data3'].sum()))
.droplevel(0)
)
出去：
| 日期 | 符号 | 数据2 | 数据3 | 数据4 | |
|---|---|---|---|---|---|
| 3 | 2015-05-05 | 应用程序 | 15 | 1 | 121 |
| 7 | 2015-05-05 | 啊啊啊啊 | 40 | 120 | 121 |
| 2 | 2015-05-06 | 应用程序 | 10 | 6 | 66 |
| 6 | 2015-05-06 | 啊啊啊啊 | 100 | 60 | 66 |
| 1 | 2015-05-07 | 应用程序 | 8 | 8 | 108 |
| 5 | 2015-05-07 | 啊啊啊啊 | 60 | 100 | 108 |
| 0 | 2015-05-08 | 应用程序 | 11 | 5 | 55 |
| 4 | 2015-05-08 | 啊啊啊啊 | 110 | 50 | 55 |
（为什么python表达式在括号内？这样我们就不需要在我们的代码中到处使用反斜杠了，我们可以在我们的表达式代码中添加注释来描述每一步。）
这有什么强大的？它正在利用“拆分-应用-组合范式”的全部力量。它允许您在不减少/聚合（即不减少行数）的情况下考虑“将数据帧拆分为块”和“在这些块上运行任意操作”。（并且无需编写显式、冗长的循环，也无需使用昂贵的连接或串联来粘合结果。）
让我们考虑一个更复杂的例子。在其中您的数据框中有多个时间序列数据的一种。您有一个代表一种产品的列、一个具有时间戳的列以及一个包含一年中某个时间为该产品销售的商品数量的列。您想按产品分组并获得一个新列，其中包含每个类别销售的项目的累计总数。我们想要一个列，在每个具有相同产品的“块”内，仍然是一个时间序列，并且单调递增（仅在一个块内）。
我们应该怎么做？与groupby+ apply！
(pd
.DataFrame({
'Date': ['2021-03-11','2021-03-12','2021-03-13','2021-03-11','2021-03-12','2021-03-13'],
'Product': ['shirt','shirt','shirt','shoes','shoes','shoes'],
'ItemsSold': [300, 400, 234, 80, 10, 120],
})
.groupby(['Product'])
.apply(lambda gdf: (gdf
# sort by date within a group
.sort_values('Date')
# create new column
.assign(CumulativeItemsSold=lambda df: df['ItemsSold'].cumsum())))
.droplevel(0)
)
出去：
| 日期 | 产品 | 已售商品 | 累计售出商品 | |
|---|---|---|---|---|
| 0 | 2021-03-11 | 衬衫 | 300 | 300 |
| 1 | 2021-03-12 | 衬衫 | 400 | 700 |
| 2 | 2021-03-13 | 衬衫 | 234 | 934 |
| 3 | 2021-03-11 | 鞋 | 80 | 80 |
| 4 | 2021-03-12 | 鞋 | 10 | 90 |
| 5 | 2021-03-13 | 鞋 | 120 | 210 |
这种方法的另一个优点是什么？即使我们必须按多个字段分组，它也能工作！例如，如果我们的产品有一个'Color'字段，并且我们想要按 分组的累积系列(Product, Color)，我们可以：
(pd
.DataFrame({
'Date': ['2021-03-11','2021-03-12','2021-03-13','2021-03-11','2021-03-12','2021-03-13',
'2021-03-11','2021-03-12','2021-03-13','2021-03-11','2021-03-12','2021-03-13'],
'Product': ['shirt','shirt','shirt','shoes','shoes','shoes',
'shirt','shirt','shirt','shoes','shoes','shoes'],
'Color': ['yellow','yellow','yellow','yellow','yellow','yellow',
'blue','blue','blue','blue','blue','blue'], # new!
'ItemsSold': [300, 400, 234, 80, 10, 120,
123, 84, 923, 0, 220, 94],
})
.groupby(['Product', 'Color']) # We group by 2 fields now
.apply(lambda gdf: (gdf
.sort_values('Date')
.assign(CumulativeItemsSold=lambda df: df['ItemsSold'].cumsum())))
.droplevel([0,1]) # We drop 2 levels now
出去：
| 日期 | 产品 | 颜色 | 已售商品 | 累计售出商品 | |
|---|---|---|---|---|---|
| 6 | 2021-03-11 | 衬衫 | 蓝色 | 123 | 123 |
| 7 | 2021-03-12 | 衬衫 | 蓝色 | 84 | 207 |
| 8 | 2021-03-13 | 衬衫 | 蓝色 | 923 | 1130 |
| 0 | 2021-03-11 | 衬衫 | 黄色 | 300 | 300 |
| 1 | 2021-03-12 | 衬衫 | 黄色 | 400 | 700 |
| 2 | 2021-03-13 | 衬衫 | 黄色 | 234 | 934 |
| 9 | 2021-03-11 | 鞋 | 蓝色 | 0 | 0 |
| 10 | 2021-03-12 | 鞋 | 蓝色 | 220 | 220 |
| 11 | 2021-03-13 | 鞋 | 蓝色 | 94 | 314 |
| 3 | 2021-03-11 | 鞋 | 黄色 | 80 | 80 |
| 4 | 2021-03-12 | 鞋 | 黄色 | 10 | 90 |
| 5 | 2021-03-13 | 鞋 | 黄色 | 120 | 210 |
（这种很容易扩展到对多个字段进行分组的可能性是我喜欢将groupbyalways的参数放在一个列表中的原因，即使它是一个单一的名称，如前一个示例中的“产品”。）
您可以在一个表达式中综合完成所有这些。（当然，如果 python 的 lambdas 看起来更好看一点，它看起来会更好。）
为什么我要检查一般情况？因为这是在谷歌搜索“pandas new column groupby”之类的东西时出现的第一个SO问题之一。
关于此类操作的 API 的其他想法
添加基于对组进行的任意计算的列很像在 SparkSQL 中使用 Windows 上的聚合定义新列的好习惯用法。
例如，您可以这样想（它是 Scala 代码，但 PySpark 中的等效代码看起来几乎相同）：
val byDepName = Window.partitionBy('depName)
empsalary.withColumn("avg", avg('salary) over byDepName)
就像（以我们上面看到的方式使用熊猫）：
empsalary = pd.DataFrame(...some dataframe...)
(empsalary
# our `Window.partitionBy('depName)`
.groupby(['depName'])
# our 'withColumn("avg", avg('salary) over byDepName)
.apply(lambda gdf: gdf.assign(avg=lambda df: df['salary'].mean()))
.droplevel(0)
)
（请注意 Spark 示例的合成和更好的程度。pandas 等效项看起来有点笨拙。pandas API 并没有让编写这些类型的“流畅”操作变得容易）。
这个习语反过来来自SQL 的 Window Functions，PostgreSQL 文档给出了一个非常好的定义：（强调我的）
窗口函数对与当前行有某种关联的一组表行执行计算。这与可以使用聚合函数完成的计算类型相当。但与常规聚合函数不同，窗口函数的使用不会导致行分组为单个输出行——行保留其单独的标识。在幕后，窗口函数能够访问的不仅仅是查询结果的当前行。
并给出了一个漂亮的 SQL 单行示例：（组内排名）
SELECT depname, empno, salary, rank() OVER (PARTITION BY depname ORDER BY salary DESC) FROM empsalary;
| 部门名称 | empno | 薪水 | 秩 |
|---|---|---|---|
| 发展 | 8 | 6000 | 1 |
| 发展 | 10 | 5200 | 2 |
| 发展 | 11 | 5200 | 2 |
| 发展 | 9 | 4500 | 4 |
| 发展 | 7 | 4200 | 5 |
| 人员 | 2 | 3900 | 1 |
| 人员 | 5 | 3500 | 2 |
| 销售量 | 1 | 5000 | 1 |
| 销售量 | 4 | 4800 | 2 |
| 销售量 | 3 | 4800 | 2 |
最后一件事：您可能也对 pandas' 感兴趣pipe，它类似于apply但工作方式略有不同，并为内部操作提供了更大的工作范围。看这里了解更多
| 归档时间： |
|
| 查看次数： |
58933 次 |
| 最近记录： |