Python 在SQL for DataFrame中，数组_AGG的等价物是什么？

我有一个带有price的pandas数据框，我想创建一个名为priceLags的列，如下所示：

             price        priceLags
1.           1800
2.           1750          1800

3.           1500          1750
                           1800

4.           1240          1500
                           1750
                           1800

5.           1456          1240
                           1500
                           1750

6.           1302          1456
                           1240
                           1500

priceLags由前三行的价格组成。在SQL中，它是

ARRAY_AGG(price) OVER (ORDER BY ROWS BETWEEN 1 FOLLOWING AND 3 FOLLOWING) AS priceLags

请问我怎样才能在熊猫身上做到

---

非常感谢你

创建相同结构的一种方法是：

创建滞后变量

df['lagged1']=df['price'].shift（1）
df['lagged2']=df['price'].班次（2）
df['lagged3']=df['price'].班次（3）
df
输出[1]
价格滞后1滞后2滞后3
0 1800楠楠楠楠
11750 1800.0楠楠楠
2 1500 1750.0 1800.0南
3   1240    1500.0  1750.0  1800.0
4   1456    1240.0  1500.0  1750.0
5   1302    1456.0  1240.0  1500.0

叠加这些新变量

df.set_index（'price'）.stack（dropna=False）\
.reset_index（1）.drop（'level_1'，轴=1）\
.reset_index（）.rename（列={0:'priceLags'}）
出[2]：
价格滞后
0 1800南
1800南
2 1800南
3   1750    1800.0
41750南
51750南
6   1500    1750.0
7   1500    1800.0
81500南
9   1240    1500.0
10  1240    1750.0
11  1240    1800.0
12  1456    1240.0
13  1456    1500.0
14  1456    1750.0
15  1302    1456.0
16  1302    1240.0
17  1302    1500.0

您还可以在此过程中删除空值：

df.set_index（'price'）.stack（dropna=True）.reset_index（level=1，drop=True）.reset_index（）.重命名（列={0:'priceLags'}）
出[3]：
价格滞后
0   1750    1800.0
1   1500    1750.0
2   1500    1800.0
3   1240    1500.0
...
10  1302    1240.0
11  1302    1500.0

已添加

在环顾四周之后，我发现了如何通过编程创建具有滞后时间的列。然后，我们可以堆叠和重置索引几次，以便在一次代码调用中获得最终结果：

df.assign(**{
f'{col}{t}'：df[col].shift（t）
对于滞后的t
对于df中的col
})\
.设置索引（“价格”）。堆栈（dropna=True）\\将分组为一列
.reset\ u index（level=1，drop=True）\\删除列名
.reset_index（）.rename（列={0:'priceLags'}）#重新插入正确的列名称

创建相同结构的一种方法是：

创建滞后变量

df['lagged1']=df['price'].shift（1）
df['lagged2']=df['price'].班次（2）
df['lagged3']=df['price'].班次（3）
df
输出[1]
价格滞后1滞后2滞后3
0 1800楠楠楠楠
11750 1800.0楠楠楠
2 1500 1750.0 1800.0南
3   1240    1500.0  1750.0  1800.0
4   1456    1240.0  1500.0  1750.0
5   1302    1456.0  1240.0  1500.0

叠加这些新变量

df.set_index（'price'）.stack（dropna=False）\
.reset_index（1）.drop（'level_1'，轴=1）\
.reset_index（）.rename（列={0:'priceLags'}）
出[2]：
价格滞后
0 1800南
1800南
2 1800南
3   1750    1800.0
41750南
51750南
6   1500    1750.0
7   1500    1800.0
81500南
9   1240    1500.0
10  1240    1750.0
11  1240    1800.0
12  1456    1240.0
13  1456    1500.0
14  1456    1750.0
15  1302    1456.0
16  1302    1240.0
17  1302    1500.0

您还可以在此过程中删除空值：

df.set_index（'price'）.stack（dropna=True）.reset_index（level=1，drop=True）.reset_index（）.重命名（列={0:'priceLags'}）
出[3]：
价格滞后
0   1750    1800.0
1   1500    1750.0
2   1500    1800.0
3   1240    1500.0
...
10  1302    1240.0
11  1302    1500.0

已添加

在环顾四周之后，我发现了如何通过编程创建具有滞后时间的列。然后，我们可以堆叠和重置索引几次，以便在一次代码调用中获得最终结果：

df.assign(**{
f'{col}{t}'：df[col].shift（t）
对于滞后的t
对于df中的col
})\
.设置索引（“价格”）。堆栈（dropna=True）\\将分组为一列
.reset\ u index（level=1，drop=True）\\删除列名
.reset_index（）.rename（列={0:'priceLags'}）#重新插入正确的列名称

另一种方法是定义自定义聚合函数。不是下面最优雅的代码，但可能会满足您的需要：

#导入一些包
作为pd进口熊猫
从functools导入reduce
#创建一个测试数据帧
df=pd.DataFrame([
{'a'：'hello'，'b'：1}，
{'a'：'hello'，'b'：5}，
{'a'：'hello'，'b'：6}，
{'a'：'bubye'，'b'：3}，
{'a'：'bubye'，'b'：2}，
{'a'：'bonus'，'b'：3}
])
#定义自定义聚合函数
def创建_列表（系列）：
如果len（系列）==1：
返回[x代表x系列]
返回减少（λx，y:（[x]如果类型（x）==int-else x）+[y]，系列）
#应用不同的聚合函数，包括自定义聚合函数
(
df
.groupby（“a”）
阿格先生({
“b”：[‘总和’、‘最大值’、创建列表]，
})
)

另一种方法是定义自定义聚合函数。不是下面最优雅的代码，但可能会满足您的需要：

#导入一些包
作为pd进口熊猫
从functools导入reduce
#创建一个测试数据帧
df=pd.DataFrame([
{'a'：'hello'，'b'：1}，
{'a'：'hello'，'b'：5}，
{'a'：'hello'，'b'：6}，
{'a'：'bubye'，'b'：3}，
{'a'：'bubye'，'b'：2}，
{'a'：'bonus'，'b'：3}
])
#定义自定义聚合函数
def创建_列表（系列）：
如果len（系列）==1：
返回[x代表x系列]
返回减少（λx，y:（[x]如果类型（x）==int-else x）+[y]，系列）
#应用不同的聚合函数，包括自定义聚合函数
(
df
.groupby（“a”）
阿格先生({
“b”：[‘总和’、‘最大值’、创建列表]，
})
)