pandas.Series.rolling#

Series.rolling(window, min_periods=None, center=False, win_type=None, on=None, closed=None, step=None, method='single')[源代码]#

提供滚动窗口计算。

参数:

窗口int, timedelta, str, offset, 或 BaseIndexer 子类

移动窗口的大小。

如果是整数，则为每个窗口使用的固定观测数。

如果是一个 timedelta、str 或 offset，每个窗口的时间周期。每个窗口的大小将根据时间周期内包含的观测值而变化。这仅对类日期时间索引有效。要了解更多关于偏移量和频率字符串的信息，请参见此链接。

如果是一个 BaseIndexer 子类，窗口边界基于定义的 get_window_bounds 方法。额外的滚动关键字参数，即 min_periods、center、closed 和 step 将被传递给 get_window_bounds。

min_periodsint, 默认为 None

窗口中所需的最小观测数以获得一个值；否则，结果为 np.nan。

对于由偏移量指定的窗口，min_periods 将默认为 1。

对于由整数指定的窗口，min_periods 将默认为窗口的大小。

centerbool, 默认为 False

如果为 False，将窗口标签设置为窗口索引的右边缘。

如果为真，将窗口标签设置为窗口索引的中心。

win_typestr, 默认为 None

如果 None ，所有点都是均匀加权的。

如果是字符串，它必须是有效的 scipy.signal 窗口函数。

某些 Scipy 窗口类型需要在聚合函数中传递额外的参数。这些额外参数必须与 Scipy 窗口类型方法签名中指定的关键字匹配。

开str, 可选

对于一个 DataFrame，计算滚动窗口的列标签或索引级别，而不是 DataFrame 的索引。

提供的整数列被忽略并从结果中排除，因为整数索引不用于计算滚动窗口。

关闭str, 默认为 None

如果 'right'，窗口中的第一个点不包括在计算中。

如果 'left'，窗口中的最后一个点不包括在计算中。

如果 'both'，窗口中没有任何点被排除在计算之外。

如果 'neither' ，窗口中的第一个和最后一个点将不参与计算。

默认 None ('right')。

步骤int, 默认为 None

在每个 step 结果处评估窗口，相当于切片为 [::step]。 window 必须是一个整数。使用除 None 或 1 以外的 step 参数将产生一个与输入形状不同的结果。

Added in version 1.5.0.

方法str {‘single’, ‘table’}, 默认 ‘single’

Added in version 1.3.0.

对每列或每行执行滚动操作 ('single') 或对整个对象执行 ('table')。

只有在方法调用中指定 engine='numba' 时，此参数才被实现。

返回:

pandas.api.typing.Window 或 pandas.api.typing.Rolling: 如果传递了 win_type ，则返回 Window 的实例。否则，返回 Rolling 的实例。

参见

扩展: 提供扩展变换。
ewm: 提供指数加权函数。

备注

有关进一步的使用细节和示例，请参见窗口操作。

例子

>>> df = pd.DataFrame({"B": [0, 1, 2, np.nan, 4]})
>>> df
     B
0  0.0
1  1.0
2  2.0
3  NaN
4  4.0

窗口

使用窗口长度为2个观测值的滚动总和。

>>> df.rolling(2).sum()
     B
NaN
1.0
3.0
NaN
NaN

使用2秒窗口跨度的滚动总和。

>>> df_time = pd.DataFrame(
...     {"B": [0, 1, 2, np.nan, 4]},
...     index=[
...         pd.Timestamp("20130101 09:00:00"),
...         pd.Timestamp("20130101 09:00:02"),
...         pd.Timestamp("20130101 09:00:03"),
...         pd.Timestamp("20130101 09:00:05"),
...         pd.Timestamp("20130101 09:00:06"),
...     ],
... )

>>> df_time
                       B
2013-01-01 09:00:00  0.0
2013-01-01 09:00:02  1.0
2013-01-01 09:00:03  2.0
2013-01-01 09:00:05  NaN
2013-01-01 09:00:06  4.0

>>> df_time.rolling("2s").sum()
                       B
2013-01-01 09:00:00  0.0
2013-01-01 09:00:02  1.0
2013-01-01 09:00:03  3.0
2013-01-01 09:00:05  NaN
2013-01-01 09:00:06  4.0

使用具有2个观测值的前瞻窗口进行滚动求和。

>>> indexer = pd.api.indexers.FixedForwardWindowIndexer(window_size=2)
>>> df.rolling(window=indexer, min_periods=1).sum()
     B
0  1.0
1  3.0
2  2.0
3  4.0
4  4.0

min_periods

使用窗口长度为2个观测值的滚动总和，但只需最少1个观测值即可计算值。

>>> df.rolling(2, min_periods=1).sum()
     B
0.0
1.0
3.0
2.0
4.0

center

滚动求和，结果赋值给窗口索引的中心。

>>> df.rolling(3, min_periods=1, center=True).sum()
     B
1.0
3.0
3.0
6.0
4.0

>>> df.rolling(3, min_periods=1, center=False).sum()
     B
0.0
1.0
3.0
3.0
6.0

步骤

使用窗口长度为2个观测值的滚动和，至少需要1个观测值来计算一个值，步长为2。

>>> df.rolling(2, min_periods=1, step=2).sum()
     B
0  0.0
2  3.0
4  4.0

win_type

使用Scipy 'gaussian' 窗口类型的窗口长度为2的滚动和。聚合函数中需要 std。

>>> df.rolling(2, win_type="gaussian").sum(std=3)
          B
     NaN
0.986207
2.958621
     NaN
     NaN

开

使用窗口长度为2天的滚动总和。

>>> df = pd.DataFrame(
...     {
...         "A": [
...             pd.to_datetime("2020-01-01"),
...             pd.to_datetime("2020-01-01"),
...             pd.to_datetime("2020-01-02"),
...         ],
...         "B": [1, 2, 3],
...     },
...     index=pd.date_range("2020", periods=3),
... )

>>> df
                    A  B
2020-01-01 2020-01-01  1
2020-01-02 2020-01-01  2
2020-01-03 2020-01-02  3

>>> df.rolling("2D", on="A").sum()
                    A    B
2020-01-01 2020-01-01  1.0
2020-01-02 2020-01-01  3.0
2020-01-03 2020-01-02  6.0