Ë
|
nñúhu ã ó d Z ddlmZ ddlZddlmZ ddlmZ ddlZddl m
|
Z
|
ddl m Z m Z mZmZ ddlZddlmZmZmZ ddlmc mc mZ dd lm Z dd
|
l m Z dd l m Z m!Z! dd l"m#Z#m$Z$m%Z%m&Z&m'Z' dd l(m)Z) ddl*m+Z+m,Z, ddl-m.Z. ddl/m0Z0 ddl1m2Z2 ddl3m4Z4 ddl5m6Z6 ddl7m8Z8 ddl9m:c m;Z< ddl=m>Z>m?Z?m@Z@mAZA ddlBmCZCmDZDmEZEmFZFmGZG ddlHmIZI ddlJmKZKmLZL ddlMmNZNmOZO ddlPmQZQmRZRmSZSmTZTmUZUmVZVmWZWmXZXmYZYmZZZ ddl[m\Z\m]Z]m^Z^ e r.dd l_m`Z`maZambZb dd lcmdZdmeZemfZfmgZgmhZhmiZi dd ljmkZkmlZl dd lmmnZn dd lompZp dd!lqmrZr G d" d#e8« Zs G d$ d%es« Zt G d& d'es« Zu G d( d)es« Zv G d* d+ev« Zweuj ew_ G d, d-etew« Zxy).zc
|
Provide a generic structure to support window functions,
|
similar to how we have a Groupby object.
|
é )Ú annotationsN)Ú timedelta)Úpartial)Údedent)Ú TYPE_CHECKINGÚAnyÚCallableÚLiteral)Ú
|
BaseOffsetÚ TimedeltaÚ to_offset)Úimport_optional_dependency)Ú DataError)Údeprecate_kwargÚdoc)Úensure_float64Úis_boolÚ
|
is_integerÚis_numeric_dtypeÚneeds_i8_conversion)Ú
|
ArrowDtype)Ú ABCDataFrameÚ ABCSeries)Únotna)Úexecutor)Ú factorize)ÚResamplerWindowApply)ÚExtensionArray)ÚSelectionMixin)Ú BaseIndexerÚFixedWindowIndexerÚGroupbyIndexerÚVariableWindowIndexer)Ú DatetimeIndexÚIndexÚ
|
MultiIndexÚ PeriodIndexÚTimedeltaIndex)Úconcat)Úget_jit_argumentsÚmaybe_use_numba)Úflex_binary_momentÚzsqrt)
|
Ú _shared_docsÚcreate_section_headerÚkwargs_numeric_onlyÚ kwargs_scipyÚ numba_notesÚtemplate_headerÚtemplate_returnsÚtemplate_see_alsoÚwindow_agg_numba_parametersÚwindow_apply_parameters)Ú'generate_manual_numpy_nan_agg_with_axisÚgenerate_numba_apply_funcÚgenerate_numba_table_func)ÚHashableÚIteratorÚSized)Ú ArrayLikeÚAxisÚNDFrameTÚQuantileInterpolationÚWindowingRankTypeÚnpt)Ú DataFrameÚSeries)ÚNDFrame©Ú BaseGrouper)Ú dtype_to_unitc óÊ e Zd ZU dZg Zded< e« Zded< ded< d"dd d#d
|
Zd$d Z d%d Z
|
d&d'd Z d(dZ d)dZ d*d+dZd&dZd,dZd Zd-dZd.dZd/dZd0dZed1d« Zd2dZd3dZ d& d4dZ d* d5d Z d6 d7d Z d8d Z d9 d:d Z d& d;d Z d! Z e Z!y)<Ú
|
BaseWindowz7Provides utilities for performing windowing operations.ú list[str]Ú _attributeszfrozenset[Hashable]Ú
|
exclusionsr% Ú_onN)Ú selectionc óê || _ || _ || _ | | _ || _ || _ || _ || _ ||j |« nd | _ |
|
| _
|
d | _ | j G| j dk( r | j j | _ nÅ| j j | _ n©t | j t « r| j | _ n}t | j t" « rJ| j | j j v r(t! | j | j « | _ nt% d| j d« | | _ | j) « y )Nr zinvalid on specified as z3, must be a column (of DataFrame), an Index or None)ÚobjÚonÚclosedÚstepÚwindowÚ min_periodsÚcenterÚwin_typeÚ_get_axis_numberÚaxisÚmethodÚ _win_freq_i8ÚindexrO ÚcolumnsÚ
|
isinstancer% r Ú
|
ValueErrorÚ
|
_selectionÚ _validate) ÚselfrR rV rW rX rY r[ rS rT rU r\ rP s úMH:\Change_password\venv_build\Lib\site-packages\pandas/core/window/rolling.pyÚ__init__zBaseWindow.__init__ s' ð ØØ Ø Ø Ø&ÔØ Ø Ø26Ð2BC×(Ñ(¨Ô.È Ø Ø(,ÔØ 77?ØyyA~Ø 88>>ð 88×+Ñ+Ü ¤Ô 'ØwwDHÜ ¤,Ô /°D·G±G¸t¿x¹x×?OÑ?OÑ4OÜ TXX d§g¡gÑ .Ó/DHä Ø*¨4¯7©7¨)ð 4Dð Dóð ð
|
$Ø Õó c ó | j t | j « s t d« | j t | j « s t d« | j dk r t d« t | j
|
« r>| j | j
|
kD r%t d| j d| j
|
« | j | j dvr t d« t | j t t f« st d t | « « t | j
|
t « r°t j | j
|
j « j" j% « }t j t « j « j" j% « }||k7 r+t t | j
|
« j& d
|
« | j( d vr t d « | j* ;t | j* « s t d « | j* dk r t d« y y )Nzcenter must be a booleanz min_periods must be an integerr zmin_periods must be >= 0z min_periods z must be <= window )ÚrightÚbothÚleftÚneitherz3closed must be 'right', 'left', 'both' or 'neither'zinvalid type: z? does not implement the correct signature for get_window_bounds)ÚtableÚsinglez!method must be 'table' or 'singlezstep must be an integerzstep must be >= 0)rX r ra rW r rV rT r` rR r r Ú TypeErrorÚtyper ÚinspectÚ signatureÚget_window_boundsÚ
|
parametersÚkeysÚ__name__r\ rU )rd Úget_window_bounds_signatureÚexpected_signatures re rc zBaseWindow._validate¬ sù Ø ;;Ð "¬7°4·;±;Ô+?Ü Ð 7Ó8Ð 8Ø × Ñ Ð 'Ü d× .Ñ .Ô/Ü Ð!AÓBÐBØ× Ñ !Ò#Ü Ð!;Ó<Ð<Ü$++Ô&¨4×+;Ñ+;¸d¿k¹kÒ+IÜ Ø" 4×#3Ñ#3Ð"4Ð4GÈÏ É À}ÐUóð ð ;;Ð " t§{¡{ð ;
|
ñ (
|
ô Ð RÓSÐ SÜ$((¤Y´ Ð$=Ô>Ün¬T°$«Z¨LÐ 9Ó:Ð :Ü dkk¤;Ô /ô +2×*;Ñ*;Ø ×-Ñ-ó+çjð (ô ")×!2Ñ!2Ü ×/Ñ/ó"çjð ð +Ð.@Ò@Ü ÜDKKÓ(×1Ñ1Ð2ð 3Bð Cóð ð ;;Ð 1Ñ 1Ü Ð @ÓAÐ AØ 99Ð Ü diiÔ(Ü Ð!:Ó;Ð;Øyy1}Ü Ð!4Ó5Ð5ð ð !rg c ó0 t |« t |« k7 r$t dt |« dt |« d« t |« || j xs dz dz
|
| j xs dz k7 r(t dt |« d| d| j d« y ) Nzstart (z ) and end (z ) bounds must be the same lengthé zstart and end bounds (z)) must be the same length as the object (z) divided by the step (z) if given and rounded up)Úlenra rU )rd ÚstartÚendÚnum_valss re Ú_check_window_boundsz BaseWindow._check_window_bounds× s« ô u:SÒ !Ü Ø#e* [´°S³°
|
ð ; ð óð ô u:( d§i¡i¢n°1Ñ5¸Ñ9¸t¿y¹yº~ÈAÑNÒ NÜ Ø(¬¨U«¨ ð 5"Ø"* Ð+BÀ4Ç9Á9À+ð N*ð+óð ð Org c ó\ |t |« t |« k( r|S |dd| j
S )zJ
|
Slices the index for a given result and the preset step.
|
N)r{ rU )rd r^ Úresults re Ú_slice_axis_for_stepz BaseWindow._slice_axis_for_stepæ s9 ð ~¤ V£´°E³
|
Ò!:ð ð
|
ð |$))|Ñ$ð
|
rg c óÄ | j j dk( rG|rDt | j j « s$t t | « j d| d« yyy)zö
|
Validate numeric_only argument, raising if invalid for the input.
|
|
Parameters
|
----------
|
name : str
|
Name of the operator (kernel).
|
numeric_only : bool
|
Value passed by user.
|
rz ú.z does not implement numeric_onlyN)Ú _selected_objÚndimr ÚdtypeÚNotImplementedErrorrp rv )rd ÚnameÚ numeric_onlys re Ú_validate_numeric_onlyz!BaseWindow._validate_numeric_onlyð sg ð × Ñ × #Ñ # qÒ (Ù Ü$ T×%7Ñ%7×%=Ñ%=Ô>ä%Ü:×&Ñ&Ð' q¨¨Ð.NÐOóð ð ?ð ð )rg c ó0 |j dgdg¬« }|S )z¹Subset DataFrame to numeric columns.
|
|
Parameters
|
----------
|
obj : DataFrame
|
|
Returns
|
-------
|
obj subset to numeric-only columns.
|
Únumberr )ÚincludeÚexclude)Ú select_dtypes)rd rR r s re Ú_make_numeric_onlyz BaseWindow._make_numeric_only s" ð ×"Ñ"¨H¨:À ¸}Ð"ÓMØ rg c óÂ | j `t | j t « sF|j dk( r7|j |j
|
j | j g« d¬« }|j dkD r"|s| j dk( r| j |« }| j dk( r2|j dd¬« }|j j « |_
|
|S )úA
|
Split data into blocks & return conformed data.
|
é F)r_ Úcopyrz Úfloat64)r ) rS r` r% r Úreindexr_ Ú
|
differencer[ r ÚastypeÚ_mgrÚ consolidate)rd rR r s re Ú _create_datazBaseWindow._create_data s¬ ð
|
77Ð ¤z°$·'±'¼5Ô'AÀcÇhÁhÐRSÂmØ++ c§k¡k×&<Ñ&<¸d¿g¹g¸YÓ&GÈe+ÓTCØ 88a<\¨T¯Y©Y¸!ª^ð ×)Ñ)¨#Ó.CØ 99>Ø**Y¨U*Ó3CØxx×+Ñ+Ó-CHØ
|
rg c óÀ | | j }| j D ci c] }|t | |« }}| j ||« } t | « |fd|i|¤}|S c c}w )a
|
Sub-classes to define. Return a sliced object.
|
|
Parameters
|
----------
|
key : str / list of selections
|
ndim : {1, 2}
|
requested ndim of result
|
subset : object, default None
|
subset to act on
|
rP )rR rM ÚgetattrÚ_infer_selectionrp )rd Úkeyr ÚsubsetÚattrÚkwargsrP Únew_wins re Ú_gotitemzBaseWindow._gotitem# sp ð >ØXXFð 9=×8HÑ8HÖI°$ dÓ+Ñ+ÐIÐIà×)Ñ)¨#¨vÓ6 Ø $t*VÑC¨yÐC¸FÑCØùò Js Ac óº || j v rt j | |« S || j v r| | S t dt | « j d| d« )Nú'z' object has no attribute ')Ú_internal_names_setÚobjectÚ__getattribute__rR ÚAttributeErrorrp rv )rd r¢ s re Ú __getattr__zBaseWindow.__getattr__; sd Ø 4×+Ñ+Ñ +Ü×*Ñ*¨4°Ó6Ð 6Ø 488Ñ Ø:Ð ä ØT
|
×#Ñ#Ð$Ð$?À¸vÀQÐ Gó
|
ð
|
rg c ó6 | j j « S ©N)rR Ú_dir_additions©rd s re r¯ zBaseWindow._dir_additionsE s Øxx×&Ñ&Ó(Ð(rg c ó fd j D « }dj |« }t « j d| dS )z@
|
Provide a nice str repr of our rolling object.
|
c 3 ój K | ]* }t |d « |d dk7 r| dt |« , y w)Nr Ú_ú=)r )Ú.0Ú attr_namerd s re ú <genexpr>z&BaseWindow.__repr__.<locals>.<genexpr>L sF øè ø ò
|
àÜtY¨Ó-Ð9¸iȹlÈcÒ>Qð k7 4¨Ó3Ð4Ô 5ñ
|
ùs 03ú,z [ú])rM Újoinrp rv )rd Ú
|
attrs_listÚattrss ` re Ú__repr__zBaseWindow.__repr__H sF ø ó
|
à !× -Ñ -ô
|
|
ð
|
Ó$Üt*×%Ñ%Ð& b¨¨¨qÐ1Ð1rg c # óÆ K | j j | j « }| j |« }| j « }|j t |« | j | j | j | j ¬« \ }}| j ||t |« « t ||« D ]" \ }}|j t ||« }| $ y w©N©Ú
|
num_valuesrW rX rT rU )r
Úset_axisrO r Ú_get_window_indexerrs r{ rW rX rT rU r ÚzipÚilocÚslice)rd rR Úindexerr| r} ÚsÚer s re Ú__iter__zBaseWindow.__iter__T sÆ è ø Ø× Ñ ×)Ñ)¨$¯(©(Ó3Ø× Ñ Ó$Ø×*Ñ*Ó,à ×.Ñ.Ü3xØ ×(Ñ(Ø;;Ø;;Øð /ó
|
|
sð ×!Ñ! %¨¬c°#«hÔ7äsOò DAqØXXe A qkÑ*FØLñ ùs C C!c ó t |j « r/t dt | « j d|j d« t |t « r0|j t j t j ¬« }n t |« }t j |« }|j « r%t j |t j |« }|S # t t f$ r }t d|j « |d}~ww xY w)z1Convert input to numpy arrays for Cython routineszops for z for this dtype z are not implemented)Úna_valuezcannot handle this type -> N)r r r rp rv r` r Úto_numpyÚnpr Únanr ra ro ÚisinfÚanyÚwhere)rd ÚvaluesÚerrÚinfs re Ú _prep_valueszBaseWindow._prep_valuesf sÝ ä v||Ô ,Ü%Ø4 :×.Ñ.Ð/ð 0Ø Ð&:ð<óð ð SÜ&¤.Ô1Ø ¬¯©¼b¿f¹f ÓEä'¨Ó/ô
|
hhvÓ Ø 779ÜXXc¤2§6¡6¨6Ó2Fà øô IÐ&ò SÜÐ 9¸&¿,¹,¸ Ð HÓIÈsÐ Rûð Sús ÁA C Ã D
|
Ã,DÄD
|
c óX ddl m} | j | j j |j
|
« sñ| j j } || j | j j
|
|d¬« }||j v r|||< y ||j
|
j v ry || j j v rf| j j }|j }|j |« }|j |d | « } t | « }
|
|j |
|
||« y |||< y y y )Nr ©rE F©r^ r r )ÚpandasrE rS rO Úequalsr^ r rR r_ Únamesr
Úget_locÚ intersectionr{ Úinsert) rd r rR rE r Ú extra_colÚold_colsÚnew_colsÚold_locÚoverlapÚnew_locs re Ú_insert_on_columnz BaseWindow._insert_on_column~ sù õ "à 77Ñ t§x¡x§¡°s·y±yÔ'AØ88==DÙ txx¨t¯x©x¯~©~ÀDÈuÔUIØv~~Ñ%à (t Ø ×+Ñ+Ñ+ØØ×+Ñ+×3Ñ3Ñ3à ×-Ñ-×5Ñ5Ø!>>Ø"×*Ñ*¨4Ó0Ø"×/Ñ/°¸¸'Ð0BÓCÜ g,Ø g t¨YÕ7ð )t ð% (BÐ rg c óZ t | j t t t f« r| j j
|
S t | j j t « rL| j j j dv r*| j j t j ¬« S y )NÚmM©r ) r` rO r' r$ r( Úasi8r r ÚkindrÍ rÎ Úint64r° s re Ú _index_arrayzBaseWindow._index_array sm ô dhh¤¬m¼^Ð LÔ MØ88==Ð Ü ¬
|
Ô 3¸¿¹¿¹×8KÑ8KÈtÑ8SØ88×$Ñ$¬2¯8©8Ð$Ó4Ð 4Ørg c óÎ |j d dk( r |j d dkD r t d« |j d dk( r|j d« S | j ||« |S )z Validate and finalize result.rz r ú No numeric types to aggregater )Úshaper r ræ )rd ÚoutrR s re Ú_resolve_outputzBaseWindow._resolve_output sa à 99Q<1Ò §¡¨1¡ °Ò!1ÜÐ ;Ó<Ð <Ø 99Q<1Ò Ø::iÓ(Ð (à × Ñ s CÔ(Ø
|
rg c óê t | j t « r | j S | j ,t | j
|
| j | j ¬« S t | j ¬« S )z[
|
Return an indexer class that will compute the window start and end bounds
|
)Ú index_arrayÚ window_sizerX )rõ )r` rV r r] r# rí rX r! r° s re rà z BaseWindow._get_window_indexerª s_ ô dkk¤;Ô /Ø;;Ð Ø × Ñ Ð (Ü(Ø × -Ñ -Ø × -Ñ -Ø{{ôð ô
|
"¨d¯k©kÔ:Ð:rg c ó | j | j « }|dk( r t |« j t « } | j |j « } ||« }| j |j |« }|j |||j ¬« S # t t f$ r}t d« |d}~ww xY w)z5
|
Series version of _apply_columnwise
|
Úcountrï N©r^ r )r r
r r ÚintrÖ Ú_valuesro r r r r^ Ú _constructorr )rd Úhomogeneous_funcr rR rÓ rÔ r r^ s re Ú _apply_serieszBaseWindow._apply_series¸ sµ ð × Ñ × 2Ñ 2Ó3à 7?ä*×#Ñ#¤CÓ(Cð FØ×&Ñ& s§{¡{Ó3Fñ " &Ó)Ø×)Ñ)¨#¯)©)°VÓ<Ø× Ñ ¨e¸#¿(¹(Ð ÓCÐCøô Ô.Ð/ò FÜÐ ;Ó<À#Ð Eûð Fús Á B  B=Â, B8Â8B=c ó¶ | j ||« | j j dk( r| j ||« S | j | j |« }|dk( r=t |« j t « }|j j « |_ | j dk( r |j }g }g }t |j « « D ]A \ }} | j |« } ||« }
|
|j' |
|
« |j' |« C | j) |j* t- |« dkD r|d nd« } t/ |« j1 || |j2 j5 |« d¬« } | j dk( r | j } | j7 | |« S # t t f$ r } t# d|j$ « | d} ~ ww xY w)zl
|
Apply the given function to the DataFrame broken down into homogeneous
|
sub-frames.
|
rz r÷ z#Cannot aggregate non-numeric type: Nr F)r^ r_ Úverify_integrity) r r
r rý r r r rù r r r[ ÚTÚ enumerateÚ_iter_column_arraysrÖ ro r r r Úappendr r^ r{ rp Ú _from_arraysr_ Útakerò ) rd rü r r rR ÚtakerÚ
|
res_valuesÚiÚarrrÔ Úresr^ Údfs re Ú_apply_columnwisez BaseWindow._apply_columnwiseÌ s½ ð ×#Ñ# D¨,Ô7Ø × Ñ × "Ñ " aÒ 'Ø×%Ñ%Ð&6¸Ó=Ð =à× Ñ × 2Ñ 2°LÓAØ 7?ä*×#Ñ#¤CÓ(CØxx×+Ñ+Ó-CHà 99>Ø%%CàØ
|
Ü × 7Ñ 7Ó 9Ó:ò FAsð Ø×'Ñ'¨Ó,ñ
|
# 3Ó'CØ × Ñ cÔ "Ø LLOð ð ×)Ñ)Ø II¬¨J«¸!Ò(;z !}Àó
|
ô #Y× #Ñ #Ø ØØKK×$Ñ$ UÓ+Ø "ð $ó
|
ð 99>ØBà×#Ñ# B¨Ó,Ð,øô+ Ô 2Ð3ò Ü Ø9¸#¿)¹)¸ÐEóàðûð ús ÃF+Æ+GÆ:GÇGc ób | j j dk( r t d« | j | j |« }| j |j « « }| j dk( r |j n|} ||« }| j dk( r |j n|}| j |j |« }|j d t |j « k( r |j n|j dd| j
}|j |||¬« } | j | |« S )zT
|
Apply the given function to the DataFrame across the entire object
|
rz z1method='table' not applicable for Series objects.N©r^ r_ )r
r ra r rÖ rÍ r[ r r r^ rð r{ r_ rU rû rò )
|
rd rü r r rR rÓ r r^ r_ rñ s
|
re Ú_apply_tablewisezBaseWindow._apply_tablewise s ð × Ñ × "Ñ " aÒ 'Ü Ð PÓQÐ QØ× Ñ × 2Ñ 2°LÓAØ×"Ñ" 3§<¡<£>Ó2Ø !YY¨!^°Ù! &Ó)Ø !YY¨!^°Ø×)Ñ)¨#¯)©)°VÓ<ð ||A¤# c§k¡kÓ"2Ò2ð KKà\ § ¡ \Ñ*ð ð
|
× Ñ v¨U¸GÐ ÓDà×#Ñ# C¨Ó-Ð-rg c óò | j ||« }| |}|dn|}nCt |t t f« s t d« |j
|
dk( r|r| j |« }t |||t |« ¬« S )ú]
|
Apply the given pairwise function given 2 pandas objects (DataFrame/Series)
|
Tz#other must be a DataFrame or Seriesr )Úpairwise) r r` r r ra r r r, Úbool)rd ÚtargetÚotherr Úfuncr s re Ú_apply_pairwisezBaseWindow._apply_pairwise sy ð ×"Ñ" 6¨<Ó8Ø =ØEà 'Ð /t°XHÜE¤L´)Ð#<Ô=Ü Ð BÓCÐ CØ ZZ1_¡ Ø×+Ñ+¨EÓ2Eä! &¨%°ÄÀXÃÔOÐOrg c óò j « j j n j d fd } j dk( r j |||« S j |||« S )aÞ
|
Rolling statistical measure using supplied function.
|
|
Designed to be used with passed-in Cython array-based functions.
|
|
Parameters
|
----------
|
func : callable function to apply
|
name : str,
|
numba_args : tuple
|
args to be passed when func is a numba func
|
**kwargs
|
additional arguments for rolling function and window function
|
|
Returns
|
-------
|
y : type of input
|
c óÀ | j dk( r| j « S fd}t j d¬« 5 || « }d d d « |S # 1 sw Y S xY w)Nr c óÔ j t | « j j j ¬« \ }}j ||t | « « | ||g¢ S r¿ )rs r{ rX rT rU r )Úxr| r} r rW Ú
|
numba_argsrd Úwindow_indexers re Úcalcz9BaseWindow._apply.<locals>.homogeneous_func.<locals>.calcY si ø Ø +× =Ñ =Ü " 1vØ +Ø ;;Ø ;;Ø ð >ó
|
sð ×)Ñ)¨%°´c¸!³fÔ=áAu c¨;ÐD¸ÒDÐDrg Úignore©Úall)Úsizer rÎ Úerrstate)rÓ r r r rW r rd r s re rü z+BaseWindow._apply.<locals>.homogeneous_funcS s^ ø ð {{aÒ Ø {{}Ð$÷
|
Eð
|
Eô Ô*ñ &Ù f ÷ &ð M÷ &ð Mús Á AÁA rn ©rÓ ú
|
np.ndarray)rà rW rõ r\ r r ) rd r r r r r£ rü rW r s `` ` @@re Ú_applyzBaseWindow._apply2 s~ ü ð4 ×1Ñ1Ó3ð × Ñ Ð+ð × Ò à ×+Ñ+ð ÷ ñ ð. ;;(Ò "Ø×)Ñ)Ð*:¸DÀ,ÓOÐ Oà×(Ñ(Ð)9¸4À ÓNÐ Nrg c ó< | j « }| j | j n |j }| j | j « }| j
|
dk( r |j }| j |j « « }|j dk( r|j dd« }|j t |« || j | j | j ¬« \ }} | j! || t |« « t" j$ }
|
t# j& ||
|
fddit) |« ¤} | |j f|| |d|¤j } | j
|
dk( r | j n| } | j+ |j, | « } |j dk( r0| j/ « } |j1 | | |j2 ¬« }|S | j+ |j4 | j « }|j1 | | |¬« }| j7 ||« S ) Nrz éÿÿÿÿrÀ Úis_grouped_kernelF)r| r} rW rø r ) rà rW rõ r r
r[ r rÖ rÍ r Úreshapers r{ rX rT rU r r Úfloat_dtype_mappingÚgenerate_shared_aggregatorr* r r^ Úsqueezerû r r_ rò )rd r Ú engine_kwargsÚ func_kwargsr rW rR rÓ r| r} Ú dtype_mappingÚ
|
aggregatorr r^ rñ r_ s re Ú _numba_applyzBaseWindow._numba_applyo sú ð ×1Ñ1Ó3ð × Ñ Ð+ð × Ò à ×+Ñ+ð ð
|
× Ñ × 2Ñ 2Ó3Ø 99>Ø%%CØ×"Ñ" 3§<¡<£>Ó2Ø ;;!Ò Ø^^ B¨Ó*FØ#×5Ñ5Ü6{Ø#Ø;;Ø;;Øð 6ó
|
|
sð ×!Ñ! %¨¬c°&«kÔ:ô
|
!×4Ñ4 Ü ×8Ñ8Ø Ø ñ
|
ð $ð
|
ô Ó.ñ
|
|
ñ Ø HHð
|
Ø ! s¸ ñ
|
ØGRñ
|
ç
|
!ð ð "YY¨!^°Ø×)Ñ)¨#¯)©)°VÓ<Ø 88q=Ø^^Ó%FØ×"Ñ" 6°¸S¿X¹XÐ"ÓFCØJà×/Ñ/°· ± ¸V¿X¹XÓFGØ×"Ñ" 6°ÀÐ"ÓHCØ×'Ñ'¨¨SÓ1Ð 1rg c ón t | |||¬« j « }|| j |d||¬« S |S )N©Úargsr£ F)Úrawr5 r£ )r ÚaggÚapply©rd r r5 r£ r s re Ú aggregatezBaseWindow.aggregate¢ s< Ü% d¨D°tÀFÔK×OÑOÓQØ >Ø::d¨°DÀ:ÓHÐ HØ rg ) NNFNr NNNrn )rR rF rW ú
|
int | NonerX ú bool | NonerY ú
|
str | Noner[ r? rS zstr | Index | NonerT r= rU r; r\ ÚstrÚreturnÚNone©r? r@ )r| r% r} r% r~ rù r? r@ r® )r^ r% r z Sized | Noner? r% )r r> r r r? r@ )rR r@ r? r@ ©F©rR r@ r r r? r@ )r¢ r> )r? r> )r? r< )rÓ r> r? r% )r rD rR rD r? r@ )r? z npt.NDArray[np.int64] | None)rñ rD rR rD r? rD )r? r )rü úCallable[..., ArrayLike]r r= r? rE )rü rD r r> r r r? úDataFrame | Series)NF)rü rD r r= r r r? rE © r rE r úDataFrame | Series | Noner r< r zFCallable[[DataFrame | Series, DataFrame | Series], DataFrame | Series]r r r? rE ©F© )r úCallable[..., Any]r r> r r r útuple[Any, ...])r rJ r. údict[str, bool] | None)"rv Ú
|
__module__Ú __qualname__Ú__doc__rM Ú__annotations__Ú frozensetrN rf rc r r r r r r¥ r¬ r¯ r½ rÊ rÖ ræ Úpropertyrí rò rà rý r r r r& r2 r: r7 rI rg re rK rK x se
ÙAà KÓ Ù&/£kJÐ#Ó1Ø Jð
|
Ø"&Ø #Ø #ØØ!%Ø !Ø Ø ð+ð ñ+à ð+ð ð +ð
|
ð +ð ð +ð ð+ð ð+ð ð+ð ð+ð ð+ð
|
ó +óZ)6ðV Ø ð Ø&0ð Ø<?ð à ó ô
|
óó( ô ó"ó0
|
ò)ó
|
2óó$ó0)ð2 òó ðóó ;ð NRðDØ 8ðDØ@JðDà óDð0 #ð 3-à2ð3-ð ð3-ð ð 3-ð
|
|
ó 3-ðp Ø "ð .à2ð.ð ð.ð ð .ð
|
|
ó .ð4Pà"ðPð )ðPð ð Pð
|
Uð Pð ð Pð
|
óPð6 #Ø&(ð ;Oà ð;Oð ð;Oð ð ;Oð
|
$ó ;Oð@ 15ð12à ð12ð .ó12òfð Crg rK c óÀ e Zd ZU dZded< ded< dgZded< dd d fd
|
Z d d fd Z d fd Zdd fd Z d fd Z
|
xZ S )ÚBaseWindowGroupbyz3
|
Provide the groupby windowing facilities.
|
rH Ú_grouperr Ú _as_indexrL rM T)rV c ó ddl m} t ||« s t d« || _ || _ |j | j j d¬« }|j d« t d« t | , |g|¢i |¤ y )Nr rG z Must pass a BaseGrouper object.r ©r_ ÚerrorsrU z step not implemented for groupby) Úpandas.core.groupby.opsrH r` ra rU rV ÚdroprÜ Úgetr Úsuperrf )rd rR rU rV r5 r£ rH Ú __class__s re rf zBaseWindowGroupby.__init__´ s| ø õ 8ä( KÔ0Ü Ð >Ó?Ð ?Ø Ø"ð hht}}× 2Ñ 2¸8hÓDà ::fÓ Ð )Ü%Ð&HÓIÐ IÜ ÑÐ.tÒ. vÓ.rg c óö t | ||||fi |¤}| j j }g |j ¢}t j
|
| j j « } | |z }
|
| j j D cg c]( } | | j j j vs| | * } } t | « t | « k7 r|j | d¬« }| j j } t j
|
| j j « }| j j j « }|r t j t |« « }n%t j g t j" ¬« }| D cg c] }|j% |« } }||j% |« }t' |t( « st) j* |g« }| j- t |j « « |j- t |j « « t) || |
|
d¬« }||_ | j. s-|j1 t t3 t | « « « ¬« }|S c c} w c c}w )Nr rX ré F©rÜ rÿ )Úlevel)r] r& rR r^ rÜ r rU r{ r[ ÚcodesÚlevelsÚindicesrÓ rÎ Ú concatenateÚlistÚarrayÚintpr r` r& Ú from_arraysÚextendrV Ú reset_indexÚrange)rd r r r r r£ r Úgrouped_object_indexÚgrouped_index_nameÚ groupby_keysÚresult_index_namesr Ú drop_columnsrb rc Ú group_indicesrÇ ÚcÚidxÚ result_indexr^ s re r& zBaseWindowGroupby._applyË s ø ô Ø Ø Ø Ø ñ
|
ð
|
ñ
|
ð $xx~~Ð Ø :Ð 3× 9Ñ 9Ð :ÐÜyy § ¡ ×!4Ñ!4Ó5 Ø )Ð,>Ñ >Ðð }}×*Ñ*ö
|
àØ$((..×.Ñ.Ñ.°#°+ò ð
|
ð
|
ô |Ó ¤ LÓ 1Ò 1à[[¨ ¸h[ÓGFà ×#Ñ#Ü4==×/Ñ/Ó0à ×-Ñ-×4Ñ4Ó6 Ù Ünn¤T¨-Ó%8Ó9Gähhr¬¯©Ô1GØ*/Ö0 Q Ð0Ð0ð Ð +Ø&×+Ñ+¨GÓ4CÜ c¤:Ô.Ü ×,Ñ,¨c¨UÓ3Ø LLcii Ô )Ø MM$szzÓ*Ô +ä!Ø EÐ!3Àeô
|
ð $ Ø~~Ø×'Ñ'¬d´5¼¸\Ó9JÓ3KÓ.LÐ'ÓMFØ ùòI
|
ùò$ 1s Á?-I1ÆI6c óÔ |j | j j d¬« }t | ||||« }It fd| j j j « D « « st |« }t | j j j « D cg c], }|j |« j |j « . c}« }d | j j j « D « } g }
|
g } t t t! | « D ][ } t# j$ t# j& | « |« } t) | « \ }}|
|
j+ |« | j+ |« ] nï| j j, }
|
| j j. } | j j j « }|r t# j0 t |« « }n%t# j& g t" j2 ¬« }|j4 dk( rd}nt |j6 « }|
|
D cg c]' }t# j$ |j |« |« ) }
|
}t9 |j t: « r^t |j j, « }t |j j. « }t |j j « }n5t) |j « \ }}|g}|g}|j j< g}|
|
|z }| |z }| j j |z }t; |||d¬« }||_ |S c c}w c c}w ) r r rX c 3 óL K | ] }t |« t « k( y wr® )r{ )rµ Úgroupr s re r· z4BaseWindowGroupby._apply_pairwise.<locals>.<genexpr> s# øè ø ò )
|
Ø).CJ#e*Õ $ñ)
|
ùs !$c 3 óF K | ] }t j |« y wr® )ÚcomÚmaybe_make_list)rµ Úpairs re r· z4BaseWindowGroupby._apply_pairwise.<locals>.<genexpr>& s è ø ò Ø.2×#Ñ# D×)ñùs !ré rz Fr` ) r[ rU rÜ r] r r! rd rÓ r{ r) r r r^ ru Úmaprf rÄ rÎ Úrepeatrg r r rb rc re rh r r_ r` r& r )rd r r r r r r Úold_result_lenÚ
|
gb_indicesÚgb_pairsÚ groupby_codesÚgroupby_levelsÚ gb_level_pairÚlabelsrb rc rr rÇ Ú repeat_byrs Ú result_codesÚ result_levelsÚ result_namesÚ idx_codesÚ
|
idx_levelsru r^ s ` re r z!BaseWindowGroupby._apply_pairwise sÎ ù ð T§]¡]×%8Ñ%8ÀÓJÜÑ(¨°¸À$È ÓUà Ñ ¤Só )
|
Ø26·-±-×2GÑ2G×2NÑ2NÓ2Pô)
|
õ &
|
ô ! [NÜð '+§m¡m×&;Ñ&;×&BÑ&BÓ&Döà"ð KK
|
Ó+×3Ñ3°F·L±LÕAòóFñØ6:·m±m×6KÑ6K×6PÑ6PÓ6RôHð MØ Nä!$¤T¬3°¨>Ó!:ò . ܤ2§8¡8¨MÓ#:¸NÓKÜ )¨&Ó 1 vØ ×$Ñ$ UÔ+Ø ×%Ñ% fÕ-ñ .ð !MM× /Ñ /Mð "]]× 1Ñ 1Nà MM× 1Ñ 1× 8Ñ 8Ó :MÙ Ü ..¬¨mÓ)<Ó=ä (( 2¬R¯W©WÔ5à{{aÒ Ø ä §¡Ó / à?Lö Ø:; !&& /¨9Õ5ð Mð ô fll¤JÔ /Ü § ¡ × 2Ñ 2Ó3LÜ § ¡ ×!4Ñ!4Ó 5MÜ § ¡ × 2Ñ 2Ó3Lä$-¨f¯l©lÓ$;Ñ !IzØ %;LØ 'LMØ "LL× -Ñ -Ð.Lð % |Ñ3 Ø&¨ Ñ6 Ø}}×*Ñ*¨\Ñ9 ä!Ø <¨|Èeô
|
ð $ Ø ùòuùòF s Â-1M É
|
,M%c ó |j snt j t | j j
|
j « « « j t j « }|j |« }t | - ||« S )r ) ÚemptyrÎ re rf rU rd rÓ r rì r r] r )rd rR r Ú groupby_orderr^ s re r z BaseWindowGroupby._create_data\ sf ø ð yyÜ NN¬4°· ± ×0EÑ0E×0LÑ0LÓ0NÓ+OÓ P× WÑ WÜó Mð ((=Ó)CÜwÑ# C¨ Ó6Ð6rg c ó | j %| j j | j « }t | |||¬« S )N)r¡ )rS rR Ú set_indexrO r] r¥ )rd r r r¡ r^ s re r¥ zBaseWindowGroupby._gotitemj s> ø ð 77Ð àXX×'Ñ'¨¯©Ó1FÜwÑ T°&Ð Ó9Ð9rg )rR rE rU rH rV r r? r@ rH )
|
r rJ r r> r r r rK r? rE rF rB rC r® ) rv rM rN rO rP rM rf r& r r r¥ Ú __classcell__©r^ s @re rT rT « sæ ø
ñð ÓØOØ (\KÓ)ð ñ /à ð/ð ð /ð
|
ð /ð
|
õ/ð6 #Ø&(ð ;à ð;ð ð;ð ð ;ð
|
$ð ;ð
|
õ;ðzRà"ðRð )ðRð ð Rð
|
Uð Rð ð Rð
|
õRöh 7÷ :ñ :rg rT c ón e Zd ZdZg d¢Z fdZd#dZ d$ d%dZ ee d e
|
d« e
|
d« d d
|
¬ « d « Z e Z ee ed « ee ed« e ed« e ed« e
|
d« ddd¬« d&d'd« Z ee ed « ee ed« e ed« e ed« e
|
d« ddd¬« d&d'd« Z ee ed « ee ed« e ed« e ed« e
|
d« dd d ¬« d(d)d « Z ee ed « ee ed« e ed« e ed« e
|
d « dd d!¬« d(d)d"« Z xZS )*ÚWindowaä
|
Provide rolling window calculations.
|
|
Parameters
|
----------
|
window : int, timedelta, str, offset, or BaseIndexer subclass
|
Size of the moving window.
|
|
If an integer, the fixed number of observations used for
|
each window.
|
|
If a timedelta, str, or offset, the time period of each window. Each
|
window will be a variable sized based on the observations included in
|
the time-period. This is only valid for datetimelike indexes.
|
To learn more about the offsets & frequency strings, please see `this link
|
<https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`__.
|
|
If a BaseIndexer subclass, the window boundaries
|
based on the defined ``get_window_bounds`` method. Additional rolling
|
keyword arguments, namely ``min_periods``, ``center``, ``closed`` and
|
``step`` will be passed to ``get_window_bounds``.
|
|
min_periods : int, default None
|
Minimum number of observations in window required to have a value;
|
otherwise, result is ``np.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 default
|
to the size of the window.
|
|
center : bool, 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_type : str, default None
|
If ``None``, all points are evenly weighted.
|
|
If a string, it must be a valid `scipy.signal window function
|
<https://docs.scipy.org/doc/scipy/reference/signal.windows.html#module-scipy.signal.windows>`__.
|
|
Certain Scipy window types require additional parameters to be passed
|
in the aggregation function. The additional parameters must match
|
the keywords specified in the Scipy window type method signature.
|
|
on : str, optional
|
For a DataFrame, a column label or Index level on which
|
to calculate the rolling window, rather than the DataFrame's index.
|
|
Provided integer column is ignored and excluded from result since
|
an integer index is not used to calculate the rolling window.
|
|
axis : int or str, default 0
|
If ``0`` or ``'index'``, roll across the rows.
|
|
If ``1`` or ``'columns'``, roll across the columns.
|
|
For `Series` this parameter is unused and defaults to 0.
|
|
.. deprecated:: 2.1.0
|
|
The axis keyword is deprecated. For ``axis=1``,
|
transpose the DataFrame first instead.
|
|
closed : str, 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 excluded
|
from calculations.
|
|
Default ``None`` (``'right'``).
|
|
step : int, default None
|
|
.. versionadded:: 1.5.0
|
|
Evaluate the window at every ``step`` result, equivalent to slicing as
|
``[::step]``. ``window`` must be an integer. Using a step argument other
|
than None or 1 will produce a result with a different shape than the input.
|
|
method : str {'single', 'table'}, default 'single'
|
|
.. versionadded:: 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 specifying ``engine='numba'``
|
in the method call.
|
|
Returns
|
-------
|
pandas.api.typing.Window or pandas.api.typing.Rolling
|
An instance of Window is returned if ``win_type`` is passed. Otherwise,
|
an instance of Rolling is returned.
|
|
See Also
|
--------
|
expanding : Provides expanding transformations.
|
ewm : Provides exponential weighted functions.
|
|
Notes
|
-----
|
See :ref:`Windowing Operations <window.generic>` for further usage details
|
and examples.
|
|
Examples
|
--------
|
>>> 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**
|
|
Rolling sum with a window length of 2 observations.
|
|
>>> df.rolling(2).sum()
|
B
|
0 NaN
|
1 1.0
|
2 3.0
|
3 NaN
|
4 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
|
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
|
|
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()
|
B
|
0 1.0
|
1 3.0
|
2 2.0
|
3 4.0
|
4 4.0
|
|
**min_periods**
|
|
Rolling sum with a window length of 2 observations, but only needs a minimum of 1
|
observation to calculate a value.
|
|
>>> df.rolling(2, min_periods=1).sum()
|
B
|
0 0.0
|
1 1.0
|
2 3.0
|
3 2.0
|
4 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()
|
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**
|
|
Rolling sum with a window length of 2 observations, minimum of 1 observation to
|
calculate a value, and a step of 2.
|
|
>>> df.rolling(2, min_periods=1, step=2).sum()
|
B
|
0 0.0
|
2 3.0
|
4 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)
|
B
|
0 NaN
|
1 0.986207
|
2 2.958621
|
3 NaN
|
4 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 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
|
© rV rW rX rY r[ rS rT rU r\ c óü t | « t | j t « st d| j « t dd¬« }t || j d « | _ | j t d| j « t | j t « r t d« t | j « r| j dk r t d« | j dk7 r t d « y )
|
NzInvalid win_type zscipy.signal.windowsz,Scipy is required to generate window weight.)Úextraz6BaseIndexer subclasses not implemented with win_types.r ú&window must be an integer 0 or greaterrn z+'single' is the only supported method type.)r] rc r` rY r> ra r r Ú_scipy_weight_generatorrV r r r r\ )rd Úsignalr^ s re rc zWindow._validate| sÜ ø Ü ÑÔä$--¬Ô-Ü Ð 0°· ± °Ð @ÓAÐ AÜ+Ø "Ð*Xô
|
ô (/¨v°t·}±}ÀdÓ'KÔ$Ø × 'Ñ 'Ð /Ü Ð 0°· ± °Ð @ÓAÐ Aä dkk¤;Ô /Ü%ØHóð ô $++Ô&¨$¯+©+¸ª/Ü Ð EÓFÐ Fà ;;(Ò "Ü%Ð&SÓTÐ Tð #rg c ól |dkD r.t |d« g}t j |t |« « }|S )zT
|
Center the result in the window for weighted rolling aggregations.
|
r N)rÆ rÎ r Útuple)rd r ÚoffsetÚ lead_indexers re Ú_center_windowzWindow._center_window s7 ð A:Ü ! &¨$Ó /Ð0LÜWWV¤E¨,Ó$7Ñ 8Ó9FØ rg c óÚ j j fi |¤ j rt « dz
|
dz ndd fd } j |||« dd j
|
S )a+
|
Rolling with weights statistical measure using supplied function.
|
|
Designed to be used with passed-in Cython array-based functions.
|
|
Parameters
|
----------
|
func : callable function to apply
|
name : str,
|
numeric_only : bool, default False
|
Whether to only operate on bool, int, and float columns
|
numba_args : tuple
|
unused
|
**kwargs
|
additional arguments for scipy windows if necessary
|
|
Returns
|
-------
|
y : type of input
|
rz r r c ó | j dk( r| j « S fd}t j d¬« 5 t j || « « }d d d « j
|
rj « }S # 1 sw Y )xY w)Nr c óÞ t j t j gz « }t j | |f« } | j j « S t « « S r® )rÎ rg rÏ re rW r{ )r Úadditional_nansr r rd rV s re r z5Window._apply.<locals>.homogeneous_func.<locals>.calcà sk ø Ü"$§(¡(¬B¯F©F¨8°fÑ+<Ó"=ÜNN A Ð#7Ó8ÙØØØ(,×(8Ñ(8Ð(DD×$Ñ$óð ô KNÈfË+óð rg r r )r" r rÎ r# ÚasarrayrX r )rÓ r r r r rd rV s re rü z'Window._apply.<locals>.homogeneous_func½ sw ø ð {{aÒ Ø {{}Ð$÷ ô Ô*ñ 2ä¡D¨£LÓ1÷ 2ð {{Ø ×,Ñ,¨V°VÓ<àM÷ 2ð 2ús ¿ BÂB Nr$ )r rV rX r{ r rU ) rd r r r r r£ rü r rV s `` @@re r& z Window._apply sv û ð: .×-Ñ-Ø KKñ
|
Ø!ñ
|
ð ,0¯;ª;#f+ / aÒ'¸A÷ ð ð0 ×%Ñ%Ð&6¸¸lÓKÙ tyyLñ
|
ð
|
rg r: z£
|
See Also
|
--------
|
pandas.DataFrame.aggregate : Similar DataFrame method.
|
pandas.Series.aggregate : Similar Series method.
|
at
|
Examples
|
--------
|
>>> df = pd.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6], "C": [7, 8, 9]})
|
>>> df
|
A B C
|
0 1 4 7
|
1 2 5 8
|
2 3 6 9
|
|
>>> df.rolling(2, win_type="boxcar").agg("mean")
|
A B C
|
0 NaN NaN NaN
|
1 1.5 4.5 7.5
|
2 2.5 5.5 8.5
|
zSeries/DataFrameÚ ©Úsee_alsoÚexamplesÚklassr[ c óT t | |||¬« j « }| || « }|S )Nr4 )r r7 r9 s re r: zWindow.aggregateÙ s1 ô@ & d¨D°tÀFÔK×OÑOÓQØ >á$ZFà rg Ú
|
ParametersÚReturnsúSee AlsoÚExamplesaï >>> ser = pd.Series([0, 1, 5, 2, 8])
|
|
To get an instance of :class:`~pandas.core.window.rolling.Window` we need
|
to pass the parameter `win_type`.
|
|
>>> type(ser.rolling(2, win_type='gaussian'))
|
<class 'pandas.core.window.rolling.Window'>
|
|
In order to use the `SciPy` Gaussian window we need to provide the parameters
|
`M` and `std`. The parameter `M` corresponds to 2 in our example.
|
We pass the second parameter `std` as a parameter of the following method
|
(`sum` in this case):
|
|
>>> ser.rolling(2, win_type='gaussian').sum(std=3)
|
0 NaN
|
1 0.986207
|
2 5.917243
|
3 6.903450
|
4 9.862071
|
dtype: float64
|
Úrollingzweighted window sumÚsum©Ú window_methodÚaggregation_descriptionÚ
|
agg_methodc óN t j } | j |fd|d|¤S )Nr° ©r r )Úwindow_aggregationsÚroll_weighted_sumr& ©rd r r£ Ú window_funcs re r° z
|
Window.sum s= ôN *×;Ñ; ð t{{Ø ð
|
àØ%ñ
|
ð ñ
|
ð
|
rg aº >>> ser = pd.Series([0, 1, 5, 2, 8])
|
|
To get an instance of :class:`~pandas.core.window.rolling.Window` we need
|
to pass the parameter `win_type`.
|
|
>>> type(ser.rolling(2, win_type='gaussian'))
|
<class 'pandas.core.window.rolling.Window'>
|
|
In order to use the `SciPy` Gaussian window we need to provide the parameters
|
`M` and `std`. The parameter `M` corresponds to 2 in our example.
|
We pass the second parameter `std` as a parameter of the following method:
|
|
>>> ser.rolling(2, win_type='gaussian').mean(std=3)
|
0 NaN
|
1 0.5
|
2 3.0
|
3 3.5
|
4 5.0
|
dtype: float64
|
zweighted window meanÚmeanc óN t j } | j |fd|d|¤S )Nr» r¶ )r· Úroll_weighted_meanr& r¹ s re r» z Window.mean4 s= ôL *×<Ñ< ð t{{Ø ð
|
àØ%ñ
|
ð ñ
|
ð
|
rg a¾ >>> ser = pd.Series([0, 1, 5, 2, 8])
|
|
To get an instance of :class:`~pandas.core.window.rolling.Window` we need
|
to pass the parameter `win_type`.
|
|
>>> type(ser.rolling(2, win_type='gaussian'))
|
<class 'pandas.core.window.rolling.Window'>
|
|
In order to use the `SciPy` Gaussian window we need to provide the parameters
|
`M` and `std`. The parameter `M` corresponds to 2 in our example.
|
We pass the second parameter `std` as a parameter of the following method:
|
|
>>> ser.rolling(2, win_type='gaussian').var(std=3)
|
0 NaN
|
1 0.5
|
2 8.0
|
3 4.5
|
4 18.0
|
dtype: float64
|
zweighted window varianceÚvarc ó t t j |¬« }|j dd « | j |fd|d|¤S )N©Úddofr r¾ r¶ )r r· Úroll_weighted_varÚpopr& )rd rÁ r r£ rº s re r¾ z
|
Window.vare sD ôL Ô 1× CÑ CÈ$ÔO Ø
|
|
64Ô Øt{{;ÐX¨UÀ ÑXÐQWÑXÐXrg aÒ >>> ser = pd.Series([0, 1, 5, 2, 8])
|
|
To get an instance of :class:`~pandas.core.window.rolling.Window` we need
|
to pass the parameter `win_type`.
|
|
>>> type(ser.rolling(2, win_type='gaussian'))
|
<class 'pandas.core.window.rolling.Window'>
|
|
In order to use the `SciPy` Gaussian window we need to provide the parameters
|
`M` and `std`. The parameter `M` corresponds to 2 in our example.
|
We pass the second parameter `std` as a parameter of the following method:
|
|
>>> ser.rolling(2, win_type='gaussian').std(std=3)
|
0 NaN
|
1 0.707107
|
2 2.828427
|
3 2.121320
|
4 4.242641
|
dtype: float64
|
z"weighted window standard deviationÚstdc ó@ t | j d|d|d|¤« S )NrÄ )rÁ r r rI )r- r¾ )rd rÁ r r£ s re rÄ z
|
Window.std s, ôL Ø DHHÐ P$ U¸ Ñ PÈÑ Pó
|
ð
|
rg )r r% r rù r? r% rH )r z,Callable[[np.ndarray, int, int], np.ndarray]r r> r r r rK rB ©r r ©rz F©rÁ rù r r )rv rM rN rO rM rc r r& r r. r r: r7 r3 r/ r0 r1 r4 r5 r° r» r¾ rÄ r r s @re r r t s, ø ñyòv
|
KôUó,ð #Ø&(ð <
|
à:ð<
|
ð ð<
|
ð ð <
|
ð
|
$ó <
|
ñ| Ø[Ñ!Ùð ó
|
ñ ð ó
|
ð$ !Ø ô; ñ>ó? ð>ð CáØÙ lÓ+ØØÙ iÓ(ØÙ jÓ)ØÙ jÓ)Ùð ó
|
ð0 Ø 5ØôI%óL
|
|
óM%ðL
|
|
ñ ØÙ lÓ+ØØÙ iÓ(ØÙ jÓ)ØÙ jÓ)Ùð ó
|
ð. Ø 6ØôG$óJ
|
|
óK$ðJ
|
|
ñ ØÙ lÓ+ØØÙ iÓ(ØÙ jÓ)ØÙ jÓ)Ùð ó
|
ð. Ø :ØôG$óJYóK$ðJYñ
|
ØÙ lÓ+ØØÙ iÓ(ØÙ jÓ)ØÙ jÓ)Ùð ó
|
ð. Ø DØôG$óJ
|
óK$ôJ
|
rg r c ó´ e Zd ZdddZ d ddZ ddZ d ddZ d ddZ d ddZ d ddZ d dd Z
|
d dd
|
Z d dd Z ddd Z d d d ZdddZ d d dZ d d!dZ d" d#dZ d" d#dZy)$ÚRollingAndExpandingMixinc óJ t j }| j |d|¬« S )Nr÷ r¶ )r· Úroll_sumr& ©rd r rº s re r÷ z RollingAndExpandingMixin.count» s" Ü)×2Ñ2 Ø{{;¨WÀ<{ÓPÐPrg Nc ó~ |d}|i }t |« s t d« d}t |« rN|du r t d« |}| j dk( rt |fi t ||« ¤}nHt |fi t ||« ¤}n1|dv r"| t d« | j ||||« }n t d« | j |d |¬
|
« S ) NrI z'raw parameter must be `True` or `False`Fz.raw must be `True` when using the numba enginern )ÚcythonNz+cython engine does not accept engine_kwargsz)engine must be either 'numba' or 'cython'r8 )r r ) r ra r+ r\ r9 r* r: Ú_generate_cython_apply_funcr& ) rd r r6 Úenginer. r5 r£ r Ú
|
apply_funcs re r8 z RollingAndExpandingMixin.apply¿ sô ð <ØDØ >ØFäs|Ü Ð FÓGÐ Gà&(
|
Ü 6Ô "Øe|Ü Ð!QÓRÐRØ JØ{{hÒ&Ü 6Øñ Ü -¨m¸VÓ Dñ
|
ô 7Øñ Ü -¨m¸VÓ Dñ
|
ð Ð'Ñ 'Ø Ð(Ü Ð!NÓOÐOØ ×9Ñ9¸$ÀÈÈTÓRJä Ð HÓIÐ Ià{{Ø ØØ!ð ó
|
ð
|
rg c óf ddl m t t j ||||¬« |f fd }|S )Nr rØ )r5 r£ r6 Úfunctionc óH |s | j d¬« } | |||« S )NF)r^ r )rO )rÓ Úbeginr} rW r6 rE rd rº s re rÒ zHRollingAndExpandingMixin._generate_cython_apply_func.<locals>.apply_funcû s) ø Ùá ¨d¯h©h¸UÔCÙ v u¨c°;Ó?Ð ?rg )rÚ rE r r· Ú
|
roll_apply)rd r5 r£ r6 rÔ rÒ rE rº s ` @@re rÐ z4RollingAndExpandingMixin._generate_cython_apply_funcê s; ú õ "ä Ü × *Ñ *ØØØØ ô
|
ð =@÷ @ð Ðrg c ó
|
t |« rU| j dk( r.t t j « }| j |d||¬« S ddlm} | j ||« S t j }| j |d|¬« S )Nrm T©r6 rÑ r. r )Ú sliding_sumr° r¶ ) r+ r\ r8 rÎ Únansumr8 Úpandas.core._numba.kernelsrÚ r2 r· rÌ r& )rd r rÑ r. r rÚ rº s re r° z RollingAndExpandingMixin.sum s ô 6Ô "Ø{{gÒ%Ü>¼r¿y¹yÓIØzzØØ Ø!Ø"/ð "ó ð õ Cà×(Ñ(¨°mÓDÐDÜ)×2Ñ2 Ø{{;¨UÀ {ÓNÐNrg c ó t |« rW| j dk( r.t t j « }| j |d||¬« S ddlm} | j ||d¬« S t j }| j |d|¬« S ) Nrm TrÙ r ©Úsliding_min_max©Úis_maxÚmaxr¶ ) r+ r\ r8 rÎ Únanmaxr8 rÜ rß r2 r· Úroll_maxr& ©rd r rÑ r. r rß rº s re râ z RollingAndExpandingMixin.max s ô 6Ô "Ø{{gÒ%Ü>¼r¿y¹yÓIØzzØØ Ø!Ø"/ð "ó ð õ Gà×(Ñ(¨ ¸-ÐPTÐ(ÓUÐUÜ)×2Ñ2 Ø{{;¨UÀ {ÓNÐNrg c ó t |« rW| j dk( r.t t j « }| j |d||¬« S ddlm} | j ||d¬« S t j }| j |d|¬ « S )
|
Nrm TrÙ r rÞ Frà Úminr¶ ) r+ r\ r8 rÎ Únanminr8 rÜ rß r2 r· Úroll_minr& rå s re rç z RollingAndExpandingMixin.min/ s ô 6Ô "Ø{{gÒ%Ü>¼r¿y¹yÓIØzzØØ Ø!Ø"/ð "ó ð õ Gà×(Ñ(¨ ¸-ÐPUÐ(ÓVÐVÜ)×2Ñ2 Ø{{;¨UÀ {ÓNÐNrg c ó
|
t |« rU| j dk( r.t t j « }| j |d||¬« S ddlm} | j ||« S t j }| j |d|¬« S )Nrm TrÙ r )Ú sliding_meanr» r¶ ) r+ r\ r8 rÎ Únanmeanr8 rÜ rë r2 r· Ú roll_meanr& )rd r rÑ r. r rë rº s re r» z RollingAndExpandingMixin.meanE s ô 6Ô "Ø{{gÒ%Ü>¼r¿z¹zÓJØzzØØ Ø!Ø"/ð "ó ð õ Dà×(Ñ(¨ °}ÓEÐEÜ)×3Ñ3 Ø{{;¨VÀ,{ÓOÐOrg c óü t |« rN| j dk( rt t j « }nt j }| j |d||¬« S t j }| j |d|¬« S )Nrm TrÙ Úmedianr¶ ) r+ r\ r8 rÎ Ú nanmedianr8 r· Ú roll_median_cr& )rd r rÑ r. r rº s re rï z RollingAndExpandingMixin.median[ ss ô 6Ô "Ø{{gÒ%Ü>¼r¿|¹|ÓLä||à::ØØØ Ø +ð ó ð ô *×7Ñ7 Ø{{;¨XÀL{ÓQÐQrg c óê t |« r=| j dk( r t d« ddlm} t | j ||¬« « S t j fd}| j |d|¬« S ) Nrm z%std not supported with method='table'r ©Ú sliding_varrÀ c ó0 t | |||¬« « S )NrÀ )r- )rÓ rÖ r} rW rÁ rº s re Ú
|
zsqrt_funcz0RollingAndExpandingMixin.std.<locals>.zsqrt_func s ø Ü V¨U°C¸È4ÔPÓQÐ Qrg rÄ r¶ )
|
r+ r\ r rÜ rô r- r2 r· Úroll_varr& )rd rÁ r rÑ r. rô rö rº s ` @re rÄ z RollingAndExpandingMixin.stdp sw ù ô 6Ô "Ø{{gÒ%Ü)Ð*QÓRÐRÝ >ä×*Ñ*¨;¸ ÈDÐ*ÓQÓRÐ RÜ)×2Ñ2 õ Rð {{Ø ØØ%ð ó
|
ð
|
rg c óÞ t |« r4| j dk( r t d« ddlm} | j |||¬« S t t j |¬« }| j |d|¬« S )Nrm z%var not supported with method='table'r ró rÀ r¾ r¶ )
|
r+ r\ r rÜ rô r2 r r· r÷ r& )rd rÁ r rÑ r. rô rº s re r¾ z RollingAndExpandingMixin.var sq ô 6Ô "Ø{{gÒ%Ü)Ð*QÓRÐRÝ >à×$Ñ$ [°-ÀdÐ$ÓKÐ KÜ Ô 1× :Ñ :ÀÔF Ø{{Ø ØØ%ð ó
|
ð
|
rg c óJ t j }| j |d|¬« S )NÚskewr¶ )r· Ú roll_skewr& rÍ s re rú z RollingAndExpandingMixin.skew ó, Ü)×3Ñ3 Ø{{Ø ØØ%ð ó
|
ð
|
rg c ó | j d|« | j |¬« | j |¬« |z
|
j d« z S ©NÚsem©r ç à?©r rÄ r÷ Úpow©rd rÁ r s re rÿ z RollingAndExpandingMixin.sem¤ sF à ×#Ñ# E¨<Ô8Øxx \xÓ2Ø JJ LJÓ 1°DÑ 8ß
|
#c(ñð rg c óJ t j }| j |d|¬« S )NÚkurtr¶ )r· Ú roll_kurtr& rÍ s re r z RollingAndExpandingMixin.kurt« rü rg c óº |dk( rt j }n2|dk( rt j }n t t j ||¬« }| j |d|¬« S )Ng ð?g )ÚquantileÚ interpolationr r¶ )r· rä ré r Ú roll_quantiler& )rd Úqr
|
r rº s re r z!RollingAndExpandingMixin.quantile³ sX ð 8Ü-×6Ñ6KØ #XÜ-×6Ñ6Kä!Ü#×1Ñ1ØØ +ôKð {{;¨ZÀl{ÓSÐSrg c ód t t j |||¬« }| j |d|¬« S )N)r\ Ú ascendingÚ
|
percentileÚrankr¶ )r r· Ú roll_rankr& )rd r\ r Úpctr rº s re r z RollingAndExpandingMixin.rankÆ s7 ô Ü × )Ñ )ØØ Øô
|
ð {{;¨VÀ,{ÓOÐOrg c ó² j t d« j d|« ddlm fd} j j ||||« S )Nz step not implemented for covÚcovr rØ c ó8 j | « }j |« }j « }j j n |j }|j t |« |j j j ¬« \ }}j ||t |« « t j d¬« 5 t j ||z |||« }t j ||||« } t j ||||« }
|
t j t ||z « j! t j" « ||d« } || |
|
z z
|
| | z
|
z z } d d d « | j$ | j& d¬« S # 1 sw Y )xY w)NrÀ r r r FrÙ )rÖ rà rW rõ rs r{ rX rT rU r rÎ r# r· rí rÌ r r r r^ r )r ÚyÚx_arrayÚy_arrayr rW r| r} Úmean_x_yÚmean_xÚmean_yÚ count_x_yr rE rÁ rd s re Úcov_funcz.RollingAndExpandingMixin.cov.<locals>.cov_funcã s ø Ø×'Ñ'¨Ó*GØ×'Ñ'¨Ó*GØ !× 5Ñ 5Ó 7Nð ×#Ñ#Ð/ð × Ò à#×/Ñ/ð ð
|
(×9Ñ9Ü w<Ø 'Ø{{Ø{{ØYYð :ó JE3ð × %Ñ % e¨S´#°g³,Ô ?ä Ô*ñ YÜ.×8Ñ8ØgÑ% u¨c°;ó ô -×6Ñ6°wÀÀsÈKÓXÜ,×6Ñ6°wÀÀsÈKÓXÜ /× 8Ñ 8Ü' GÑ+Ó,×3Ñ3´B·J±JÓ?ÀÈÈQó ð # V¨f¡_Ñ4¸ÀiÐRVÑFVÑ9WÑX÷ Yñ &¨¯©°a·f±fÀ5ÔIÐ I÷ Yð Yús Ã
|
B FÆF©rU r r rÚ rE r r
)rd r r rÁ r r rE s ` ` @re r z RollingAndExpandingMixin.covÖ sZ ú ð 99Ð Ü%Ð&DÓEÐ EØ ×#Ñ# E¨<Ô8å!ö Jð< ×#Ñ#Ø × Ñ x°¸<ó
|
ð
|
rg c ó² j t d« j d|« ddlm fd} j j ||||« S )Nz step not implemented for corrÚcorrr rØ c ó¶ j | « }j |« }j « }j j n |j }|j t |« |j j j ¬« \ }}j ||t |« « t j d¬« 5 t j ||z |||« }t j ||||« } t j ||||« }
|
t j t ||z « j! t j" « ||d« } t j$ ||||« } t j$ ||||« } || |
|
z z
|
| | z
|
z z }| | z dz }||z }d d d « | j& | j( d¬« S # 1 sw Y )xY w)NrÀ r r r r FrÙ )rÖ rà rW rõ rs r{ rX rT rU r rÎ r# r· rí rÌ r r r r÷ r^ r )r r r r r rW r| r} r r r r Úx_varÚy_varÚ numeratorÚ denominatorr rE rÁ rd s re Ú corr_funcz0RollingAndExpandingMixin.corr.<locals>.corr_func sÚ ø Ø×'Ñ'¨Ó*GØ×'Ñ'¨Ó*GØ !× 5Ñ 5Ó 7Nð ×#Ñ#Ð/ð × Ò à#×/Ñ/ð ð
|
(×9Ñ9Ü w<Ø 'Ø{{Ø{{ØYYð :ó JE3ð × %Ñ % e¨S´#°g³,Ô ?ä Ô*ñ 1Ü.×8Ñ8ØgÑ% u¨c°;ó ô -×6Ñ6°wÀÀsÈKÓXÜ,×6Ñ6°wÀÀsÈKÓXÜ /× 8Ñ 8Ü' GÑ+Ó,×3Ñ3´B·J±JÓ?ÀÈÈQó ô ,×4Ñ4ØU C¨°dóô ,×4Ñ4ØU C¨°dóð &¨°©Ñ 7Ø ¨TÑ!1Ñ2ñ ð % u}°Ñ 4 Ø" [Ñ0÷' 1ñ( &¨¯©°a·f±fÀ5ÔIÐ I÷) 1ð 1ús Ã
|
C GÇGr )rd r r rÁ r r& rE s ` ` @re r z RollingAndExpandingMixin.corr s[ ú ð 99Ð Ü%Ð&EÓFÐ FØ ×#Ñ# F¨LÔ9å!ö& JðP ×#Ñ#Ø × Ñ x°¸Ló
|
ð
|
rg rB rÆ ©FNNNN© r rJ r6 r rÑ ú!Literal['cython', 'numba'] | Noner. rL r5 ztuple[Any, ...] | Noner£ zdict[str, Any] | None)
|
r5 rK r£ zdict[str, Any]r6 zbool | np.bool_rÔ rJ r? z?Callable[[np.ndarray, np.ndarray, np.ndarray, int], np.ndarray]©FNN©r r rÑ r) r. rL ©rz FNN©rÁ rù r r rÑ r) r. rL rÇ rÈ ©ÚlinearF©r Úfloatr
|
rA r r ©ÚaverageTFF©r\ rB r r r r r r ©NNrz F©r rG r r< rÁ rù r r )rv rM rN r÷ r8 rÐ r° râ rç r» rï rÄ r¾ rú rÿ r r r r r rI rg re rÊ rÊ º sÞ ôQð Ø48Ø04Ø'+Ø(,ð)
|
à ð)
|
ð ð)
|
ð 2ð )
|
ð
|
.ð )
|
ð %ð )
|
ð &ó)
|
ðVà ðð ðð ð ð
|
%ð ð
|
Ió ð6 #Ø48Ø04ð OàðOð 2ðOð .ó Oð0 #Ø48Ø04ð OàðOð 2ðOð .ó Oð0 #Ø48Ø04ð OàðOð 2ðOð .ó Oð0 #Ø48Ø04ð PàðPð 2ðPð .ó Pð0 #Ø48Ø04ð RàðRð 2ðRð .ó Rð. Ø "Ø48Ø04ð
|
àð
|
ð ð
|
ð 2ð
|
ð
|
.ó
|
ð4 Ø "Ø48Ø04ð
|
àð
|
ð ð
|
ð 2ð
|
ð
|
.ó
|
ô(
|
ôô
|
ð 08Ø "ð Tà ðTð -ðTð ó Tð* %.Ø ØØ "ð Pà!ðPð ðPð ð Pð
|
ó Pð$ ,0Ø $ØØ "ð -
|
à(ð-
|
ð ð-
|
ð ð -
|
ð
|
ó -
|
ðb ,0Ø $ØØ "ð 7
|
à(ð7
|
ð ð7
|
ð ð 7
|
ð
|
ô 7
|
rg rÊ c óÔ e Zd ZU g d¢Zded< fdZdgdZdhdZ ee d e
|
d« e
|
d « d
|
d ¬ « fd « Z e Z ee ed« e ed« e ed« e ed« e
|
d« j% dd d« ddd¬« didj fd « Z ee ed« e ed« e ed« e ed« e
|
d« ddd ¬« dk dl fd « Z ee ed« e e« ed« e ed« e ed « e ed« e
|
d « j% dd d« dd!d!¬« dm dn fd" « Z ee ed« e e« ed« e ed« e ed « e ed« e
|
d#« dd$d%¬« did d d& dn fd'« Z ee ed« e e« ed« e ed« e ed « e ed« e
|
d(« j% dd d« dd)d*¬« dm dn fd+ « Z ee ed« e e« ed« e ed« e ed « e ed« e
|
d,« j% dd d« dd-d-¬« dm dn fd. « Z ee ed« e e« ed« e ed« e ed « e ed« e
|
d/« j% dd d« dd0d0¬« dm dn fd1 « Z ee ed« e
|
d2« j% dd d« e ed3« ed« e ed« d4e ed « e
|
d5« j% dd d« ed« e
|
d6« j% dd d« dd7d8¬« do dp fd9 « Z ee ed« e
|
d2« j% dd d« e ed3« ed« e ed« d:e ed « e
|
d;« j% dd d« ed« e
|
d<« j% dd d« dd=d>¬« do dp fd? « Z ee ed« e ed« e ed« d@e ed « e
|
dA« ed« e
|
dB« ddCdD¬« didj fdE « Z ee ed« e
|
d2« j% dd d« e ed« e ed« e ed « dF ed« e
|
dG« j% dd d« ddHdI¬« dqdrdJ« Z ee ed« e ed« e ed« dKe ed « dL ed« e
|
dM« j% dd d« ddNdO¬« didj fdP « Z! ee ed« e
|
dQ« j% dd d« e ed« e ed« e ed« e
|
dR« j% dd d« ddSdS¬« e"dSdT¬U« ds dt fdV « « Z# ee dW ed« e
|
dX« j% dd d« e ed« e ed« e ed« e
|
dY« j% dd d« ddZdZ¬« du dv fd[ « Z$ ee ed« e
|
d\« j% dd d« e ed« e ed« e ed« e
|
d]« dd^d_¬« dw dx fd` « Z% ee ed« e
|
d\« j% dd d« e ed« e ed« e
|
da« j% dd d« e ed « e
|
db« j% dd d« ed« e
|
dc« j% dd d« dddde¬« dw dx fdf « Z& xZ'S )yÚRollingr rL rM c ó° t | « | j j smt | j
|
t t t f« sHt | j
|
j t « r[| j
|
j j dv r8t | j t t t f« r| j! « t# | j « }t | j
|
t « rT|j( | j
|
j* j( | j
|
j* j, z z | _ nS t1 | j
|
j « }t3 |j( « j5 |« j6 | _ | j8 d| _ | j: t= d« y t | j t> « ry tA | j « r| j dk r t' d« y # t$ t& f$ r }t' d| j d« |d }~ww xY w# t$ $ r d}Y çw xY w) Nrè zpassed window z, is not compatible with a datetimelike indexÚnsrz z,step is not supported with frequency windowsr r )!r] rc rR r r` rO r$ r( r' r r rë rV r> r r Ú _validate_datetimelike_monotonicr ro ra ÚnanosÚfreqÚnr] rI r Úas_unitÚ_valuerW rU r r r )rd r= rÔ Úunitr^ s re rc zRolling._validateL sÎ ø Ü ÑÔð HHNNÜ$((¤]´NÄKÐ$PÔQÜ488>>¬:Õ6¸4¿8¹8¿>¹>×;NÑ;NÐRVÒ;Vܤs¬J¼ Ð&BÕCØ × 1Ñ 1Ô 3ð Ü §¡Ó-ô $((¤KÔ0ð %)§J¡JØHHMM×'Ñ'¨$¯(©(¯-©-¯/©/Ñ9ñ%Õ!ð Ü(¨¯©¯ © Ó8Dô %.¨d¯j©jÓ$9×$AÑ$AÀ$Ó$G×$NÑ$NÔ!ð × Ñ Ð'Ø#$Ô àyyÐ$Ü)ØBóð ð %ô
|
¤[Ô 1à ÜDKKÔ(¨D¯K©K¸!ªOÜ Ð EÓFÐ Fð -<øô? zÐ*ò Ü Ø$ T§[¡[ Mð 2;ð ;óð ðûð ûô !ò à Dð ús* Ã
|
H Å I ÈIÈ%H?È?IÉ IÉIc óÐ | j j r| j d« | j j s)| j j s| j d« yyy)z
|
Validate self._on is monotonic (increasing or decreasing) and has
|
no NaT values for frequency windows.
|
úvalues must not have NaTzvalues must be monotonicN)rO ÚhasnansÚ_raise_monotonic_errorÚis_monotonic_increasingÚis_monotonic_decreasingr° s re r; z(Rolling._validate_datetimelike_monotonic| sQ ð
|
88× Ò Ø × 'Ñ 'Ð(BÔ CØ×0Ò0°D·H±H×4TÒ4TØ × 'Ñ 'Ð(BÕ Cð 5UÐ0rg c óf | j }|| j dk( rd}nd}t | d| « )Nr r^ Úcolumnú )rS r[ ra )rd ÚmsgrS s re rE z Rolling._raise_monotonic_error s: Ø WWØ :ØyyA~Ø à ÜB4q Ó'Ð'rg r: z³
|
See Also
|
--------
|
pandas.Series.rolling : Calling object with Series data.
|
pandas.DataFrame.rolling : Calling object with DataFrame data.
|
aì
|
Examples
|
--------
|
>>> df = pd.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6], "C": [7, 8, 9]})
|
>>> df
|
A B C
|
0 1 4 7
|
1 2 5 8
|
2 3 6 9
|
|
>>> df.rolling(2).sum()
|
A B C
|
0 NaN NaN NaN
|
1 3.0 9.0 15.0
|
2 5.0 11.0 17.0
|
|
>>> df.rolling(2).agg({"A": "sum", "B": "min"})
|
A B
|
0 NaN NaN
|
1 3.0 4.0
|
2 5.0 5.0
|
zSeries/Dataframer¥ r¦ c ó* t | |g|¢i |¤S r® )r] r: )rd r r5 r£ r^ s re r: zRolling.aggregate s ø ôL wÑ Ð7¨Ò7°Ñ7Ð7rg r« r¬ r r® a«
|
>>> s = pd.Series([2, 3, np.nan, 10])
|
>>> s.rolling(2).count()
|
0 NaN
|
1 2.0
|
2 1.0
|
3 1.0
|
dtype: float64
|
>>> s.rolling(3).count()
|
0 NaN
|
1 NaN
|
2 2.0
|
3 2.0
|
dtype: float64
|
>>> s.rolling(4).count()
|
0 NaN
|
1 NaN
|
2 NaN
|
3 3.0
|
dtype: float64
|
ú
|
rz r¯ z count of non NaN observationsr÷ r± c ó" t | |« S r® )r] r÷ ©rd r r^ s re r÷ z Rolling.count¹ s ø ôJ w}\Ó*Ð*rg zË >>> ser = pd.Series([1, 6, 5, 4])
|
>>> ser.rolling(2).apply(lambda s: s.sum() - s.min())
|
0 NaN
|
1 6.0
|
2 6.0
|
3 5.0
|
dtype: float64
|
zcustom aggregation functionr8 Nc ó. t | ||||||¬« S )N)r6 rÑ r. r5 r£ )r] r8 )rd r r6 rÑ r. r5 r£ r^ s re r8 z Rolling.applyà s. ø ôB w}Ø ØØØ'ØØð ó
|
ð
|
rg ÚNotesa]
|
>>> s = pd.Series([1, 2, 3, 4, 5])
|
>>> s
|
0 1
|
1 2
|
2 3
|
3 4
|
4 5
|
dtype: int64
|
|
>>> s.rolling(3).sum()
|
0 NaN
|
1 NaN
|
2 6.0
|
3 9.0
|
4 12.0
|
dtype: float64
|
|
>>> s.rolling(3, center=True).sum()
|
0 NaN
|
1 6.0
|
2 9.0
|
3 12.0
|
4 NaN
|
dtype: float64
|
|
For DataFrame, each sum is computed column-wise.
|
|
>>> df = pd.DataFrame({{"A": s, "B": s ** 2}})
|
>>> df
|
A B
|
0 1 1
|
1 2 4
|
2 3 9
|
3 4 16
|
4 5 25
|
|
>>> df.rolling(3).sum()
|
A B
|
0 NaN NaN
|
1 NaN NaN
|
2 6.0 14.0
|
3 9.0 29.0
|
4 12.0 50.0
|
r° c ó( t | |||¬« S ©N)r rÑ r. )r] r° ©rd r rÑ r. r^ s re r° z Rolling.sum
|
s% ø ôJ w{Ø%ØØ'ð ó
|
ð
|
rg z® >>> ser = pd.Series([1, 2, 3, 4])
|
>>> ser.rolling(2).max()
|
0 NaN
|
1 2.0
|
2 3.0
|
3 4.0
|
dtype: float64
|
Úmaximumrâ )rÑ r. c ó( t | |||¬« S rS )r] râ )rd r rÑ r. r5 r£ r^ s re râ z Rolling.maxU s% ø ôF w{Ø%ØØ'ð ó
|
ð
|
rg zþ
|
Performing a rolling minimum with a window size of 3.
|
|
>>> s = pd.Series([4, 3, 5, 2, 6])
|
>>> s.rolling(3).min()
|
0 NaN
|
1 NaN
|
2 3.0
|
3 2.0
|
4 2.0
|
dtype: float64
|
Úminimumrç c ó( t | |||¬« S rS )r] rç rT s re rç z Rolling.min~ s% ø ôH w{Ø%ØØ'ð ó
|
ð
|
rg a¢
|
The below examples will show rolling mean calculations with window sizes of
|
two and three, respectively.
|
|
>>> s = pd.Series([1, 2, 3, 4])
|
>>> s.rolling(2).mean()
|
0 NaN
|
1 1.5
|
2 2.5
|
3 3.5
|
dtype: float64
|
|
>>> s.rolling(3).mean()
|
0 NaN
|
1 NaN
|
2 2.0
|
3 3.0
|
dtype: float64
|
r» c ó( t | |||¬« S rS )r] r» rT s re r» z Rolling.mean¨ s% ø ôV w|Ø%ØØ'ð ó
|
ð
|
rg a
|
Compute the rolling median of a series with a window size of 3.
|
|
>>> s = pd.Series([0, 1, 2, 3, 4])
|
>>> s.rolling(3).median()
|
0 NaN
|
1 NaN
|
2 1.0
|
3 2.0
|
4 3.0
|
dtype: float64
|
rï c ó( t | |||¬« S rS )r] rï rT s re rï zRolling.medianÙ s% ø ôH w~Ø%ØØ'ð ó
|
ð
|
rg z»
|
ddof : int, default 1
|
Delta Degrees of Freedom. The divisor used in calculations
|
is ``N - ddof``, where ``N`` represents the number of elements.
|
z1.4z/numpy.std : Equivalent method for NumPy array.
|
zÛ
|
The default ``ddof`` of 1 used in :meth:`Series.std` is different
|
than the default ``ddof`` of 0 in :func:`numpy.std`.
|
|
A minimum of one period is required for the rolling calculation.
|
|
a
|
|
>>> s = pd.Series([5, 5, 6, 7, 5, 5, 5])
|
>>> s.rolling(3).std()
|
0 NaN
|
1 NaN
|
2 0.577350
|
3 1.000000
|
4 1.000000
|
5 1.154701
|
6 0.000000
|
dtype: float64
|
zstandard deviationrÄ c ó* t | ||||¬« S ©N)rÁ r rÑ r. )r] rÄ ©rd rÁ r rÑ r. r^ s re rÄ z Rolling.std ó( ø ôh w{ØØ%ØØ'ð ó
|
ð
|
rg z/numpy.var : Equivalent method for NumPy array.
|
zÛ
|
The default ``ddof`` of 1 used in :meth:`Series.var` is different
|
than the default ``ddof`` of 0 in :func:`numpy.var`.
|
|
A minimum of one period is required for the rolling calculation.
|
|
a
|
|
>>> s = pd.Series([5, 5, 6, 7, 5, 5, 5])
|
>>> s.rolling(3).var()
|
0 NaN
|
1 NaN
|
2 0.333333
|
3 1.000000
|
4 1.000000
|
5 1.333333
|
6 0.000000
|
dtype: float64
|
Úvariancer¾ c ó* t | ||||¬« S r\ )r] r¾ r] s re r¾ z Rolling.var> r^ rg z:scipy.stats.skew : Third moment of a probability density.
|
zV
|
A minimum of three periods is required for the rolling calculation.
|
|
zÿ >>> ser = pd.Series([1, 5, 2, 7, 15, 6])
|
>>> ser.rolling(3).skew().round(6)
|
0 NaN
|
1 NaN
|
2 1.293343
|
3 -0.585583
|
4 0.670284
|
5 1.652317
|
dtype: float64
|
zunbiased skewnessrú c ó$ t | |¬« S ©Nr )r] rú rO s re rú z Rolling.skewy s ø ôD w|¨ |Ó6Ð6rg z:A minimum of one period is required for the calculation.
|
|
zÎ
|
>>> s = pd.Series([0, 1, 2, 3])
|
>>> s.rolling(2, min_periods=1).sem()
|
0 NaN
|
1 0.707107
|
2 0.707107
|
3 0.707107
|
dtype: float64
|
zstandard error of meanrÿ c ó | j d|« | j |¬« | j |« |z
|
j d« z S rþ r r s re rÿ z Rolling.sem sG ðF ×#Ñ# E¨<Ô8Øxx \xÓ2Ø JJ|Ó $ tÑ +ß
|
#c(ñð rg z/scipy.stats.kurtosis : Reference SciPy method.
|
z<A minimum of four periods is required for the calculation.
|
|
a]
|
The example below will show a rolling calculation with a window size of
|
four matching the equivalent function call using `scipy.stats`.
|
|
>>> arr = [1, 2, 3, 4, 999]
|
>>> import scipy.stats
|
>>> print(f"{{scipy.stats.kurtosis(arr[:-1], bias=False):.6f}}")
|
-1.200000
|
>>> print(f"{{scipy.stats.kurtosis(arr[1:], bias=False):.6f}}")
|
3.999946
|
>>> s = pd.Series(arr)
|
>>> s.rolling(4).kurt()
|
0 NaN
|
1 NaN
|
2 NaN
|
3 -1.200000
|
4 3.999946
|
dtype: float64
|
z,Fisher's definition of kurtosis without biasr c ó$ t | |¬« S rb )r] r rO s re r z Rolling.kurtÅ s ø ôL w|¨ |Ó6Ð6rg aæ
|
quantile : float
|
Quantile to compute. 0 <= quantile <= 1.
|
|
.. deprecated:: 2.1.0
|
This will be renamed to 'q' in a future version.
|
interpolation : {{'linear', 'lower', 'higher', 'midpoint', 'nearest'}}
|
This optional parameter specifies the interpolation method to use,
|
when the desired quantile lies between two data points `i` and `j`:
|
|
* linear: `i + (j - i) * fraction`, where `fraction` is the
|
fractional part of the index surrounded by `i` and `j`.
|
* lower: `i`.
|
* higher: `j`.
|
* nearest: `i` or `j` whichever is nearest.
|
* midpoint: (`i` + `j`) / 2.
|
ae
|
>>> s = pd.Series([1, 2, 3, 4])
|
>>> s.rolling(2).quantile(.4, interpolation='lower')
|
0 NaN
|
1 1.0
|
2 2.0
|
3 3.0
|
dtype: float64
|
|
>>> s.rolling(2).quantile(.4, interpolation='midpoint')
|
0 NaN
|
1 1.5
|
2 2.5
|
3 3.5
|
dtype: float64
|
r r )Ú old_arg_nameÚ new_arg_namec ó( t | |||¬« S )N)r r
|
r )r] r )rd r r
|
r r^ s re r zRolling.quantileí s& ø ôr wÑ ØØ'Ø%ð ó
|
ð
|
rg z.. versionadded:: 1.4.0
|
|
a
|
method : {{'average', 'min', 'max'}}, default 'average'
|
How to rank the group of records that have the same value (i.e. ties):
|
|
* average: average rank of the group
|
* min: lowest rank in the group
|
* max: highest rank in the group
|
|
ascending : bool, default True
|
Whether or not the elements should be ranked in ascending order.
|
pct : bool, default False
|
Whether or not to display the returned rankings in percentile
|
form.
|
a(
|
>>> s = pd.Series([1, 4, 2, 3, 5, 3])
|
>>> s.rolling(3).rank()
|
0 NaN
|
1 NaN
|
2 2.0
|
3 2.0
|
4 3.0
|
5 1.5
|
dtype: float64
|
|
>>> s.rolling(3).rank(method="max")
|
0 NaN
|
1 NaN
|
2 2.0
|
3 2.0
|
4 3.0
|
5 2.0
|
dtype: float64
|
|
>>> s.rolling(3).rank(method="min")
|
0 NaN
|
1 NaN
|
2 2.0
|
3 2.0
|
4 3.0
|
5 1.0
|
dtype: float64
|
r c ó* t | ||||¬« S )N)r\ r r r )r] r )rd r\ r r r r^ s re r z Rolling.rank,
|
s( ø ôH w|ØØ ØØ%ð ó
|
ð
|
rg a
|
other : Series or DataFrame, optional
|
If not supplied then will default to self and produce pairwise
|
output.
|
pairwise : bool, default None
|
If False then only matching columns between self and other will be
|
used and the output will be a DataFrame.
|
If True then all pairwise combinations will be calculated and the
|
output will be a MultiIndexed DataFrame in the case of DataFrame
|
inputs. In the case of missing elements, only complete pairwise
|
observations will be used.
|
ddof : int, default 1
|
Delta Degrees of Freedom. The divisor used in calculations
|
is ``N - ddof``, where ``N`` represents the number of elements.
|
zß >>> ser1 = pd.Series([1, 2, 3, 4])
|
>>> ser2 = pd.Series([1, 4, 5, 8])
|
>>> ser1.rolling(2).cov(ser2)
|
0 NaN
|
1 1.5
|
2 0.5
|
3 1.5
|
dtype: float64
|
zsample covariancer c ó* t | ||||¬« S ©N)r r rÁ r )r] r ©rd r r rÁ r r^ s re r z Rolling.covw
|
s( ø ôb w{ØØ ØØ%ð ó
|
ð
|
rg z
|
cov : Similar method to calculate covariance.
|
numpy.corrcoef : NumPy Pearson's correlation calculation.
|
ao
|
This function uses Pearson's definition of correlation
|
(https://en.wikipedia.org/wiki/Pearson_correlation_coefficient).
|
|
When `other` is not specified, the output will be self correlation (e.g.
|
all 1's), except for :class:`~pandas.DataFrame` inputs with `pairwise`
|
set to `True`.
|
|
Function will return ``NaN`` for correlations of equal valued sequences;
|
this is the result of a 0/0 division error.
|
|
When `pairwise` is set to `False`, only matching columns between `self` and
|
`other` will be used.
|
|
When `pairwise` is set to `True`, the output will be a MultiIndex DataFrame
|
with the original index on the first level, and the `other` DataFrame
|
columns on the second level.
|
|
In the case of missing elements, only complete pairwise observations
|
will be used.
|
|
ax
|
The below example shows a rolling calculation with a window size of
|
four matching the equivalent function call using :meth:`numpy.corrcoef`.
|
|
>>> v1 = [3, 3, 3, 5, 8]
|
>>> v2 = [3, 4, 4, 4, 8]
|
>>> np.corrcoef(v1[:-1], v2[:-1])
|
array([[1. , 0.33333333],
|
[0.33333333, 1. ]])
|
>>> np.corrcoef(v1[1:], v2[1:])
|
array([[1. , 0.9169493],
|
[0.9169493, 1. ]])
|
>>> s1 = pd.Series(v1)
|
>>> s2 = pd.Series(v2)
|
>>> s1.rolling(4).corr(s2)
|
0 NaN
|
1 NaN
|
2 NaN
|
3 0.333333
|
4 0.916949
|
dtype: float64
|
|
The below example shows a similar rolling calculation on a
|
DataFrame using the pairwise option.
|
|
>>> matrix = np.array([[51., 35.],
|
... [49., 30.],
|
... [47., 32.],
|
... [46., 31.],
|
... [50., 36.]])
|
>>> np.corrcoef(matrix[:-1, 0], matrix[:-1, 1])
|
array([[1. , 0.6263001],
|
[0.6263001, 1. ]])
|
>>> np.corrcoef(matrix[1:, 0], matrix[1:, 1])
|
array([[1. , 0.55536811],
|
[0.55536811, 1. ]])
|
>>> df = pd.DataFrame(matrix, columns=['X', 'Y'])
|
>>> df
|
X Y
|
0 51.0 35.0
|
1 49.0 30.0
|
2 47.0 32.0
|
3 46.0 31.0
|
4 50.0 36.0
|
>>> df.rolling(4).corr(pairwise=True)
|
X Y
|
0 X NaN NaN
|
Y NaN NaN
|
1 X NaN NaN
|
Y NaN NaN
|
2 X NaN NaN
|
Y NaN NaN
|
3 X 1.000000 0.626300
|
Y 0.626300 1.000000
|
4 X 1.000000 0.555368
|
Y 0.555368 1.000000
|
Ú correlationr c ó* t | ||||¬« S rj )r] r rk s re r z Rolling.corr¯
|
s( ø ô| w|ØØ ØØ%ð ó
|
ð
|
rg rA )rK r> rB rÆ r' r( r* r+ r, r- rÇ rÈ r. r0 r2 r4 r5 r6 )(rv rM rN rM rP rc r; rE r r. r r: r7 r3 r/ r0 r4 r5 Úreplacer÷ r7 r8 r6 r2 r° râ rç r» rï rÄ r¾ rú rÿ r r r r r r r r s @re r8 r8 ? sd ø
ò
|
Kó
|
ô.Gó`Dó(ñ Ø[Ñ!Ùð ó
|
ñ ð ó
|
ð0 !Ø ôG$óJ8óK$ðJ8ð CáØÙ lÓ+ØÙ iÓ(ØÙ jÓ)ØÙ jÓ)Ùð ó
|
÷, '$AÓ
|
Ø Ø ?ØôE#õH+óI#ðH+ñ ØÙ lÓ+Ø Ù iÓ(ØÙ jÓ)ØÙ jÓ)Ùð ó
|
|
ð Ø =Øô-ð6 Ø48Ø04Ø'+Ø(,ð
|
à ð
|
ð ð
|
ð 2ð
|
ð
|
.ð
|
ð %ð
|
ð &ô
|
ó1ð0
|
ñ$ ØÙ lÓ+ØÙ#Ó%Ù iÓ(ØÙ jÓ)ØÙ gÓ&ØÙ jÓ)Ùð, ó.
|
÷\ '$AÓ
|
Ø Ø %Øô{>ðB #Ø48Ø04ð
|
|
àð
|
|
ð 2ð
|
|
ð .ô
|
|
ó>ð~
|
|
ñ ØÙ lÓ+ØÙ#Ó%Ù iÓ(ØÙ jÓ)ØÙ gÓ&ØÙ jÓ)Ùð ó
|
|
ð Ø )Øô3ð: #ð
|
ð 59Ø04ñ
|
àð
|
ð 2ð
|
ð
|
.ô
|
ó7ð6
|
ñ ØÙ lÓ+ØÙ#Ó%Ù iÓ(ØÙ jÓ)ØÙ gÓ&ØÙ jÓ)Ùð ó
|
÷ '$AÓ
|
Ø Ø )Øô9 ð@ #Ø48Ø04ð
|
|
àð
|
|
ð 2ð
|
|
ð .ô
|
|
ó= ð<
|
|
ñ ØÙ lÓ+ØÙ#Ó%Ù iÓ(ØÙ jÓ)ØÙ gÓ&ØÙ jÓ)Ùð ó
|
÷( '$AÓ
|
Ø Ø &ØôG$ðN #Ø48Ø04ð
|
|
àð
|
|
ð 2ð
|
|
ð .ô
|
|
óK$ðJ
|
|
ñ ØÙ lÓ+ØÙ#Ó%Ù iÓ(ØÙ jÓ)ØÙ gÓ&ØÙ jÓ)Ùð ó
|
÷ '$AÓ
|
Ø Ø (Øô9 ð@ #Ø48Ø04ð
|
|
àð
|
|
ð 2ð
|
|
ð .ô
|
|
ó= ð<
|
|
ñ ØÙ lÓ+Ùð ó
|
÷ '$AÓ
|
ØÙ# EÓ*Ù iÓ(ØÙ jÓ)Ø:ØÙ gÓ&Ùð ó
|
÷ '$AÓ
|
Ù jÓ)Ùð ó
|
÷ '$AÓ
|
Ø Ø 4ØôW,ð^ Ø "Ø48Ø04ð
|
àð
|
ð ð
|
ð 2ð
|
ð
|
.ô
|
ó[,ðZ
|
ñ ØÙ lÓ+Ùð ó
|
÷ '$AÓ
|
ØÙ# EÓ*Ù iÓ(ØÙ jÓ)Ø:ØÙ gÓ&Ùð ó
|
÷ '$AÓ
|
Ù jÓ)Ùð ó
|
÷ '$AÓ
|
Ø Ø *ØôW,ð^ Ø "Ø48Ø04ð
|
àð
|
ð ð
|
ð 2ð
|
ð
|
.ô
|
ó[,ðZ
|
ñ ØÙ lÓ+ØÙ iÓ(ØÙ jÓ)ØEØÙ gÓ&Ùð ó
|
ñ
|
jÓ)Ùð
|
ó
|
ð Ø 3Øô? õB7óC ðB7ñ ØÙ lÓ+Ùð ó
|
÷ '$AÓ
|
ØÙ iÓ(ØÙ jÓ)ØÙ gÓ&ØFÙ jÓ)Ùð ó
|
|
÷ '$AÓ
|
Ø Ø 8Øô? óBóC ðBñ ØÙ lÓ+ØÙ iÓ(ØÙ jÓ)Ø:ØÙ gÓ&ØHÙ jÓ)Ùð ó
|
÷( '$AÓ
|
Ø Ø NØôG$õJ7óK$ðJ7ñ ØÙ lÓ+Ùð ó
|
÷$ '$AÓ
|
ØÙ iÓ(ØÙ jÓ)ØÙ jÓ)Ùð ó
|
÷" '$AÓ
|
Ø Ø *Ø ôa1ñd *¸3Ô?ð 08Ø "ð
|
|
à ð
|
|
ð -ð
|
|
ð ô
|
|
ó @óe1ðf
|
|
ñ ØØ&Ù lÓ+Ùð ó
|
÷ '$AÓ
|
ØÙ iÓ(ØÙ jÓ)ØÙ jÓ)Ùð ó
|
÷< '$AÓ
|
Ø Ø &Øôw<ð~ %.Ø ØØ "ð
|
à!ð
|
ð ð
|
ð ð
|
ð
|
ô
|
ó{<ðz
|
ñ ØÙ lÓ+Ùð ó
|
÷ '$AÓ
|
ØÙ iÓ(ØÙ jÓ)ØÙ jÓ)Ùð ó
|
ð Ø 3ØôQ)ðX ,0Ø $ØØ "ð
|
à(ð
|
ð ð
|
ð ð
|
ð
|
ô
|
óU)ðT
|
ñ ØÙ lÓ+Ùð ó
|
÷ '$AÓ
|
ØÙ iÓ(ØÙ jÓ)Ùð ó
|
÷
|
'$AÓ
|
ØÙ gÓ&Ùð ó
|
÷, '$AÓ
|
Ù jÓ)Ùð8 ó:
|
÷t '$AÓ
|
Ø Ø -Øôkvðr ,0Ø $ØØ "ð
|
à(ð
|
ð ð
|
ð ð
|
ð
|
ô
|
óovôn
|
rg r8 c óP e Zd ZdZej
|
ej
|
z ZddZd Zy)ÚRollingGroupbyz3
|
Provide a rolling groupby implementation.
|
c óÔ d}| j }t | j t « rjt | j « }| j j
|
j « }t |t « sJ |j dd« | j }n1| j t }| j }nt }| j }t ||| j j ||¬« }|S )z
|
Return an indexer class that will compute the window start and end bounds
|
|
Returns
|
-------
|
GroupbyIndexer
|
Nrô )rô rõ Úgroupby_indicesr Úindexer_kwargs)rí r` rV r rp Ú__dict__r Údictrà r] r# r! r" rU rd )rd rs rô Úrolling_indexerrV r s re rà z"RollingGroupby._get_window_indexer? sÈ ð 15Ø×'Ñ' Ü dkk¤;Ô /Ü " 4§;¡;Ó /OØ ![[× 1Ñ 1× 6Ñ 6Ó 8NÜ n¬dÔ3Ð 3Ð3à × Ñ }¨dÔ 3Ø[[FØ × Ñ Ð *Ü 3Oð ×&Ñ&Fä 0OØ[[FÜ'Ø#Ø Ø MM× 1Ñ 1Ø*Ø)ô
|
ð Ð rg c ód | j j r| j d« | j j j « D ]b }| j j |« }|j r+|j r8| j dn | j }t d| d| d« y)zC
|
Validate that each group in self._on is monotonic
|
rC Nr^ zEach group within z' must be monotonic. Sort the values in z first.) rO rD rE rU rd rÓ r rF rG rS ra )rd rr Úgroup_onrS s re r; z/RollingGroupby._validate_datetimelike_monotonicb s ð
|
88× Ò Ø × 'Ñ 'Ð(BÔ CØ !]]× 2Ñ 2× 9Ñ 9Ó ;ò MØxx}} ]Ó3Hà×0Ó0°H×4TÓ4Tà $§¡ W°T·W±WÜ Ø(¨¨ð -*Ø*,¨¨Wð6óð ñ rg N)r? r" ) rv rM rN rO r8 rM rT rà r; rI rg re rp rp 8 s+ ñð ×%Ñ%Ð(9×(EÑ(EÑEKó! óFrg rp )yrO Ú
|
__future__r r Údatetimer Ú functoolsr rq Útextwrapr Útypingr r r r
|
ÚnumpyrÎ Úpandas._libs.tslibsr r r Ú pandas._libs.window.aggregationsÚ_libsrV Ú aggregationsr· Úpandas.compat._optionalr Ú pandas.errorsr Úpandas.util._decoratorsr r Úpandas.core.dtypes.commonr r r r r Úpandas.core.dtypes.dtypesr Úpandas.core.dtypes.genericr r Úpandas.core.dtypes.missingr Úpandas.core._numbar Úpandas.core.algorithmsr Úpandas.core.applyr Úpandas.core.arraysr Úpandas.core.baser Úpandas.core.commonÚcoreÚcommonrz Ú pandas.core.indexers.objectsr r! r" r# Úpandas.core.indexes.apir$ r% r& r' r( Úpandas.core.reshape.concatr) Úpandas.core.util.numba_r* r+ Úpandas.core.window.commonr, r- Úpandas.core.window.docr. r/ r0 r1 r2 r3 r4 r5 r6 r7 Úpandas.core.window.numba_r8 r9 r: Úcollections.abcr; r< r= Úpandas._typingr> r? r@ rA rB rC rÚ rD rE Úpandas.core.genericrF rZ rH Ú pandas.core.arrays.datetimelikerI rK rT r rÊ r8 rp rI rg re ú<module>r sE ðñõ #ã Ý Ý Û Ý ÷ó ó ÷ñ ÷
|
?Ó >Ý >Ý #÷÷
|
õ õ 1÷õ -å 'Ý ,Ý 2Ý -Ý +ß Ð ÷ó ÷ õ õ .÷÷÷ ÷ ÷ ÷ñ ñ ÷ñ ÷ ÷ ÷õ ,Ý3å 9ôp ô pôfF:
|
ô F:ôRC
|
Zô C
|
ôLB
|
zô B
|
ôJ s
|
Ð&ô s
|
ðl ..ô:Ð&¨õ :rg
|
