pandas.DataFrame.rolling#

DataFrame.rolling(window,min_periods=None,center=False,win_type=None,on=None,axis=<no_default>,closed=None,step=None,method='single')[source]#

Provide rolling window calculations.

Parameters:

windowint, timedelta, str, offset, or BaseIndexer subclass

Size of the moving window.

If an integer, the fixed number of observations used foreach window.

If a timedelta, str, or offset, the time period of each window. Eachwindow will be a variable sized based on the observations included inthe time-period. This is only valid for datetimelike indexes.To learn more about the offsets & frequency strings, please seethis link.

If a BaseIndexer subclass, the window boundariesbased on the definedget_window_bounds method. Additional rollingkeyword arguments, namelymin_periods,center,closed andstep will be passed toget_window_bounds.

min_periodsint, default None

Minimum number of observations in window required to have a value;otherwise, result isnp.nan.

For a window that is specified by an offset,min_periods will default to 1.

For a window that is specified by an integer,min_periods will defaultto the size of the window.

centerbool, default False

If False, set the window labels as the right edge of the window index.

If True, set the window labels as the center of the window index.

win_typestr, default None

IfNone, all points are evenly weighted.

If a string, it must be a validscipy.signal window function.

Certain Scipy window types require additional parameters to be passedin the aggregation function. The additional parameters must matchthe keywords specified in the Scipy window type method signature.

onstr, optional

For a DataFrame, a column label or Index level on whichto calculate the rolling window, rather than the DataFrame’s index.

Provided integer column is ignored and excluded from result sincean integer index is not used to calculate the rolling window.

axisint or str, default 0

If0 or'index', roll across the rows.

If1 or'columns', roll across the columns.

ForSeries this parameter is unused and defaults to 0.

Deprecated since version 2.1.0:The axis keyword is deprecated. Foraxis=1,transpose the DataFrame first instead.

closedstr, default None

If'right', the first point in the window is excluded from calculations.

If'left', the last point in the window is excluded from calculations.

If'both', the no points in the window are excluded from calculations.

If'neither', the first and last points in the window are excludedfrom calculations.

DefaultNone ('right').

stepint, default None

Added in version 1.5.0.

Evaluate the window at everystep result, equivalent to slicing as[::step].window must be an integer. Using a step argument otherthan None or 1 will produce a result with a different shape than the input.

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

Added in version 1.3.0.

Execute the rolling operation per single column or row ('single')or over the entire object ('table').

This argument is only implemented when specifyingengine='numba'in the method call.

Returns:

pandas.api.typing.Window or pandas.api.typing.Rolling

An instance of Window is returned ifwin_type is passed. Otherwise,an instance of Rolling is returned.

See also

expanding

Provides expanding transformations.

ewm

Provides exponential weighted functions.

Notes

SeeWindowing Operations for further usage detailsand examples.

Examples

>>>df=pd.DataFrame({'B':[0,1,2,np.nan,4]})>>>df     B0  0.01  1.02  2.03  NaN4  4.0

window

Rolling sum with a window length of 2 observations.

>>>df.rolling(2).sum()     B0  NaN1  1.02  3.03  NaN4  NaN

Rolling sum with a window span of 2 seconds.

>>>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                       B2013-01-01 09:00:00  0.02013-01-01 09:00:02  1.02013-01-01 09:00:03  2.02013-01-01 09:00:05  NaN2013-01-01 09:00:06  4.0

>>>df_time.rolling('2s').sum()                       B2013-01-01 09:00:00  0.02013-01-01 09:00:02  1.02013-01-01 09:00:03  3.02013-01-01 09:00:05  NaN2013-01-01 09:00:06  4.0

Rolling sum with forward looking windows with 2 observations.

>>>indexer=pd.api.indexers.FixedForwardWindowIndexer(window_size=2)>>>df.rolling(window=indexer,min_periods=1).sum()     B0  1.01  3.02  2.03  4.04  4.0

min_periods

Rolling sum with a window length of 2 observations, but only needs a minimum of 1observation to calculate a value.

>>>df.rolling(2,min_periods=1).sum()     B0  0.01  1.02  3.03  2.04  4.0

center

Rolling sum with the result assigned to the center of the window index.

>>>df.rolling(3,min_periods=1,center=True).sum()     B0  1.01  3.02  3.03  6.04  4.0

>>>df.rolling(3,min_periods=1,center=False).sum()     B0  0.01  1.02  3.03  3.04  6.0

step

Rolling sum with a window length of 2 observations, minimum of 1 observation tocalculate a value, and a step of 2.

>>>df.rolling(2,min_periods=1,step=2).sum()     B0  0.02  3.04  4.0

win_type

Rolling sum with a window length of 2, using the Scipy'gaussian'window type.std is required in the aggregation function.

>>>df.rolling(2,win_type='gaussian').sum(std=3)          B0       NaN1  0.9862072  2.9586213       NaN4       NaN

on

Rolling sum with a window length of 2 days.

>>>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  B2020-01-01 2020-01-01  12020-01-02 2020-01-01  22020-01-03 2020-01-02  3

>>>df.rolling('2D',on='A').sum()                    A    B2020-01-01 2020-01-01  1.02020-01-02 2020-01-01  3.02020-01-03 2020-01-02  6.0