编辑:我浓缩了这个问题，因为它可能太复杂了。问题的重点在下面以粗体显示。

我想了解更多有关使用 DataFrame.rolling 时实际创建的对象的信息或 Series.rolling :

print(type(df.rolling))
<class 'pandas.core.window.Rolling'>

def rwindows(a, window):
    if a.ndim == 1:
        a = a.reshape(-1, 1)
    shape = a.shape[0] - window + 1, window, a.shape[-1]
    strides = (a.strides[0],) + a.strides
    windows = np.lib.stride_tricks.as_strided(a, shape=shape, strides=strides)
    return np.squeeze(windows)

# as_strided version

a = np.arange(5)
print(rwindows(a, 3))           # 1d input
[[0 1 2]
 [1 2 3]
 [2 3 4]]

b = np.arange(10).reshape(5,2)
print(rwindows(b, 4))           # 2d input
[[[0 1]
  [2 3]
  [4 5]
  [6 7]]

 [[2 3]
  [4 5]
  [6 7]
  [8 9]]]

produce a single value from an ndarray input *args and **kwargs are passed to the function

def prod(a, b):
    return a * b
df.rolling(3).apply(prod, args=((df + 2).rolling(3),))
-----------------------------------------------------------------------
...
TypeError: unsupported operand type(s) for *: 'float' and 'Rolling'

最佳答案

我建议您查看源代码，以便深入了解滚动的作用。我特别建议你看看 rolling generic.py 中的函数和 window.py .从那里您可以查看 Window class如果您指定窗口类型或默认值 Rolling class .最后一个继承自 _Rolling_and_Expanding最终 _Rolling和 _Window .

也就是说，我要给我两分钱:Pandas 的整个滚动机制依赖于 numpy 函数 apply_along_axis .特别是使用 here在 Pandas 。它与 windows.pyx 一起使用cython 模块。在你的系列中，出现了聚合滚动窗口。对于典型的聚合函数，它可以有效地为您处理它们，但对于自定义函数(使用 apply() )，它使用 roll_generic() 在 windows.pyx .

pandas 中的滚动功能独立地对 Pandas 数据框列进行操作。它不是 python iterator , 并且是延迟加载的，这意味着在您对其应用聚合函数之前不会计算任何内容。实际应用数据滚动窗口的函数直到聚合完成之前才使用。

混淆的一个来源可能是您将滚动对象视为数据框。 (您在上一个代码片段中已将滚动对象命名为 df)。真的不是。它是一个对象，它可以通过在它所包含的窗口逻辑上应用聚合来生成数据帧。

您提供的 lambda 应用于新数据帧的每个单元格。它在旧数据框中向后(沿着每一列)使用一个窗口，并将其聚合到新数据框中的一个单元格中。聚合可以是 sum 之类的东西, mean ，你定制的东西，等等，在一些窗口大小上，比如 3。下面是一些例子:

a = np.arange(5)
df = pd.DataFrame(a, columns=['a'])
df.rolling(3).mean().dropna()

df.rolling(3).apply(np.mean).dropna()

     a
2  3.0
3  6.0
4  9.0

df.rolling(3).apply(lambda x: np.sqrt(x.dot(x))).dropna()

def euclidean_dist(x):
    return np.sqrt(x.dot(x))

df.rolling(3).apply(euclidean_dist).dropna()

          a
2  2.236068
3  3.741657
4  5.385165

a = np.arange(8)
df = pd.DataFrame(a, columns=['a'])
n = 4
rol = df.rolling(n)

def prod(window_list, constant_rol):
    return window_list.dot(constant_rol.sum().dropna().head(n))

rol.apply(prod, args=(rol,)).dropna()

# [92.0, 140.0, 188.0, 236.0, 284.0]

import numpy as np
import pandas as pd

n = 3
a = np.arange(5)
df = pd.DataFrame(a, columns=['a'])

def keep(window, windows):
    windows.append(window.copy())
    return window[-1]

windows = list()
df['a'].rolling(n).apply(keep, args=(windows,))
df = df.tail(n)
df['a_window'] = windows

   a         a_window
2  2  [0.0, 1.0, 2.0]
3  3  [1.0, 2.0, 3.0]
4  4  [2.0, 3.0, 4.0]

import numpy as np
import pandas as pd

a = np.arange(5)

df = pd.DataFrame(a, columns=['a'])
for i in range(1,3):
    df['a-%s' % i] = df['a'].shift(i)

df.dropna()

   a  a-1  a-2
2  2  1.0  0.0
3  3  2.0  1.0
4  4  3.0  2.0

import pandas as pd

a = np.arange(50)
df = pd.DataFrame(a, columns=['a'])
df.index = pd.to_datetime('2016-01-01') + pd.to_timedelta(df['a'], 'D')
blocks, obj, index = df.rolling(4, freq='W')._create_blocks(how=None)
for b in blocks:
    print(b)

               a
a               
2016-01-03   2.0
2016-01-10   9.0
2016-01-17  16.0
2016-01-24  23.0
2016-01-31  30.0
2016-02-07  37.0
2016-02-14  44.0
2016-02-21   NaN

                a
a                
2016-01-03    NaN
2016-01-10    NaN
2016-01-17    NaN
2016-01-24   50.0
2016-01-31   78.0
2016-02-07  106.0
2016-02-14  134.0
2016-02-21    NaN

import pandas as pd
a = np.arange(5)
df = pd.DataFrame(a, columns=['a'])
blocks, obj, index = df.rolling(3)._create_blocks(how=None)

for b in blocks:
    print(b)

            a
a            
2016-01-01  0
2016-01-02  1
2016-01-03  2
2016-01-04  3
2016-01-05  4

关于python - pandas 滚动对象如何工作？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/45254174/