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')[исходный код]

Выполняет вычисления для скользящего окна.

Параметры:

window:int, timedelta, str, offset или подкласс BaseIndexer

Размер скользящего окна.

Если задано целое число, оно определяет фиксированное количество наблюдений, используемых для каждого окна.

Если задан объект timedelta, строка или смещение, это определяет временной интервал каждого окна. Размер каждого окна будет переменным и будет зависеть от наблюдений, входящих во временной интервал. Допустимо только для индексов типа datetime. Подробнее о смещениях и строках частоты см. по этой ссылке.

Если задан подкласс BaseIndexer, границы окна определяются на основе метода get_window_bounds. Дополнительные ключевые аргументы для скользящего окна, а именно min_periods, center, closed и step, будут переданы в get_window_bounds.

min_periods:int, по умолчанию None

Минимальное количество наблюдений в окне, необходимое для получения значения; в противном случае результатом будет np.nan.

Для окна, заданного смещением, по умолчанию min_periods равно 1.

Для окна, заданного целым числом, по умолчанию min_periods равно размеру окна.

center:bool, по умолчанию False

Если False, в качестве меток окна устанавливается правый край индекса окна.

Если True, в качестве меток окна устанавливается центр индекса окна.

win_type:str, по умолчанию None

Если задано None, все точки имеют одинаковый вес.

Если задана строка, она должна обозначать допустимую функцию окон SciPy.signal.

Для некоторых типов окон Scipy требуется передавать дополнительные параметры в функцию агрегации. Дополнительные параметры должны соответствовать именованным аргументам, указанным в сигнатуре метода типа окна Scipy.

on:str, необязательный

Для DataFrame — метка столбца или уровень индекса, по которому следует вычислять скользящее окно вместо индекса DataFrame.

Указанный целочисленный столбец игнорируется и исключается из результата, поскольку целочисленный индекс не используется для вычисления скользящего окна.

axis:int или str, по умолчанию 0

Если задано 0 или 'index', скользящее окно вычисляется по строкам.

Если задано 1 или 'columns', скользящее окно вычисляется по столбцам.

Для Series этот параметр не используется и по умолчанию равен 0.

Устарело с версии 2.1.0: Ключевой аргумент axis устарел. Для axis=1 сначала транспонируйте DataFrame.

closed:str, по умолчанию None

Если задано 'right', первая точка окна исключается из вычислений.

Если задано 'left', последняя точка окна исключается из вычислений.

Если задано 'both', ни одна точка окна не исключается из вычислений.

Если задано 'neither', первая и последняя точки окна исключаются из вычислений.

По умолчанию None ('right').

step:int, по умолчанию None

Добавлено в версии 1.5.0.

Вычислять значение окна для каждого step результата; эквивалентно срезу [::step]. window должно быть целым числом. Использование аргумента step, отличного от None или 1, приведёт к тому, что форма результата будет отличаться от формы входных данных.

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

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