pandas.DataFrame.rolling#

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

提供滚动窗口计算。

参数:
windowint, timedelta, str, offset, or BaseIndexer subclass

移动窗口的间隔。

如果为整数，则为每个窗口的开始和结束之间的差值。窗口中的点数取决于 closed 参数。

如果为 timedelta、str 或 offset，则为每个窗口的时间段。每个窗口的大小将可变，具体取决于包含在时间段内的观测值。这仅对 datetimelike 索引有效。要了解更多关于 offset 和频率字符串的信息，请参阅 此链接。

如果为 BaseIndexer 子类，则窗口边界基于定义的 get_window_bounds 方法。其他滚动关键字参数，即 min_periods、center、closed 和 step 将传递给 get_window_bounds。

min_periodsint, default None

窗口中需要有值所需的最小观测值数量；否则，结果为 np.nan。

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

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

centerbool, default False

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

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

win_typestr, default None

如果为 None，则所有点都均匀加权。

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

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

onstr, optional

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

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

closedstr, default None

确定窗口中点的包含性。

如果为 'right'，则使用窗口 (first, last]，表示最后一个点包含在计算中。

如果为 'left'，则使用窗口 [first, last)，表示第一个点包含在计算中。

如果为 'both'，则使用窗口 [first, last]，表示窗口中的所有点都包含在计算中。

如果为 'neither'，则使用窗口 (first, last)，表示窗口中的第一个和最后一个点不包含在计算中。

() 和 [] 分别引用开集和闭集表示法。

默认 None ('right')。

stepint，默认为 None

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

methodstr {‘single’, ‘table’}, default ‘single’

按单列或行 ('single') 或在整个对象 ('table') 上执行滚动操作。

此参数仅在方法调用中指定 engine='numba' 时实现。

返回:
pandas.api.typing.Window or pandas.api.typing.Rolling

如果传递了 win_type，则返回 Window 实例。否则，返回 Rolling 实例。

另请参阅

expanding

提供扩展变换。

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

window

窗口长度为 2 个观测值的滚动求和。

>>> df.rolling(2).sum()
     B
0  NaN
1  1.0
2  3.0
3  NaN
4  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.0
1  1.0
2  3.0
3  2.0
4  4.0

center

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

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

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

step

窗口长度为 2 个观测值的滚动求和，最少 1 个观测值即可计算值，步长为 2。

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

win_type

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

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

on

窗口跨度为 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
本页内容