Question

编辑：我强调了这个问题，因为它可能过于介入了。问题的内容如下所示。

我想更多地了解使用DataFrame.rolling或Series.rolling时实际创建的对象：

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

一些背景知识：考虑使用np.as_strided的常用替代品。此代码段本身并不重要，但其结果是我在提出此问题时的参考点。

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)

此处rwindows将采用1d或2d ndarray并构建等于指定窗口大小的滚动“块”（如下所示）。 .rolling对象如何与下面的ndarray输出进行比较？它是一个迭代器，是否为每个块存储了某些属性？或完全不同的东西？我尝试使用__dict__和_get_index()之类的属性/方法在对象上使用制表符完成，但他们并没有告诉我太多。我在pandas中也看到了_create_blocks方法 - 它是否与strided方法类似？

# 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]]]

第2部分，额外学分

使用上面的NumPy方法（OLS实现here）是必要的，因为pandas.core.window.Rolling.apply中的func必须

从ndarray输入生成单个值* args和** kwargs 传递给函数

所以参数不能是另一个滚动对象。即。

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'

所以这真的是我上面的问题出现的地方。为什么传递的函数必须使用NumPy数组并生成单个标量值，这与.rolling对象的布局有什么关系？

Answer 1

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

那就是说，我会给我两分钱：熊猫＆＃39;整个滚动机制依赖于numpy函数apply_along_axis。特别是它在pandas中使用here。它与windows.pyx cython模块一起使用。在你的系列中，out是聚合的滚动窗口。对于典型的聚合函数，它会为您有效地处理它们，但对于自定义聚合函数（使用apply()），它在windows.pyx中使用roll_generic()。

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()

......并制作：

（第一列是索引值，可以在此处忽略，以及下一个示例。）

注意我们如何提供现有的numpy聚合函数。这就是想法。我们应该能够提供我们想要的任何东西，只要它符合聚合函数的作用，即采用值向量并从中产生单个值。这是另一个创建自定义聚合函数的函数，在本例中是窗口的L2范数：

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

如果您不熟悉lambda函数，则与以下内容相同：

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

为了确保，我们可以手动检查np.sqrt(0**2 + 1**2 + 2**2)确实是2.236068。

[在原始编辑中，在]最后一段代码片段中，您的代码可能比您预期的要早。在调用df.apply(...)之前失败您试图在将数字2传递给df之前将名为df.apply(...)的滚动对象添加到数字2中。滚动对象不是您进行操作的东西。您提供的聚合函数通常也不符合聚合函数。 a是一个包含窗口值的列表，b将是您传入的常量额外参数。如果您愿意，它可以是滚动对象，但它通常不会你想做的事情。为了更清楚，这里有一些类似于你在原始编辑中所做的事情，但有效：

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]

这是一个人为的例子，但是我要表明它可以传递你想要的任何一个常量，甚至是你正在使用的滚动对象。动态部分是您案例中的第一个参数a或我的案例中的window_list。所有已定义的窗口（以单个列表的形式）将逐个传递到该函数中。

根据您的后续评论，这可能是您正在寻找的内容：

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]

请注意，只有在一次对列进行操作时才有效。如果您想在窗口中进行一些数学运算，然后将其存储在keep中，那也很好。

尽管如此，如果没有更多关于你想要达到的目标的信息，很难建立一个适合你需要的例子。

如果您的最终目标是创建滞后变量的数据框，那么我将使用shift()使用实际列：

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

（可能有一些更漂亮的方式，但它完成了工作。）

关于第一个代码段中的变量b，请记住pandas中的DataFrames通常不作为任意维度/对象的张量处理。您可以将任何内容填充到其中，但最终字符串，时间对象，整数和浮点数是预期的。这可能是大熊猫的设计者不愿意将滚动聚合转换为非标量值的原因。它看起来似乎不允许使用简单的字符串作为聚合函数的输出。

无论如何，我希望这回答你的一些问题。如果没有让我知道，我会尝试在评论或更新中帮助您。

关于滚动对象的_create_blocks()函数的最终说明。

当您使用_create_blocks()的{{1}}参数时，freq函数会处理重建索引和分箱。

如果您使用freq，例如，周期rolling：

freq=W

...然后我们逐周获得分档（不滚动）的原始数据：

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这样的聚合并获取：

sum

...用测试总和检验：50 = 2 + 9 + 16 + 23。

如果您不使用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作为参数，则只返回原始数据结构：

freq

......产生......

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)

...并用于滚动窗口聚合。

pandas滚动对象如何工作？

第2部分，额外学分

1 个答案: