pandas.Series.rolling#

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

提供滚动窗口计算。

参数
windowInt、Offset或BaseIndexer子类

移动窗口的大小。

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

如果是偏移量,则为每个窗口的时间段。每个窗口的大小将根据时间段中包含的观测值而可变。这仅对类似日期时间的索引有效。要了解更多有关偏移量和频率字符串的信息,请参阅 this link

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

min_periodsInt,默认为无

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

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

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

center布尔值,默认为False

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

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

win_type字符串,默认为无

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

如果是字符串,则必须是有效的 scipy.signal window function

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

on字符串,可选

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

假定整型列被忽略并从结果中排除,因为整型索引不用于计算滚动窗口。

axisInt或str,默认为0

如果 0'index' ,在各行之间滚动。

如果 1'columns' ,在柱子上滚动。

closed字符串,默认为无

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

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

如果 'both' ,则窗口中的无点不在计算范围内。

如果 'neither' 时,窗口中的第一个和最后一个点不在计算范围内。

Default None ('right').

在 1.2.0 版更改: 现在支持带有固定窗的闭合参数。

stepInt,默认为无

..版本已添加::1.5.0

每隔一次对窗口进行评估 step 结果,相当于切片为 [::step]window 必须是整数。使用除None或1以外的Step参数将生成与输入形状不同的结果。

methodStr{‘Single’,‘TABLE’},默认为‘Single’

1.3.0 新版功能.

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

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

退货
Window 子类,如果 win_type 已通过
Rolling 子类IF win_type 未通过

参见

expanding

提供扩展转换。

ewm

提供指数加权函数。

注意事项

看见 Windowing Operations 获取更多用法详细信息和示例。

示例

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