Pandas 适用于多列输出的滚动

我正在编写一个代码，它将滚动窗口应用于将返回多列的函数。

输入：熊猫系列
预期输出：3 列 DataFrame

def fun1(series, ):
    # Some calculations producing numbers a, b and c
    return {"a": a, "b": b, "c": c} 

res.rolling('21 D').apply(fun1)

资源内容：

time
2019-09-26 16:00:00    0.674969
2019-09-26 16:15:00    0.249569
2019-09-26 16:30:00   -0.529949
2019-09-26 16:45:00   -0.247077
2019-09-26 17:00:00    0.390827
                         ...   
2019-10-17 22:45:00    0.232998
2019-10-17 23:00:00    0.590827
2019-10-17 23:15:00    0.768991
2019-10-17 23:30:00    0.142661
2019-10-17 23:45:00   -0.555284
Length: 1830, dtype: float64

Error:

TypeError: must be real number, not dict

我尝试过的：

• 在 apply 中更改 raw=True
• 在 apply 中使用 lambda 函数
• 以列表/numpy 数组/数据帧/系列的形式返回 fun1 中的结果。

我还浏览了SO中的许多相关帖子，声明一些：

• Pandas - 在多列上使用 `.rolling()` https://stackoverflow.com/questions/51615849/pandas-using-rolling-on-multiple-columns
• 从 pandas.rolling_apply 返回两个值 https://stackoverflow.com/questions/22218438/returning-two-values-from-pandas-rolling-apply
• 如何将函数应用于 Pandas 数据框的两列 https://stackoverflow.com/questions/13331698/how-to-apply-a-function-to-two-columns-of-pandas-dataframe
• 将 pandas 函数应用于列以创建多个新列？ https://stackoverflow.com/questions/16236684/apply-pandas-function-to-column-to-create-multiple-new-columns/16245109

但指定的解决方案均不能解决此问题。

有没有直接的解决方案？

这里有一个hacky回答使用rolling，生成一个 DataFrame：

import pandas as pd
import numpy as np

dr = pd.date_range('09-26-2019', '10-17-2019', freq='15T')
data = np.random.rand(len(dr))

s = pd.Series(data, index=dr)

output = pd.DataFrame(columns=['a','b','c'])

row = 0

def compute(window, df):
    global row
    a = window.max()
    b = window.min()
    c = a - b
    df.loc[row,['a','b','c']] = [a,b,c]
    row+=1    
    return 1
    
s.rolling('1D').apply(compute,kwargs={'df':output})

output.index = s.index

似乎是rolling apply函数总是期望返回一个数字，以便根据计算立即生成一个新的系列。

我正在通过制作一个新的来解决这个问题outputDataFrame（具有所需的输出列），并在函数内写入该数据帧。我不确定是否有办法获取滚动对象中的索引，所以我改为使用global增加写入新行的次数。鉴于以上几点，您需要return一些数字。所以虽然实际上rolling操作返回一系列1, output修改为：

In[0]:
s

Out[0]:
2019-09-26 00:00:00    0.106208
2019-09-26 00:15:00    0.979709
2019-09-26 00:30:00    0.748573
2019-09-26 00:45:00    0.702593
2019-09-26 01:00:00    0.617028
  
2019-10-16 23:00:00    0.742230
2019-10-16 23:15:00    0.729797
2019-10-16 23:30:00    0.094662
2019-10-16 23:45:00    0.967469
2019-10-17 00:00:00    0.455361
Freq: 15T, Length: 2017, dtype: float64

In[1]:
output

Out[1]:
                           a         b         c
2019-09-26 00:00:00  0.106208  0.106208  0.000000
2019-09-26 00:15:00  0.979709  0.106208  0.873501
2019-09-26 00:30:00  0.979709  0.106208  0.873501
2019-09-26 00:45:00  0.979709  0.106208  0.873501
2019-09-26 01:00:00  0.979709  0.106208  0.873501
                      ...       ...       ...
2019-10-16 23:00:00  0.980544  0.022601  0.957943
2019-10-16 23:15:00  0.980544  0.022601  0.957943
2019-10-16 23:30:00  0.980544  0.022601  0.957943
2019-10-16 23:45:00  0.980544  0.022601  0.957943
2019-10-17 00:00:00  0.980544  0.022601  0.957943

[2017 rows x 3 columns]

这感觉更像是一种利用rolling比预期用途，所以我有兴趣看到一个更优雅的答案。

UPDATE：感谢@JuanPi，您可以使用以下方式获取滚动窗口索引这个答案 https://stackoverflow.com/a/60918101/13386979。所以一个非global答案可能如下所示：

def compute(window, df):
    a = window.max()
    b = window.min()
    c = a - b
    df.loc[window.index.max(),['a','b','c']] = [a,b,c]  
    return 1