pandas.Series.rolling #

系列。滚动( window , min_periods = None , center = False , win_type = None , on = None , axis = _NoDefault.no_default , close = None , step = None , method = 'single' ) [来源] #

提供滚动窗口计算。

参数
window int、timedelta、str、offset 或 BaseIndexer 子类

移动窗口的大小。

如果是整数,则表示每个窗口使用的固定观测值数量。

如果是 timedelta、str 或 offset,则为每个窗口的时间段。每个窗口的大小将根据该时间段内包含的观察结果而变化。这仅对 datetimelike 索引有效。要了解有关偏移和频率字符串的更多信息,请参阅此链接

如果是 BaseIndexer 子类,则窗口边界基于定义的get_window_bounds方法。其他滚动关键字参数,即min_periodscenterclosedstep传递给get_window_bounds

min_periods int,默认无

窗口中需要有值的最小观测值数量;否则,结果为np.nan.

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

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

中心布尔值,默认 False

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

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

win_type str,默认无

如果None,则所有点均等加权。

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

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

str 上,可选

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

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

axis int 或 str,默认 0

如果0'index',则滚动各行。

如果1'columns',则滚动各列。

对于系列,此参数未使用,默认为 0。

自版本 2.1.0 起已弃用: axis 关键字已弃用。对于axis=1,首先转置 DataFrame。

闭合str,默认 None

如果'right',则窗口中的第一个点将从计算中排除。

如果'left',则窗口中的最后一个点将从计算中排除。

如果'both',则将窗口中的所有点排除在计算之外。

如果'neither',则窗口中的第一个点和最后一个点将从计算中排除。

默认None'right')。

步骤int,默认无

1.5.0 版本中的新增内容。

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

方法str {'single', 'table'}, 默认 'single'

1.3.0 版本中的新增功能。

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

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

返回
pandas.api.typing.Window 或 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

窗户

窗口长度为 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

最短周期

窗口长度为 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

中心

滚动总和,并将结果分配给窗口索引的中心。

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

滚动总和,窗口长度为 2 个观测值,最少 1 个观测值来计算值,步长为 2。

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

赢类型

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

>>> df.rolling(2, win_type='gaussian').sum(std=3)
          B
0       NaN
1  0.986207
2  2.958621
3       NaN
4       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