ó à'·h¶|ãó2•SSKJr SSKrSSKrSSKrSSKrSSKrSSKJrJ r J r SSK J r SSK Jr SSKJrJr SSKJr SSKJrJrJrJrJrJr SSKJr SS KJr SS K!J"r"J#r# SS K$J%r%J&r&J'r' SS K(J)r)J*r*J+r+ SS K,J-r-J.r. SSK/J0r0J1r1J2r2J3r3J4r4J5r5J6r6 SSK7J8r8J9r9 SSK:J;r;Jr> SSK=J?r@ SSKAJBrBJCrCJDrD SSKEJFrF SSKGJHrH SSKIJJrJ SSKKJLrL SSKMJNrN SSKOJPrP SSKQJRrR SSKSJTrT SSKUJVrV SSKWJXrX \R²"\Z5 SSK[J\r] SSS5 \R²"\Z5 SSK[J^r^ SSS5 \(aÓ\R²"\Z5 SS K[J_r_ SSS5 \R²"\Z5 SSK[J`ra SSS5 SS!KJbrb SS"KJcrc SS#KJdrdJereJfrf SS$KgJhrhJiriJjrjJkrkJlrlJmrmJnrnJoroJprpJqrqJrrrJsrsJtrtJuruJvrvJwrwJxrx SS%K/Jyry \RôS&:¼a SS'KJ{r{J|r| OSS'K}J{r{J|r| \RôS(:¼aSS)KJ&r& OSS)K}J&r& \"S*5r~\|"S+5rO\0(a\GR\r‚\5\‚lƒ"S,S-5r„S0S1S.jjr…S2S/jr†g!,(df  GNL=f!,(df  GN==f!,(df  GN'=f!,(df  GN=f)3é)Ú annotationsN)Ú CollectionÚMappingÚSequence)Ú timedelta)Úreduce)ÚBytesIOÚStringIO)ÚPath)Ú TYPE_CHECKINGÚAnyÚCallableÚClassVarÚNoReturnÚTypeVar)Ú functions)Únegate_duration_stringÚparse_as_duration_string)Údeprecate_renamed_parameterÚ deprecatedÚissue_deprecation_warning)Úparse_into_expressionÚparse_into_list_of_expressionsÚ,parse_predicates_constraints_into_expression)Úissue_unstable_warningÚunstable)ÚBUILDING_SPHINX_DOCSÚ extend_boolÚfind_stacklevelÚ no_defaultÚnormalize_filepathÚsphinx_accessorÚwarn_null_comparison)Ú wrap_exprÚwrap_s)ÚInt64Úparse_into_datatype_expr)Ú_check_for_numpy)Únumpy)ÚCustomUFuncWarningÚOutOfBoundsErrorÚPolarsInefficientMapWarning©ÚExprArrayNameSpace©ÚExprBinaryNameSpace©ÚExprCatNameSpace©ÚExprDateTimeNameSpace©ÚExprListNameSpace©ÚExprMetaNameSpace©ÚExprNameNameSpace©ÚExprStringNameSpace©ÚExprStructNameSpace)Úthread_pool_size)Ú arg_where)ÚPyExpr)ÚPySeries)ÚIterable)ÚIOBase)Ú DataFrameÚ LazyFrameÚSeries)ÚClosedIntervalÚFillNullStrategyÚInterpolationMethodÚIntoExprÚIntoExprColumnÚMapElementsStrategyÚ NullBehaviorÚNumericLiteralÚPolarsDataTypeÚQuantileMethodÚ RankMethodÚ RoundModeÚ SchemaDictÚSearchSortedSideÚSerializationFormatÚTemporalLiteralÚWindowMappingStrategy)Ú NoDefault)éé )Ú ConcatenateÚ ParamSpec)rZé )rÚTÚPc ó•\rSrSr%SrSrS\S'1SkrS\S'\GSAS j5r GSBS jr GSBS jr GSBS jr GSCS jr GSDSjrGSESjrGSESjrGSFSjrGSFSjrGSESjrGSESjrGSESjrGSESjrGSESjrGSDSjrGSESjrGSESjrGSESjrGSESjrGSESjrGSESjrGSESjrGSDS jr GSFS!jr!GSFS"jr"GSDS#jr#GSGS$jr$GSHS%jr%GSES&jr&GSES'jr'GSES(jr(GSES)jr)GSFS*jr*GSFS+jr+GSIS,jr,GSJS-jr-GSKS.jr.\S/S0.GSLS1jj5r/GSDS2jr0S3S4.GSMS5jjr1S3S4.GSMS6jjr2GSDS7jr3GSDS8jr4GSDS9jr5GSDS:jr6GSDS;jr7GSNS<jr8GSOS=jr9GSPS>jr:GSDS?jr;GSDS@jrGSDSCjr?GSDSDjr@GSDSEjrAGSDSFjrBGSDSGjrCGSDSHjrDGSQGSRSIjjrES3SJ.GSSSKjjrFGSDSLjrGGSDSMjrHGSDSNjrISOSP.GSTSRjjrJSOSP.GSTSSjjrKSOSP.GSTSTjjrLSOSP.GSTSUjjrMSOSP.GSTSVjjrNGSDSWjrOGSDSXjrPGSUGSVSYjjrQGSWSZjrRGSXS[jrSGSDS\jrTS3SOS].GSYS^jjrUSOSOS_.GSZSajjrVGS[GS\SbjjrW\X"S`SQScSd9GS[SOSP.GS]Sejjj5rYGS[GS\SfjjrZ\X"S`SQScSd9GS[SOSP.GS]Sgjjj5r[SOSOS_.GSZShjjr\GSDSijr]GSDSjjr^GS^Skjr_GS_SOSl.GS`Smjjjr`SOSOS3SOSn.GSaSojjraGSbSpjrbGScSqjrcGSdSSs.GSeStjjjrdGSfGSgSujjreGShSvjrfGSQGSiSwjjrgGSQGSiSxjjrhGSDSyjriGSdGSjSzjjrjGSdGSjS{jjrkGSDS|jrlGSDS}jrmGSDS~jrnGSDSjroGSDS€jrpGSDSjrqGSDS‚jrrGSDSƒjrsGSDS„jrtGSDS…jruGSDS†jrvGSDS‡jrwGSDSˆjrxSOS‰.GSkSŠjjryGSDS‹jrzGSDSŒjr{GSQSSOSOSSŽ.GSlSjjjr|SSS‘.GSmS’jjr}GSDS“jr~GSDS”jrGSDS•jr€GSDS–jrGSDS—jr‚GSDS˜jrƒGSnGSoSšjjr„\…"5SSOSOS›.GSpSœjj5r†\…"5SSOSOSOS.GSqSžjj5r‡GSDSŸjrˆGSDS jr‰GSrS¡jrŠ\‹"S¢5GSsS£j5rŒGSQSOSOSOS¤.GStS¥jjjrGSQS3SOS¦SOS§.GSuS¨jjjrŽGSDS©jrGSDSªjrGSDS«jr‘GSvGSwS¬jjr’GSxGSyS­jjr“GSxGSyS®jjr”GSxGSyS¯jjr•GSzS°jr–GSzS±jr—GS{S²jr˜GS{S³jr™GS{S´jršGS{Sµjr›GS{S¶jrœGS{S·jrGS{S¸jržGS{S¹jrŸGS{Sºjr GS{S»jr¡GS{S¼jr¢GS{S½jr£GS{S¾jr¤GSDS¿jr¥GS{SÀjr¦GSGSÁjr§GS{SÂjr¨SOSÃ.GS|SÄjjr©GS}SÅjrªGS~GSSÆjjr«SÇSÈSOSÉ.GS€SÊjjr¬GSGS‚SËjjr­S3SÌ.GSƒSÍjjr®GS„GS…SÎjjr¯GS†GS‡SÏjjr°GSˆSÐjr±\…"5\X"SÑSÒSÓSd9SrSSÔ.GS‰SÕjj55r²\…"5\X"SÑSÒSÓSd9SrSSÔ.GS‰SÖjj55r³\…"5\X"SÑSÒSÓSd9SrSSÔ.GS‰S×jj55r´\…"5\X"SÑSÒSÓSd9SrSSÔ.GS‰SØjj55rµ\…"5\X"SÑSÒSÓSd9SrSSrSÙ.GSŠSÚjj55r¶\…"5\X"SÑSÒSÓSd9SrSSrSÙ.GSŠSÛjj55r·\…"5\X"SÑSÒSÓSd9SrSSÔ.GS‰SÜjj55r¸\…"5\X"SÑSÒSÓSd9S™SrSSÝ.GS‹SÞjj55r¹\X"SÑSÒSÓSd9GSQSSOSß.GSŒSàjjj5rº\X"SÑSÒSÓSd9GSQSSOSß.GSŒSájjj5r»\X"SÑSÒSÓSd9GSQSSOSß.GSŒSâjjj5r¼\X"SÑSÒSÓSd9GSQSSOSß.GSŒSãjjj5r½\X"SÑSÒSÓSd9GSQSSOSrSä.GSSåjjj5r¾\X"SÑSÒSÓSd9GSQSSOSrSä.GSSæjjj5r¿\X"SÑSÒSÓSd9GSQSSOSß.GSŒSçjjj5rÀ\X"SÑSÒSÓSd9GSŽSSOSß.GSSèjjj5rÁ\…"5S3SSOSé.GSSêjj5rÂ\…"5S3S3SSOSë.GS‘Sìjj5rÃ\…"5\X"SÑSÒSÓSd9GSQSSOSß.GS’Síjjj55rÄGSDSîjrÅGS“SOSSï.GS”SðjjjrÆGS•GS–SñjjrÇGSdGS—SòjjrÈS3Só.GS˜SôjjrÉS3S3Sõ.GS™SöjjrÊGSšGS›S÷jjrËGSDSøjrÌGSDSùjrÍGSDSújrÎGSDSûjrÏGSDSüjrÐGSDSýjrÑGSDSþjrÒGSDSÿjrÓGSDGSjrÔGSDGSjrÕGSDGSjrÖGSDGSjr×GSDGSjrØGSDGSjrÙGSDGSjrÚGSDGSjrÛGSDGSjrÜGSDGS jrÝGSœGS jrÞGSQGSGS jjrßGSQSSOSOSGS .GSžGS jjjrà\X"SÑSÒSÓSd9SSSSS3SrSOGS.GSŸGSjj5ráGS GSjrâ\X"SÑSÒSÓSd9SSSSS3SOSrSOGS.GS¡GSjj5rã\X"SÑSÒSÓSd9SSSSS3SOSrSOGS.GS¡GSjj5räGS¢GSjråSOSOSSOGS.GS£GSjjræGSDGSjrç\èGRÒ4GS¤GSjjrêGSDGSjrë\èGRÒ4S3GS.GS¥GSjjjrì\…"5\X"SÑSÒSÓSd9SrGS.GS¦GSjj55ríSOSl.GS§GSjjrî\‹"GS5GSDGS j5rï\…"5GSQSSOSOGS!.GS¨GS"jjj5rð\ñ4\ñSGS#.GS©GS$jjjrò\ñ4\ñSGS#.GSªGS%jjjróGSDGS&jrôGSDGS'jrõGSDGS(jröGSDGS)jr÷GSDGS*jrøGSDGS+jrùGSDGS,jrúGSDGS-jrûGSDGS.jrü\‹"GS/5SSSOSOSOSOSOSOGS0.GS«GS1jj5rýSOSSGS2.GS¬GS3jjrþSOSSGS2.GS­GS4jjrÿ\GS®GS5j5GrG\GS¯GS6j5GrG\GS°GS7j5GrG\GS±GS8j5GrG\GS²GS9j5GrG\GS³GS:j5GrG\GS´GS;j5GrG\GSµGS<j5GrG\GS¶GS=j5Gr G\GS·GS>j5Gr GS¸GS?jGr GS@Gr g(¹ÚExpré~z1Expressions that can be used in various contexts.NrAÚ_pyexpr> ÚdtÚarrÚbinÚcatÚstrÚlistÚmetaÚnameÚstructzClassVar[set[str]]Ú _accessorscó4•URU5nXlU$©N)Ú__new__rd)ÚclsÚpyexprÚexprs ÚcC:\Users\julio\OneDrive\Documentos\Trabajo\Ideas Frescas\venv\Lib\site-packages\polars/expr/expr.pyÚ _from_pyexprÚExpr._from_pyexprs€à{‰{˜3ӈ، ؈ ócó6•URR5$rp©rdÚto_str©Úselfs ruÚ _repr_html_ÚExpr._repr_html_•ó€Ø|‰|×"Ñ"Ó$Ð$rxcóº•[URR5=n5S:”aUSSS3nSURRSU<S[ U5SS3$)Néu…Ú)Úlenrdr{Ú __class__Ú__name__Úid)r}Úexpr_strs ruÚ__repr__Ú Expr.__repr__˜s_€Ü ˜4Ÿ<™<×.Ñ.Ó0Ð0ˆxÓ 1°BÓ 6Ø" 3 B˜-˜¨Ð,ˆHØ4—>‘>×*Ñ*Ð+¨2¨h©\¸ÄÀDÃÈ!À ÈAÐNÐNrxcó6•URR5$rprzr|s ruÚ__str__Ú Expr.__str__r€rxcó•Sn[U5e)Na°the truth value of an Expr is ambiguous You probably got here by using a Python standard library function instead of the native expressions API. Here are some things you might want to try: - instead of `pl.col('a') and pl.col('b')`, use `pl.col('a') & pl.col('b')` - instead of `pl.col('a') in [y, z]`, use `pl.col('a').is_in([y, z])` - instead of `max(pl.col('a'), pl.col('b'))`, use `pl.max_horizontal(pl.col('a'), pl.col('b'))` )Ú TypeError)r}Úmsgs ruÚ__bool__Ú Expr.__bool__ s€ð pð ô˜‹nÐrxcó"•UR5$rp)Úabsr|s ruÚ__abs__Ú Expr.__abs__­s€Øx‰x‹zÐrxcóF•[USS9n[URU-5$©NT©Ú str_as_lit©rr$rd©r}ÚotherÚ other_pyexprs ruÚ__add__Ú Expr.__add__±s"€Ü,¨U¸tÑDˆ ܘŸ™¨ Ñ4Ó5Ð5rxcóD•[USS9n[X R-5$ršrržs ruÚ__radd__Ú Expr.__radd__µs €Ü,¨U¸tÑDˆ ܘ¯ © Ñ4Ó5Ð5rxcó`•[U5n[URRU55$rp)rr$rdÚand_ržs ruÚ__and__Ú Expr.__and__¹ó&€Ü,¨UÓ3ˆ ܘŸ™×*Ñ*¨<Ó8Ó9Ð9rxcó`•[U5n[URUR55$rp)rr$r§rd©r}rŸÚ other_exprs ruÚ__rand__Ú Expr.__rand__½ó$€Ü*¨5Ó1ˆ ܘŸ™¨¯©Ó6Ó7Ð7rxcót•[U5 [USS9n[URR U55$rš)r#rr$rdÚeqržs ruÚ__eq__Ú Expr.__eq__Áó.€Ü˜UÔ#Ü,¨U¸tÑDˆ ܘŸ™Ÿ™¨Ó6Ó7Ð7rxcóH•[U5n[URU-5$rprržs ruÚ __floordiv__ÚExpr.__floordiv__Æs €Ü,¨UÓ3ˆ ܘŸ™¨Ñ5Ó6Ð6rxcóF•[U5n[X R-5$rprržs ruÚ __rfloordiv__ÚExpr.__rfloordiv__Ês€Ü,¨UÓ3ˆ ܘ¯©Ñ5Ó6Ð6rxcót•[U5 [USS9n[URR U55$rš)r#rr$rdÚgt_eqržs ruÚ__ge__Ú Expr.__ge__Îó0€Ü˜UÔ#Ü,¨U¸tÑDˆ ܘŸ™×+Ñ+¨LÓ9Ó:Ð:rxcót•[U5 [USS9n[URR U55$rš)r#rr$rdÚgtržs ruÚ__gt__Ú Expr.__gt__Órµrxcó"•UR5$rp)Únot_r|s ruÚ __invert__ÚExpr.__invert__Øs€Øy‰y‹{Ðrxcót•[U5 [USS9n[URR U55$rš)r#rr$rdÚlt_eqržs ruÚ__le__Ú Expr.__le__ÛrÀrxcót•[U5 [USS9n[URR U55$rš)r#rr$rdÚltržs ruÚ__lt__Ú Expr.__lt__àrµrxcóH•[U5n[URU-5$rprržs ruÚ__mod__Ú Expr.__mod__åó €Ü,¨UÓ3ˆ ܘŸ™¨ Ñ4Ó5Ð5rxcóF•[U5n[X R-5$rprržs ruÚ__rmod__Ú Expr.__rmod__éó€Ü,¨UÓ3ˆ ܘ¯ © Ñ4Ó5Ð5rxcóH•[U5n[URU-5$rprržs ruÚ__mul__Ú Expr.__mul__írÔrxcóF•[U5n[X R-5$rprržs ruÚ__rmul__Ú Expr.__rmul__ñrØrxcót•[U5 [USS9n[URR U55$rš)r#rr$rdÚneqržs ruÚ__ne__Ú Expr.__ne__õs0€Ü˜UÔ#Ü,¨U¸tÑDˆ ܘŸ™×)Ñ)¨,Ó7Ó8Ð8rxcó.•[UR*5$rp)r$rdr|s ruÚ__neg__Ú Expr.__neg__ús€Ü˜$Ÿ,™,˜Ó'Ð'rxcó`•[U5n[URRU55$rp)rr$rdÚor_ržs ruÚ__or__Ú Expr.__or__ýs&€Ü,¨UÓ3ˆ ܘŸ™×)Ñ)¨,Ó7Ó8Ð8rxcó`•[U5n[URUR55$rp)rr$rçrdr¬s ruÚ__ror__Ú Expr.__ror__s$€Ü*¨5Ó1ˆ ܘŸ™¨¯ © Ó5Ó6Ð6rxcó•U$rp©r|s ruÚ__pos__Ú Expr.__pos__s€Øˆ rxcó`•[U5n[URRU55$rp)rr$rdÚpow)r}ÚexponentÚexponent_pyexprs ruÚ__pow__Ú Expr.__pow__s&€Ü/°Ó9ˆÜ˜Ÿ™×)Ñ)¨/Ó:Ó;Ð;rxcó4•[U5n[U5U-$rp)rr$©r}ÚbaseÚ base_pyexprs ruÚ__rpow__Ú Expr.__rpow__ s€Ü+¨DÓ1ˆ ܘÓ%¨Ñ-Ð-rxcóH•[U5n[URU- 5$rprržs ruÚ__sub__Ú Expr.__sub__rÔrxcóF•[U5n[X R- 5$rprržs ruÚ__rsub__Ú Expr.__rsub__rØrxcóH•[U5n[URU- 5$rprržs ruÚ __truediv__ÚExpr.__truediv__rÔrxcóF•[U5n[X R- 5$rprržs ruÚ __rtruediv__ÚExpr.__rtruediv__rØrxcó`•[U5n[URRU55$rp)rr$rdÚxor_ržs ruÚ__xor__Ú Expr.__xor__ rªrxcó`•[U5n[URUR55$rp)rr$r rdr¬s ruÚ__rxor__Ú Expr.__rxor__$r°rxcó6•URR5$rp)rdÚ __getstate__r|s rurÚExpr.__getstate__(s€Ø|‰|×(Ñ(Ó*Ð*rxcó„•[R"S5RUlURRU5 g©Nr)ÚFÚlitrdÚ __setstate__)r}Ústates rurÚExpr.__setstate__+s)€Ü—u’u˜Q“x×'Ñ'ˆŒ Ø ‰ ×!Ñ! %Õ(rxcóL^^^^•US:waSU3n[U5e[TS5SLnUSLa2STRS3n[R"U[ [ 5S9 [U5S :XaL[T5S :Xa=[US [5(d S n[U5eUS RTU(+S 9$[S U55m[U5VVs/sH$upx[U[5(aUSU4OUSU4PM& snnmTS :Xa[ST55n O^Sn /n TH>upŒn U (dMU (aSn OURSU 35nU R!U5 M@ ["R$"U 5n SUUUU4SjjnU RXæ(+S 9$s snnf)zNumpy universal functions.Ú__call__zOnly call is implemented not Ú signatureNTaNative numpy ufuncs are dispatched using `map_batches(ufunc, is_elementwise=True)` which is safe for native Numpy and Scipy ufuncs but custom ufuncs in a group_by context won't be properly grouped. Custom ufuncs are dispatched with is_elementwise=False. If z8 needs elementwise then please use map_batches directly.)Ú stacklevelérzInput must be expression.)Úis_elementwisec3óB# •UHn[U[5v• M g7frp)Ú isinstancerb)Ú.0Úinps ruÚ Ú'Expr.__array_ufunc__..Lsé€Ð?º°”z #¤t×,Ð,ºùs‚Fc3óB# •UHoS(dMUSv• M g7f)rrNrî)r"rts rur$r%Ssé€ÐB²¨¸q½'›W˜T !žW²ùs‚ “ Ú argument_có>•/n[T5Hfup#US(a&TS:”a URURU5 M5US(aURU5 MRURUS5 Mh T"U0TD6$)Nrr)Ú enumerateÚappendrm)ÚsÚargsÚirtÚexprsÚkwargsÚnum_exprÚufuncs €€€€ruÚfunctionÚ&Expr.__array_ufunc__..functioncsnø€Ø ˆDÜ$ UÖ+‘ؘ—7˜x¨!›|Ø—K‘K §¡¨¡ Ö,ؘ!—WØ—K‘K –Nà—K‘K  Q¡Ö(ñ ,ñ˜$Ð) &Ñ)Ð )rx©r+rGÚreturnrG)ÚNotImplementedErrorÚgetattrrˆÚwarningsÚwarnr*rr†r!rbr+Ú map_batchesÚsumr)ÚnextÚaliasr*rrm)r}r1ÚmethodÚinputsr/r’Úis_custom_ufuncr-r#Ú root_exprÚfirst_renameable_exprÚ actual_exprsÚis_actual_exprÚindexr2r.r0s ` ` @@ruÚ__array_ufunc__ÚExpr.__array_ufunc__/sÁû€ð ZÓ Ø1°&°Ð:ˆCÜ% cÓ*Ð *ä! %¨Ó5¸TÐAˆØ ˜dÒ "ðð—n‘nÐ%Ð%]ð_ð ô MŠMØÜ"Ü*Ó,ò ô ˆv‹;˜!Ó ¤ F£ ¨qÓ 0ô˜f Q™i¬×.Ñ.Ø1Ü& sÓ+Ð+ؘ!‘9×(Ñ(¨À?Ô?RÐ(ÐSÐ SÜÑ?¹Ó?Ó?ˆô$ FÔ+ô â+‘ô)¨¬d×3Ñ3ˆS$˜‰N¸#¸uÀa¸Ò HÙ+ò ˆð q‹=ÜÑB±ÓBÓB‰Ið %)Ð !؈LÛ.3Ñ* Uß!>Þ,Ø05Ñ-à!Ÿi™i¨)°E°7Ð(;Ó<˜Ø ×'Ñ'¨Ö,ñ /4ôŸš Ó.ˆI÷ *ò *ð×$Ñ$ XÔ>QÐ$ÐRÐRùóC sÃ+F Úbinary©Úformatcó¶•[U[5(a([UR5R 55nOG[U[ [ 45(a [U5nO [U[5(a [U5nUS:Xa[RnO(US:Xa[RnOSU<3n[U5eURU"U55$)uS Read a serialized expression from a file. Parameters ---------- source Path to a file or a file-like object (by file-like object, we refer to objects that have a `read()` method, such as a file handler (e.g. via builtin `open` function) or `BytesIO`). format The format with which the Expr was serialized. Options: - `"binary"`: Deserialize from binary format (bytes). This is the default. - `"json"`: Deserialize from JSON format (string). Warnings -------- This function uses :mod:`pickle` if the logical plan contains Python UDFs, and as such inherits the security implications. Deserializing can execute arbitrary code, so it should only be attempted on trusted data. See Also -------- Expr.meta.serialize Notes ----- Serialization is not stable across Polars versions: a LazyFrame serialized in one Polars version may not be deserializable in another Polars version. Examples -------- >>> import io >>> expr = pl.col("foo").sum().over("bar") >>> bytes = expr.meta.serialize() >>> pl.Expr.deserialize(io.BytesIO(bytes)) rHÚjsonz0`format` must be one of {'binary', 'json'}, got )r!r r ÚgetvalueÚencoderir r!ÚbytesrAÚdeserialize_binaryÚdeserialize_jsonÚ ValueErrorrv)rrÚsourcerJÚ deserializerr’s ruÚ deserializeÚExpr.deserializeps¯€ôZ fœh× 'Ñ 'ܘVŸ_™_Ó.×5Ñ5Ó7Ó8‰FÜ ˜¤¤d  × ,Ñ ,Ü'¨Ó/‰FÜ ˜¤× &Ñ &ܘV“_ˆFà XÓ Ü!×4Ñ4‰LØ vÓ Ü!×2Ñ2‰LàFÀvÁjÐQˆCܘS“/Ð !à×Ñ¡ ¨VÓ 4Ó5Ð5rxcóH•[URR55$)uå Cast to physical representation of the logical dtype. - :func:`polars.datatypes.Date` -> :func:`polars.datatypes.Int32` - :func:`polars.datatypes.Datetime` -> :func:`polars.datatypes.Int64` - :func:`polars.datatypes.Time` -> :func:`polars.datatypes.Int64` - :func:`polars.datatypes.Duration` -> :func:`polars.datatypes.Int64` - :func:`polars.datatypes.Categorical` -> :func:`polars.datatypes.UInt32` - `List(inner)` -> `List(physical of inner)` - `Array(inner)` -> `Struct(physical of inner)` - `Struct(fields)` -> `Array(physical of fields)` Other data types will be left unchanged. Warnings -------- The physical representations are an implementation detail and not guaranteed to be stable. Examples -------- Replicating the pandas `pd.factorize `_ function. >>> pl.DataFrame({"vals": ["a", "x", None, "a"]}).with_columns( ... pl.col("vals").cast(pl.Categorical), ... pl.col("vals") ... .cast(pl.Categorical) ... .to_physical() ... .alias("vals_physical"), ... ) shape: (4, 2) ┌──────┬───────────────┠│ vals ┆ vals_physical │ │ --- ┆ --- │ │ cat ┆ u32 │ â•žâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ a ┆ 0 │ │ x ┆ 1 │ │ null ┆ null │ │ a ┆ 0 │ └──────┴───────────────┘ )r$rdÚ to_physicalr|s rurXÚExpr.to_physical®s€ô\˜Ÿ™×1Ñ1Ó3Ó4Ð4rxT)Ú ignore_nullscóJ•[URRU55$)u; Return whether any of the values in the column are `True`. Only works on columns of data type :class:`Boolean`. Parameters ---------- ignore_nulls * If set to `True` (default), null values are ignored. If there are no non-null values, the output is `False`. * If set to `False`, `Kleene logic`_ is used to deal with nulls: if the column contains any null values and no `True` values, the output is null. .. _Kleene logic: https://en.wikipedia.org/wiki/Three-valued_logic Returns ------- Expr Expression of data type :class:`Boolean`. Examples -------- >>> df = pl.DataFrame( ... { ... "a": [True, False], ... "b": [False, False], ... "c": [None, False], ... } ... ) >>> df.select(pl.col("*").any()) shape: (1, 3) ┌──────┬───────┬───────┠│ a ┆ b ┆ c │ │ --- ┆ --- ┆ --- │ │ bool ┆ bool ┆ bool │ â•žâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•¡ │ true ┆ false ┆ false │ └──────┴───────┴───────┘ Enable Kleene logic by setting `ignore_nulls=False`. >>> df.select(pl.col("*").any(ignore_nulls=False)) shape: (1, 3) ┌──────┬───────┬──────┠│ a ┆ b ┆ c │ │ --- ┆ --- ┆ --- │ │ bool ┆ bool ┆ bool │ â•žâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•¡ │ true ┆ false ┆ null │ └──────┴───────┴──────┘ )r$rdÚany©r}rZs rur\ÚExpr.anyÞs€ôl˜Ÿ™×)Ñ)¨,Ó7Ó8Ð8rxcóJ•[URRU55$)u¨ Return whether all values in the column are `True`. Only works on columns of data type :class:`Boolean`. .. note:: This method is not to be confused with the function :func:`polars.all`, which can be used to select all columns. Parameters ---------- ignore_nulls * If set to `True` (default), null values are ignored. If there are no non-null values, the output is `True`. * If set to `False`, `Kleene logic`_ is used to deal with nulls: if the column contains any null values and no `False` values, the output is null. .. _Kleene logic: https://en.wikipedia.org/wiki/Three-valued_logic Returns ------- Expr Expression of data type :class:`Boolean`. Examples -------- >>> df = pl.DataFrame( ... { ... "a": [True, True], ... "b": [False, True], ... "c": [None, True], ... } ... ) >>> df.select(pl.col("*").all()) shape: (1, 3) ┌──────┬───────┬──────┠│ a ┆ b ┆ c │ │ --- ┆ --- ┆ --- │ │ bool ┆ bool ┆ bool │ â•žâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•¡ │ true ┆ false ┆ true │ └──────┴───────┴──────┘ Enable Kleene logic by setting `ignore_nulls=False`. >>> df.select(pl.col("*").all(ignore_nulls=False)) shape: (1, 3) ┌──────┬───────┬──────┠│ a ┆ b ┆ c │ │ --- ┆ --- ┆ --- │ │ bool ┆ bool ┆ bool │ â•žâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•¡ │ true ┆ false ┆ null │ └──────┴───────┴──────┘ )r$rdÚallr]s rur`ÚExpr.alls€ôt˜Ÿ™×)Ñ)¨,Ó7Ó8Ð8rxcó>•[[UR55$)u1 Return indices where expression evaluates `True`. .. warning:: Modifies number of rows returned, so will fail in combination with other expressions. Use as only expression in `select` / `with_columns`. See Also -------- Series.arg_true : Return indices where Series is True polars.arg_where Examples -------- >>> df = pl.DataFrame({"a": [1, 1, 2, 1]}) >>> df.select((pl.col("a") == 1).arg_true()) shape: (3, 1) ┌─────┠│ a │ │ --- │ │ u32 │ â•žâ•â•â•â•â•â•¡ │ 0 │ │ 1 │ │ 3 │ └─────┘ )r$Ú py_arg_whererdr|s ruÚarg_trueÚ Expr.arg_trueRs€ô8œ d§l¡lÓ3Ó4Ð4rxcóH•[URR55$)uz Compute the square root of the elements. Examples -------- >>> df = pl.DataFrame({"values": [1.0, 2.0, 4.0]}) >>> df.select(pl.col("values").sqrt()) shape: (3, 1) ┌──────────┠│ values │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•â•â•â•â•â•¡ │ 1.0 │ │ 1.414214 │ │ 2.0 │ └──────────┘ )r$rdÚsqrtr|s rurgÚ Expr.sqrtpó€ô&˜Ÿ™×*Ñ*Ó,Ó-Ð-rxcóH•[URR55$)ux Compute the cube root of the elements. Examples -------- >>> df = pl.DataFrame({"values": [1.0, 2.0, 4.0]}) >>> df.select(pl.col("values").cbrt()) shape: (3, 1) ┌──────────┠│ values │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•â•â•â•â•â•¡ │ 1.0 │ │ 1.259921 │ │ 1.587401 │ └──────────┘ )r$rdÚcbrtr|s rurkÚ Expr.cbrt…rirxcó$•URS5$)uƒ Compute the base 10 logarithm of the input array, element-wise. Examples -------- >>> df = pl.DataFrame({"values": [1.0, 2.0, 4.0]}) >>> df.select(pl.col("values").log10()) shape: (3, 1) ┌─────────┠│ values │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•â•â•â•â•¡ │ 0.0 │ │ 0.30103 │ │ 0.60206 │ └─────────┘ g$@)Úlogr|s ruÚlog10Ú Expr.log10šs€ð&x‰x˜‹~ÐrxcóH•[URR55$)uw Compute the exponential, element-wise. Examples -------- >>> df = pl.DataFrame({"values": [1.0, 2.0, 4.0]}) >>> df.select(pl.col("values").exp()) shape: (3, 1) ┌──────────┠│ values │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•â•â•â•â•â•¡ │ 2.718282 │ │ 7.389056 │ │ 54.59815 │ └──────────┘ )r$rdÚexpr|s rurrÚExpr.exp¯s€ô&˜Ÿ™×)Ñ)Ó+Ó,Ð,rxcóJ•[URRU55$)u Rename the expression. Parameters ---------- name The new name. See Also -------- name.map name.prefix name.suffix Examples -------- Rename an expression to avoid overwriting an existing column. >>> df = pl.DataFrame( ... { ... "a": [1, 2, 3], ... "b": ["x", "y", "z"], ... } ... ) >>> df.with_columns( ... pl.col("a") + 10, ... pl.col("b").str.to_uppercase().alias("c"), ... ) shape: (3, 3) ┌─────┬─────┬─────┠│ a ┆ b ┆ c │ │ --- ┆ --- ┆ --- │ │ i64 ┆ str ┆ str │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ 11 ┆ x ┆ X │ │ 12 ┆ y ┆ Y │ │ 13 ┆ z ┆ Z │ └─────┴─────┴─────┘ Overwrite the default name of literal columns to prevent errors due to duplicate column names. >>> df.with_columns( ... pl.lit(True).alias("c"), ... pl.lit(4.0).alias("d"), ... ) shape: (3, 4) ┌─────┬─────┬──────┬─────┠│ a ┆ b ┆ c ┆ d │ │ --- ┆ --- ┆ --- ┆ --- │ │ i64 ┆ str ┆ bool ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ 1 ┆ x ┆ true ┆ 4.0 │ │ 2 ┆ y ┆ true ┆ 4.0 │ │ 3 ┆ z ┆ true ┆ 4.0 │ └─────┴─────┴──────┴─────┘ )r$rdr=)r}rls rur=Ú Expr.aliasÄs€ôt˜Ÿ™×+Ñ+¨DÓ1Ó2Ð2rxcót•URR5R"U/UQ76R5$)uÅ Exclude columns from a multi-column expression. Only works after a wildcard or regex column selection, and you cannot provide both string column names *and* dtypes (you may prefer to use selectors instead). Parameters ---------- columns The name or datatype of the column(s) to exclude. Accepts regular expression input. Regular expressions should start with `^` and end with `$`. *more_columns Additional names or datatypes of columns to exclude, specified as positional arguments. Examples -------- >>> df = pl.DataFrame( ... { ... "aa": [1, 2, 3], ... "ba": ["a", "b", None], ... "cc": [None, 2.5, 1.5], ... } ... ) >>> df shape: (3, 3) ┌─────┬──────┬──────┠│ aa ┆ ba ┆ cc │ │ --- ┆ --- ┆ --- │ │ i64 ┆ str ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•¡ │ 1 ┆ a ┆ null │ │ 2 ┆ b ┆ 2.5 │ │ 3 ┆ null ┆ 1.5 │ └─────┴──────┴──────┘ Exclude by column name(s): >>> df.select(pl.all().exclude("ba")) shape: (3, 2) ┌─────┬──────┠│ aa ┆ cc │ │ --- ┆ --- │ │ i64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•¡ │ 1 ┆ null │ │ 2 ┆ 2.5 │ │ 3 ┆ 1.5 │ └─────┴──────┘ Exclude by regex, e.g. removing all columns whose names end with the letter "a": >>> df.select(pl.all().exclude("^.*a$")) shape: (3, 1) ┌──────┠│ cc │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•â•¡ │ null │ │ 2.5 │ │ 1.5 │ └──────┘ Exclude by dtype(s), e.g. removing all columns of type Int64 or Float64: >>> df.select(pl.all().exclude([pl.Int64, pl.Float64])) shape: (3, 1) ┌──────┠│ ba │ │ --- │ │ str │ â•žâ•â•â•â•â•â•â•¡ │ a │ │ b │ │ null │ └──────┘ )rkÚ as_selectorÚexcludeÚas_expr)r}ÚcolumnsÚ more_columnss rurxÚ Expr.excludes1€ðfy‰y×$Ñ$Ó&×.Ò.¨wÐF¸ÒF×NÑNÓPÐPrxcó•U"U/UQ70UD6$)uÎ Offers a structured way to apply a sequence of user-defined functions (UDFs). Parameters ---------- function Callable; will receive the expression as the first parameter, followed by any given args/kwargs. *args Arguments to pass to the UDF. **kwargs Keyword arguments to pass to the UDF. Examples -------- >>> def extract_number(expr: pl.Expr) -> pl.Expr: ... """Extract the digits from a string.""" ... return expr.str.extract(r"\d+", 0).cast(pl.Int64) >>> >>> def scale_negative_even(expr: pl.Expr, *, n: int = 1) -> pl.Expr: ... """Set even numbers negative, and scale by a user-supplied value.""" ... expr = pl.when(expr % 2 == 0).then(-expr).otherwise(expr) ... return expr * n >>> >>> df = pl.DataFrame({"val": ["a: 1", "b: 2", "c: 3", "d: 4"]}) >>> df.with_columns( ... udfs=( ... pl.col("val").pipe(extract_number).pipe(scale_negative_even, n=5) ... ), ... ) shape: (4, 2) ┌──────┬──────┠│ val ┆ udfs │ │ --- ┆ --- │ │ str ┆ i64 │ â•žâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•¡ │ a: 1 ┆ 5 │ │ b: 2 ┆ -10 │ │ c: 3 ┆ 15 │ │ d: 4 ┆ -20 │ └──────┴──────┘ rî)r}r2r,r/s ruÚpipeÚ Expr.pipeUs€ñb˜Ð.˜tÒ. vÑ.Ð.rxcóH•[URR55$)u¶ Negate a boolean expression. Examples -------- >>> df = pl.DataFrame( ... { ... "a": [True, False, False], ... "b": ["a", "b", None], ... } ... ) >>> df shape: (3, 2) ┌───────┬──────┠│ a ┆ b │ │ --- ┆ --- │ │ bool ┆ str │ â•žâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•¡ │ true ┆ a │ │ false ┆ b │ │ false ┆ null │ └───────┴──────┘ >>> df.select(pl.col("a").not_()) shape: (3, 1) ┌───────┠│ a │ │ --- │ │ bool │ â•žâ•â•â•â•â•â•â•â•¡ │ false │ │ true │ │ true │ └───────┘ )r$rdrÆr|s rurÆÚ Expr.not_ˆs€ôF˜Ÿ™×*Ñ*Ó,Ó-Ð-rxcóH•[URR55$)uõ Returns a boolean Series indicating which values are null. Examples -------- >>> df = pl.DataFrame( ... { ... "a": [1, 2, None, 1, 5], ... "b": [1.0, 2.0, float("nan"), 1.0, 5.0], ... } ... ) >>> df.with_columns(pl.all().is_null().name.suffix("_isnull")) # nan != null shape: (5, 4) ┌──────┬─────┬──────────┬──────────┠│ a ┆ b ┆ a_isnull ┆ b_isnull │ │ --- ┆ --- ┆ --- ┆ --- │ │ i64 ┆ f64 ┆ bool ┆ bool │ â•žâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•¡ │ 1 ┆ 1.0 ┆ false ┆ false │ │ 2 ┆ 2.0 ┆ false ┆ false │ │ null ┆ NaN ┆ true ┆ false │ │ 1 ┆ 1.0 ┆ false ┆ false │ │ 5 ┆ 5.0 ┆ false ┆ false │ └──────┴─────┴──────────┴──────────┘ )r$rdÚis_nullr|s rurƒÚ Expr.is_null­s€ô4˜Ÿ™×-Ñ-Ó/Ó0Ð0rxcóH•[URR55$)uQ Returns a boolean Series indicating which values are not null. Examples -------- >>> df = pl.DataFrame( ... { ... "a": [1, 2, None, 1, 5], ... "b": [1.0, 2.0, float("nan"), 1.0, 5.0], ... } ... ) >>> df.with_columns( ... pl.all().is_not_null().name.suffix("_not_null") # nan != null ... ) shape: (5, 4) ┌──────┬─────┬────────────┬────────────┠│ a ┆ b ┆ a_not_null ┆ b_not_null │ │ --- ┆ --- ┆ --- ┆ --- │ │ i64 ┆ f64 ┆ bool ┆ bool │ â•žâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1 ┆ 1.0 ┆ true ┆ true │ │ 2 ┆ 2.0 ┆ true ┆ true │ │ null ┆ NaN ┆ false ┆ true │ │ 1 ┆ 1.0 ┆ true ┆ true │ │ 5 ┆ 5.0 ┆ true ┆ true │ └──────┴─────┴────────────┴────────────┘ )r$rdÚ is_not_nullr|s rur†ÚExpr.is_not_nullÉó€ô8˜Ÿ™×1Ñ1Ó3Ó4Ð4rxcóH•[URR55$)u? Returns a boolean Series indicating which values are finite. Returns ------- Expr Expression of data type :class:`Boolean`. Examples -------- >>> df = pl.DataFrame( ... { ... "A": [1.0, 2], ... "B": [3.0, float("inf")], ... } ... ) >>> df.select(pl.all().is_finite()) shape: (2, 2) ┌──────┬───────┠│ A ┆ B │ │ --- ┆ --- │ │ bool ┆ bool │ â•žâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•¡ │ true ┆ true │ │ true ┆ false │ └──────┴───────┘ )r$rdÚ is_finiter|s rurŠÚExpr.is_finiteçs€ô8˜Ÿ™×/Ñ/Ó1Ó2Ð2rxcóH•[URR55$)uQ Returns a boolean Series indicating which values are infinite. Returns ------- Expr Expression of data type :class:`Boolean`. Examples -------- >>> df = pl.DataFrame( ... { ... "A": [1.0, 2], ... "B": [3.0, float("inf")], ... } ... ) >>> df.select(pl.all().is_infinite()) shape: (2, 2) ┌───────┬───────┠│ A ┆ B │ │ --- ┆ --- │ │ bool ┆ bool │ â•žâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•¡ │ false ┆ false │ │ false ┆ true │ └───────┴───────┘ )r$rdÚ is_infiniter|s rurÚExpr.is_infiniterˆrxcóH•[URR55$)u‡ Returns a boolean Series indicating which values are NaN. Notes ----- Floating point `NaN` (Not A Number) should not be confused with missing data represented as `Null/None`. Examples -------- >>> df = pl.DataFrame( ... { ... "a": [1, 2, None, 1, 5], ... "b": [1.0, 2.0, float("nan"), 1.0, 5.0], ... } ... ) >>> df.with_columns(pl.col(pl.Float64).is_nan().name.suffix("_isnan")) shape: (5, 3) ┌──────┬─────┬─────────┠│ a ┆ b ┆ b_isnan │ │ --- ┆ --- ┆ --- │ │ i64 ┆ f64 ┆ bool │ â•žâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•¡ │ 1 ┆ 1.0 ┆ false │ │ 2 ┆ 2.0 ┆ false │ │ null ┆ NaN ┆ true │ │ 1 ┆ 1.0 ┆ false │ │ 5 ┆ 5.0 ┆ false │ └──────┴─────┴─────────┘ )r$rdÚis_nanr|s rurÚ Expr.is_nan#s€ô>˜Ÿ™×,Ñ,Ó.Ó/Ð/rxcóH•[URR55$)ué Returns a boolean Series indicating which values are not NaN. Notes ----- Floating point `NaN` (Not A Number) should not be confused with missing data represented as `Null/None`. Examples -------- >>> df = pl.DataFrame( ... { ... "a": [1, 2, None, 1, 5], ... "b": [1.0, 2.0, float("nan"), 1.0, 5.0], ... } ... ) >>> df.with_columns(pl.col(pl.Float64).is_not_nan().name.suffix("_is_not_nan")) shape: (5, 3) ┌──────┬─────┬──────────────┠│ a ┆ b ┆ b_is_not_nan │ │ --- ┆ --- ┆ --- │ │ i64 ┆ f64 ┆ bool │ â•žâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1 ┆ 1.0 ┆ true │ │ 2 ┆ 2.0 ┆ true │ │ null ┆ NaN ┆ false │ │ 1 ┆ 1.0 ┆ true │ │ 5 ┆ 5.0 ┆ true │ └──────┴─────┴──────────────┘ )r$rdÚ is_not_nanr|s rur“ÚExpr.is_not_nanDs€ô>˜Ÿ™×0Ñ0Ó2Ó3Ð3rxcóH•[URR55$)u, Get the group indexes of the group by operation. Should be used in aggregation context only. Examples -------- >>> df = pl.DataFrame( ... { ... "group": [ ... "one", ... "one", ... "one", ... "two", ... "two", ... "two", ... ], ... "value": [94, 95, 96, 97, 97, 99], ... } ... ) >>> df.group_by("group", maintain_order=True).agg(pl.col("value").agg_groups()) shape: (2, 2) ┌───────┬───────────┠│ group ┆ value │ │ --- ┆ --- │ │ str ┆ list[u32] │ â•žâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•¡ │ one ┆ [0, 1, 2] │ │ two ┆ [3, 4, 5] │ └───────┴───────────┘ )r$rdÚ agg_groupsr|s rur–ÚExpr.agg_groupses€ô@˜Ÿ™×0Ñ0Ó2Ó3Ð3rxcóH•[URR55$)uÕ Return the number of non-null elements in the column. Returns ------- Expr Expression of data type :class:`UInt32`. See Also -------- len Examples -------- >>> df = pl.DataFrame({"a": [1, 2, 3], "b": [None, 4, 4]}) >>> df.select(pl.all().count()) shape: (1, 2) ┌─────┬─────┠│ a ┆ b │ │ --- ┆ --- │ │ u32 ┆ u32 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ 3 ┆ 2 │ └─────┴─────┘ )r$rdÚcountr|s rur™Ú Expr.count‡s€ô4˜Ÿ™×+Ñ+Ó-Ó.Ð.rxcóH•[URR55$)uò Return the number of elements in the column. Null values count towards the total. Returns ------- Expr Expression of data type :class:`UInt32`. See Also -------- count Examples -------- >>> df = pl.DataFrame({"a": [1, 2, 3], "b": [None, 4, 4]}) >>> df.select(pl.all().len()) shape: (1, 2) ┌─────┬─────┠│ a ┆ b │ │ --- ┆ --- │ │ u32 ┆ u32 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ 3 ┆ 3 │ └─────┴─────┘ )r$rdr†r|s rur†ÚExpr.len£s€ô8˜Ÿ™×)Ñ)Ó+Ó,Ð,rxcó •[U[5(d[R"U5n[U[5(d[R"U5n[ UR R UR UR 55$)um Get a slice of this expression. Parameters ---------- offset Start index. Negative indexing is supported. length Length of the slice. If set to `None`, all rows starting at the offset will be selected. Examples -------- >>> df = pl.DataFrame( ... { ... "a": [8, 9, 10, 11], ... "b": [None, 4, 4, 4], ... } ... ) >>> df.select(pl.all().slice(1, 2)) shape: (2, 2) ┌─────┬─────┠│ a ┆ b │ │ --- ┆ --- │ │ i64 ┆ i64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ 9 ┆ 4 │ │ 10 ┆ 4 │ └─────┴─────┘ )r!rbrrr$rdÚslice)r}ÚoffsetÚlengths ruržÚ Expr.sliceÁs\€ô>˜&¤$×'Ñ'Ü—U’U˜6“]ˆFܘ&¤$×'Ñ'Ü—U’U˜6“]ˆFܘŸ™×+Ñ+¨F¯N©N¸F¿N¹NÓKÓLÐLrx)Úupcastcó`•[U5n[URRX255$)ur Append expressions. This is done by adding the chunks of `other` to this `Series`. Parameters ---------- other Expression to append. upcast Cast both `Series` to the same supertype. Examples -------- >>> df = pl.DataFrame( ... { ... "a": [8, 9, 10], ... "b": [None, 4, 4], ... } ... ) >>> df.select(pl.all().head(1).append(pl.all().tail(1))) shape: (2, 2) ┌─────┬──────┠│ a ┆ b │ │ --- ┆ --- │ │ i64 ┆ i64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•¡ │ 8 ┆ null │ │ 10 ┆ 4 │ └─────┴──────┘ )rr$rdr*)r}rŸr¢r s rur*Ú Expr.appendæs)€ô@-¨UÓ3ˆ ܘŸ™×,Ñ,¨\ÓBÓCÐCrxcóH•[URR55$)uà Create a single chunk of memory for this Series. Examples -------- >>> df = pl.DataFrame({"a": [1, 1, 2]}) Create a Series with 3 nulls, append column `a`, then rechunk. >>> df.select(pl.repeat(None, 3).append(pl.col("a")).rechunk()) shape: (6, 1) ┌────────┠│ repeat │ │ --- │ │ i64 │ â•žâ•â•â•â•â•â•â•â•â•¡ │ null │ │ null │ │ null │ │ 1 │ │ 1 │ │ 2 │ └────────┘ )r$rdÚrechunkr|s rur¦Ú Expr.rechunk ó€ô2˜Ÿ™×-Ñ-Ó/Ó0Ð0rxcóH•[URR55$)uå Drop all null values. The original order of the remaining elements is preserved. See Also -------- drop_nans Notes ----- A null value is not the same as a NaN value. To drop NaN values, use :func:`drop_nans`. Examples -------- >>> df = pl.DataFrame({"a": [1.0, None, 3.0, float("nan")]}) >>> df.select(pl.col("a").drop_nulls()) shape: (3, 1) ┌─────┠│ a │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•¡ │ 1.0 │ │ 3.0 │ │ NaN │ └─────┘ )r$rdÚ drop_nullsr|s rurªÚExpr.drop_nulls$s€ô<˜Ÿ™×0Ñ0Ó2Ó3Ð3rxcóH•[URR55$)u Drop all floating point NaN values. The original order of the remaining elements is preserved. See Also -------- drop_nulls Notes ----- A NaN value is not the same as a null value. To drop null values, use :func:`drop_nulls`. Examples -------- >>> df = pl.DataFrame({"a": [1.0, None, 3.0, float("nan")]}) >>> df.select(pl.col("a").drop_nans()) shape: (3, 1) ┌──────┠│ a │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•â•¡ │ 1.0 │ │ null │ │ 3.0 │ └──────┘ )r$rdÚ drop_nansr|s rur­ÚExpr.drop_nansDs€ô<˜Ÿ™×/Ñ/Ó1Ó2Ð2rxF)Úreverser¯cóJ•[URRU55$)uO Get an array with the cumulative sum computed at every element. Parameters ---------- reverse Reverse the operation. Notes ----- Dtypes in {Int8, UInt8, Int16, UInt16} are cast to Int64 before summing to prevent overflow issues. Examples -------- >>> df = pl.DataFrame({"a": [1, 2, 3, 4]}) >>> df.with_columns( ... pl.col("a").cum_sum().alias("cum_sum"), ... pl.col("a").cum_sum(reverse=True).alias("cum_sum_reverse"), ... ) shape: (4, 3) ┌─────┬─────────┬─────────────────┠│ a ┆ cum_sum ┆ cum_sum_reverse │ │ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ i64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1 ┆ 1 ┆ 10 │ │ 2 ┆ 3 ┆ 9 │ │ 3 ┆ 6 ┆ 7 │ │ 4 ┆ 10 ┆ 4 │ └─────┴─────────┴─────────────────┘ Null values are excluded, but can also be filled by calling `fill_null(strategy="forward")`. >>> df = pl.DataFrame({"values": [None, 10, None, 8, 9, None, 16, None]}) >>> df.with_columns( ... pl.col("values").cum_sum().alias("value_cum_sum"), ... pl.col("values") ... .cum_sum() ... .fill_null(strategy="forward") ... .alias("value_cum_sum_all_filled"), ... ) shape: (8, 3) ┌────────┬───────────────┬──────────────────────────┠│ values ┆ value_cum_sum ┆ value_cum_sum_all_filled │ │ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ i64 │ â•žâ•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ null ┆ null ┆ null │ │ 10 ┆ 10 ┆ 10 │ │ null ┆ null ┆ 10 │ │ 8 ┆ 18 ┆ 18 │ │ 9 ┆ 27 ┆ 27 │ │ null ┆ null ┆ 27 │ │ 16 ┆ 43 ┆ 43 │ │ null ┆ null ┆ 43 │ └────────┴───────────────┴──────────────────────────┘ )r$rdÚcum_sum©r}r¯s rur±Ú Expr.cum_sumds€ôx˜Ÿ™×-Ñ-¨gÓ6Ó7Ð7rxcóJ•[URRU55$)ua Get an array with the cumulative product computed at every element. Parameters ---------- reverse Reverse the operation. Notes ----- Dtypes in {Int8, UInt8, Int16, UInt16} are cast to Int64 before summing to prevent overflow issues. Examples -------- >>> df = pl.DataFrame({"a": [1, 2, 3, 4]}) >>> df.with_columns( ... pl.col("a").cum_prod().alias("cum_prod"), ... pl.col("a").cum_prod(reverse=True).alias("cum_prod_reverse"), ... ) shape: (4, 3) ┌─────┬──────────┬──────────────────┠│ a ┆ cum_prod ┆ cum_prod_reverse │ │ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ i64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1 ┆ 1 ┆ 24 │ │ 2 ┆ 2 ┆ 24 │ │ 3 ┆ 6 ┆ 12 │ │ 4 ┆ 24 ┆ 4 │ └─────┴──────────┴──────────────────┘ )r$rdÚcum_prodr²s rurµÚ Expr.cum_prod¢s€ôB˜Ÿ™×.Ñ.¨wÓ7Ó8Ð8rxcóJ•[URRU55$)u™ Get an array with the cumulative min computed at every element. Parameters ---------- reverse Reverse the operation. Examples -------- >>> df = pl.DataFrame({"a": [3, 1, 2]}) >>> df.with_columns( ... pl.col("a").cum_min().alias("cum_min"), ... pl.col("a").cum_min(reverse=True).alias("cum_min_reverse"), ... ) shape: (3, 3) ┌─────┬─────────┬─────────────────┠│ a ┆ cum_min ┆ cum_min_reverse │ │ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ i64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 3 ┆ 3 ┆ 1 │ │ 1 ┆ 1 ┆ 1 │ │ 2 ┆ 1 ┆ 2 │ └─────┴─────────┴─────────────────┘ )r$rdÚcum_minr²s rur¸Ú Expr.cum_minÅs€ô6˜Ÿ™×-Ñ-¨gÓ6Ó7Ð7rxcóJ•[URRU55$)u´ Get an array with the cumulative max computed at every element. Parameters ---------- reverse Reverse the operation. Examples -------- >>> df = pl.DataFrame({"a": [1, 3, 2]}) >>> df.with_columns( ... pl.col("a").cum_max().alias("cum_max"), ... pl.col("a").cum_max(reverse=True).alias("cum_max_reverse"), ... ) shape: (3, 3) ┌─────┬─────────┬─────────────────┠│ a ┆ cum_max ┆ cum_max_reverse │ │ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ i64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1 ┆ 1 ┆ 3 │ │ 3 ┆ 3 ┆ 3 │ │ 2 ┆ 3 ┆ 2 │ └─────┴─────────┴─────────────────┘ Null values are excluded, but can also be filled by calling `fill_null(strategy="forward")`. >>> df = pl.DataFrame({"values": [None, 10, None, 8, 9, None, 16, None]}) >>> df.with_columns( ... pl.col("values").cum_max().alias("cum_max"), ... pl.col("values") ... .cum_max() ... .fill_null(strategy="forward") ... .alias("cum_max_all_filled"), ... ) shape: (8, 3) ┌────────┬─────────┬────────────────────┠│ values ┆ cum_max ┆ cum_max_all_filled │ │ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ i64 │ â•žâ•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ null ┆ null ┆ null │ │ 10 ┆ 10 ┆ 10 │ │ null ┆ null ┆ 10 │ │ 8 ┆ 10 ┆ 10 │ │ 9 ┆ 10 ┆ 10 │ │ null ┆ null ┆ 10 │ │ 16 ┆ 16 ┆ 16 │ │ null ┆ null ┆ 16 │ └────────┴─────────┴────────────────────┘ )r$rdÚcum_maxr²s rur»Ú Expr.cum_maxâs€ôn˜Ÿ™×-Ñ-¨gÓ6Ó7Ð7rxcóJ•[URRU55$)u+ Return the cumulative count of the non-null values in the column. Parameters ---------- reverse Reverse the operation. Examples -------- >>> df = pl.DataFrame({"a": ["x", "k", None, "d"]}) >>> df.with_columns( ... pl.col("a").cum_count().alias("cum_count"), ... pl.col("a").cum_count(reverse=True).alias("cum_count_reverse"), ... ) shape: (4, 3) ┌──────┬───────────┬───────────────────┠│ a ┆ cum_count ┆ cum_count_reverse │ │ --- ┆ --- ┆ --- │ │ str ┆ u32 ┆ u32 │ â•žâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ x ┆ 1 ┆ 3 │ │ k ┆ 2 ┆ 2 │ │ null ┆ 2 ┆ 1 │ │ d ┆ 3 ┆ 1 │ └──────┴───────────┴───────────────────┘ )r$rdÚ cum_countr²s rur¾ÚExpr.cum_counts€ô8˜Ÿ™×/Ñ/°Ó8Ó9Ð9rxcóH•[URR55$)u^ Rounds down to the nearest integer value. Only works on floating point Series. Examples -------- >>> df = pl.DataFrame({"a": [0.3, 0.5, 1.0, 1.1]}) >>> df.select(pl.col("a").floor()) shape: (4, 1) ┌─────┠│ a │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•¡ │ 0.0 │ │ 0.0 │ │ 1.0 │ │ 1.0 │ └─────┘ )r$rdÚfloorr|s rurÁÚ Expr.floor9s€ô,˜Ÿ™×+Ñ+Ó-Ó.Ð.rxcóH•[URR55$)u[ Rounds up to the nearest integer value. Only works on floating point Series. Examples -------- >>> df = pl.DataFrame({"a": [0.3, 0.5, 1.0, 1.1]}) >>> df.select(pl.col("a").ceil()) shape: (4, 1) ┌─────┠│ a │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•¡ │ 1.0 │ │ 1.0 │ │ 1.0 │ │ 2.0 │ └─────┘ )r$rdÚceilr|s rurÄÚ Expr.ceilQó€ô,˜Ÿ™×*Ñ*Ó,Ó-Ð-rxcóJ•[URRX55$)u Round underlying floating point data by `decimals` digits. The default rounding mode is "half to even" (also known as "bankers' rounding"). Parameters ---------- decimals Number of decimals to round by. mode : {'half_to_even', 'half_away_from_zero'} RoundMode. * *half_to_even* round to the nearest even number * *half_away_from_zero* round to the nearest number away from zero Examples -------- >>> df = pl.DataFrame({"a": [0.33, 0.52, 1.02, 1.17]}) >>> df.select(pl.col("a").round(1)) shape: (4, 1) ┌─────┠│ a │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•¡ │ 0.3 │ │ 0.5 │ │ 1.0 │ │ 1.2 │ └─────┘ >>> df = pl.DataFrame( ... { ... "f64": [-3.5, -2.5, -1.5, -0.5, 0.5, 1.5, 2.5, 3.5], ... "d": ["-3.5", "-2.5", "-1.5", "-0.5", "0.5", "1.5", "2.5", "3.5"], ... }, ... schema_overrides={"d": pl.Decimal(scale=1)}, ... ) >>> df.with_columns( ... pl.all().round(mode="half_away_from_zero").name.suffix("_away"), ... pl.all().round(mode="half_to_even").name.suffix("_to_even"), ... ) shape: (8, 6) ┌──────┬──────────────┬──────────┬──────────────┬─────────────┬──────────────┠│ f64 ┆ d ┆ f64_away ┆ d_away ┆ f64_to_even ┆ d_to_even │ │ --- ┆ --- ┆ --- ┆ --- ┆ --- ┆ --- │ │ f64 ┆ decimal[*,1] ┆ f64 ┆ decimal[*,1] ┆ f64 ┆ decimal[*,1] │ â•žâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ -3.5 ┆ -3.5 ┆ -4.0 ┆ -4.0 ┆ -4.0 ┆ -4.0 │ │ -2.5 ┆ -2.5 ┆ -3.0 ┆ -3.0 ┆ -2.0 ┆ -2.0 │ │ -1.5 ┆ -1.5 ┆ -2.0 ┆ -2.0 ┆ -2.0 ┆ -2.0 │ │ -0.5 ┆ -0.5 ┆ -1.0 ┆ -1.0 ┆ -0.0 ┆ 0.0 │ │ 0.5 ┆ 0.5 ┆ 1.0 ┆ 1.0 ┆ 0.0 ┆ 0.0 │ │ 1.5 ┆ 1.5 ┆ 2.0 ┆ 2.0 ┆ 2.0 ┆ 2.0 │ │ 2.5 ┆ 2.5 ┆ 3.0 ┆ 3.0 ┆ 2.0 ┆ 2.0 │ │ 3.5 ┆ 3.5 ┆ 4.0 ┆ 4.0 ┆ 4.0 ┆ 4.0 │ └──────┴──────────────┴──────────┴──────────────┴─────────────┴──────────────┘ )r$rdÚround)r}ÚdecimalsÚmodes rurÈÚ Expr.roundis€ôz˜Ÿ™×+Ñ+¨HÓ;Ó<Ð>> df = pl.DataFrame({"a": [0.01234, 3.333, 1234.0]}) >>> df.with_columns(pl.col("a").round_sig_figs(2).alias("round_sig_figs")) shape: (3, 2) ┌─────────┬────────────────┠│ a ┆ round_sig_figs │ │ --- ┆ --- │ │ f64 ┆ f64 │ â•žâ•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 0.01234 ┆ 0.012 │ │ 3.333 ┆ 3.3 │ │ 1234.0 ┆ 1200.0 │ └─────────┴────────────────┘ )r$rdÚround_sig_figs)r}Údigitss rurÍÚExpr.round_sig_figs¨s€ô0˜Ÿ™×4Ñ4°VÓ<Ó=Ð=rxcó`•[U5n[URRU55$)u© Compute the dot/inner product between two Expressions. Parameters ---------- other Expression to compute dot product with. Examples -------- >>> df = pl.DataFrame( ... { ... "a": [1, 3, 5], ... "b": [2, 4, 6], ... } ... ) >>> df.select(pl.col("a").dot(pl.col("b"))) shape: (1, 1) ┌─────┠│ a │ │ --- │ │ i64 │ â•žâ•â•â•â•â•â•¡ │ 44 │ └─────┘ )rr$rdÚdotržs rurÑÚExpr.dotÂs(€ô6-¨UÓ3ˆ ܘŸ™×)Ñ)¨,Ó7Ó8Ð8rxcóH•[URR55$)uÝ Compute the most occurring value(s). Can return multiple Values. Examples -------- >>> df = pl.DataFrame( ... { ... "a": [1, 1, 2, 3], ... "b": [1, 1, 2, 2], ... } ... ) >>> df.select(pl.all().mode().first()) # doctest: +IGNORE_RESULT shape: (2, 2) ┌─────┬─────┠│ a ┆ b │ │ --- ┆ --- │ │ i64 ┆ i64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ 1 ┆ 1 │ └─────┴─────┘ )r$rdrÊr|s rurÊÚ Expr.modeàs€ô0˜Ÿ™×*Ñ*Ó,Ó-Ð-rx©ÚstrictÚwrap_numericalcóv•[U5n[URRURX#55$)u( Cast between data types. Parameters ---------- dtype DataType to cast to. strict Raise if cast is invalid on rows after predicates are pushed down. If `False`, invalid casts will produce null values. wrap_numerical If True numeric casts wrap overflowing values instead of marking the cast as invalid. Examples -------- >>> df = pl.DataFrame( ... { ... "a": [1, 2, 3], ... "b": ["4", "5", "6"], ... } ... ) >>> df.with_columns( ... pl.col("a").cast(pl.Float64), ... pl.col("b").cast(pl.Int32), ... ) shape: (3, 2) ┌─────┬─────┠│ a ┆ b │ │ --- ┆ --- │ │ f64 ┆ i32 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ 1.0 ┆ 4 │ │ 2.0 ┆ 5 │ │ 3.0 ┆ 6 │ └─────┴─────┘ )r'r$rdÚcastÚ_pydatatype_expr)r}ÚdtyperÖr×s rurÙÚ Expr.castús6€ôX)¨Ó/ˆÜØ L‰L× Ñ ˜e×4Ñ4°fÓ Mó ð rx)Ú descendingÚ nulls_lastrÝcóJ•[URRX55$)u” Sort this column. When used in a projection/selection context, the whole column is sorted. When used in a group by context, the groups are sorted. Parameters ---------- descending Sort in descending order. nulls_last Place null values last. Examples -------- >>> df = pl.DataFrame( ... { ... "a": [1, None, 3, 2], ... } ... ) >>> df.select(pl.col("a").sort()) shape: (4, 1) ┌──────┠│ a │ │ --- │ │ i64 │ â•žâ•â•â•â•â•â•â•¡ │ null │ │ 1 │ │ 2 │ │ 3 │ └──────┘ >>> df.select(pl.col("a").sort(descending=True)) shape: (4, 1) ┌──────┠│ a │ │ --- │ │ i64 │ â•žâ•â•â•â•â•â•â•¡ │ null │ │ 3 │ │ 2 │ │ 1 │ └──────┘ >>> df.select(pl.col("a").sort(nulls_last=True)) shape: (4, 1) ┌──────┠│ a │ │ --- │ │ i64 │ â•žâ•â•â•â•â•â•â•¡ │ 1 │ │ 2 │ │ 3 │ │ null │ └──────┘ When sorting in a group by context, the groups are sorted. >>> df = pl.DataFrame( ... { ... "group": ["one", "one", "one", "two", "two", "two"], ... "value": [1, 98, 2, 3, 99, 4], ... } ... ) >>> df.group_by("group").agg(pl.col("value").sort()) # doctest: +IGNORE_RESULT shape: (2, 2) ┌───────┬────────────┠│ group ┆ value │ │ --- ┆ --- │ │ str ┆ list[i64] │ â•žâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ two ┆ [3, 4, 99] │ │ one ┆ [1, 2, 98] │ └───────┴────────────┘ )r$rdÚ sort_with©r}rÝrÞs ruÚsortÚ Expr.sort+s€ôZ˜Ÿ™×/Ñ/° ÓGÓHÐHrxcó`•[U5n[URRU55$)u Return the `k` largest elements. Non-null elements are always preferred over null elements. The output is not guaranteed to be in any particular order, call :func:`sort` after this function if you wish the output to be sorted. This has time complexity: .. math:: O(n) Parameters ---------- k Number of elements to return. See Also -------- top_k_by bottom_k bottom_k_by Examples -------- Get the 5 largest values in series. >>> df = pl.DataFrame({"value": [1, 98, 2, 3, 99, 4]}) >>> df.select( ... pl.col("value").top_k().alias("top_k"), ... pl.col("value").bottom_k().alias("bottom_k"), ... ) shape: (5, 2) ┌───────┬──────────┠│ top_k ┆ bottom_k │ │ --- ┆ --- │ │ i64 ┆ i64 │ â•žâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•¡ │ 4 ┆ 1 │ │ 98 ┆ 98 │ │ 2 ┆ 2 │ │ 3 ┆ 3 │ │ 99 ┆ 4 │ └───────┴──────────┘ )rr$rdÚtop_k©r}ÚkÚk_pyexprs ruråÚ Expr.top_kzs)€ôZ)¨Ó+ˆÜ˜Ÿ™×+Ñ+¨HÓ5Ó6Ð6rxú1.0.0©Úversioncó¢•[U5n[U5n[U[U5SS5n[ UR R XTUS95$)uí Return the elements corresponding to the `k` largest elements of the `by` column(s). Non-null elements are always preferred over null elements, regardless of the value of `reverse`. The output is not guaranteed to be in any particular order, call :func:`sort` after this function if you wish the output to be sorted. This has time complexity: .. math:: O(n \log{n}) .. versionchanged:: 1.0.0 The `descending` parameter was renamed to `reverse`. Parameters ---------- by Column(s) used to determine the largest elements. Accepts expression input. Strings are parsed as column names. k Number of elements to return. reverse Consider the `k` smallest elements of the `by` column(s) (instead of the `k` largest). This can be specified per column by passing a sequence of booleans. See Also -------- top_k bottom_k bottom_k_by Examples -------- >>> df = pl.DataFrame( ... { ... "a": [1, 2, 3, 4, 5, 6], ... "b": [6, 5, 4, 3, 2, 1], ... "c": ["Apple", "Orange", "Apple", "Apple", "Banana", "Banana"], ... } ... ) >>> df shape: (6, 3) ┌─────┬─────┬────────┠│ a ┆ b ┆ c │ │ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ str │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•¡ │ 1 ┆ 6 ┆ Apple │ │ 2 ┆ 5 ┆ Orange │ │ 3 ┆ 4 ┆ Apple │ │ 4 ┆ 3 ┆ Apple │ │ 5 ┆ 2 ┆ Banana │ │ 6 ┆ 1 ┆ Banana │ └─────┴─────┴────────┘ Get the top 2 rows by column `a` or `b`. >>> df.select( ... pl.all().top_k_by("a", 2).name.suffix("_top_by_a"), ... pl.all().top_k_by("b", 2).name.suffix("_top_by_b"), ... ) shape: (2, 6) ┌────────────┬────────────┬────────────┬────────────┬────────────┬────────────┠│ a_top_by_a ┆ b_top_by_a ┆ c_top_by_a ┆ a_top_by_b ┆ b_top_by_b ┆ c_top_by_b │ │ --- ┆ --- ┆ --- ┆ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ str ┆ i64 ┆ i64 ┆ str │ â•žâ•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 6 ┆ 1 ┆ Banana ┆ 1 ┆ 6 ┆ Apple │ │ 5 ┆ 2 ┆ Banana ┆ 2 ┆ 5 ┆ Orange │ └────────────┴────────────┴────────────┴────────────┴────────────┴────────────┘ Get the top 2 rows by multiple columns with given order. >>> df.select( ... pl.all() ... .top_k_by(["c", "a"], 2, reverse=[False, True]) ... .name.suffix("_by_ca"), ... pl.all() ... .top_k_by(["c", "b"], 2, reverse=[False, True]) ... .name.suffix("_by_cb"), ... ) shape: (2, 6) ┌─────────┬─────────┬─────────┬─────────┬─────────┬─────────┠│ a_by_ca ┆ b_by_ca ┆ c_by_ca ┆ a_by_cb ┆ b_by_cb ┆ c_by_cb │ │ --- ┆ --- ┆ --- ┆ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ str ┆ i64 ┆ i64 ┆ str │ â•žâ•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•¡ │ 2 ┆ 5 ┆ Orange ┆ 2 ┆ 5 ┆ Orange │ │ 5 ┆ 2 ┆ Banana ┆ 6 ┆ 1 ┆ Banana │ └─────────┴─────────┴─────────┴─────────┴─────────┴─────────┘ Get the top 2 rows by column `a` in each group. >>> ( ... df.group_by("c", maintain_order=True) ... .agg(pl.all().top_k_by("a", 2)) ... .explode(pl.all().exclude("c")) ... ) shape: (5, 3) ┌────────┬─────┬─────┠│ c ┆ a ┆ b │ │ --- ┆ --- ┆ --- │ │ str ┆ i64 ┆ i64 │ â•žâ•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ Apple ┆ 4 ┆ 3 │ │ Apple ┆ 3 ┆ 4 │ │ Orange ┆ 2 ┆ 5 │ │ Banana ┆ 6 ┆ 1 │ │ Banana ┆ 5 ┆ 2 │ └────────┴─────┴─────┘ r¯Úby©rçr¯)rrrr†r$rdÚtop_k_by)r}rîrçr¯rèÚ by_pyexprss rurðÚ Expr.top_k_byªsL€ôr)¨Ó+ˆÜ3°BÓ7ˆ ä˜g¤s¨:£¸ À4ÓHˆä˜Ÿ™×.Ñ.¨zÈwÐ.ÐWÓXÐXrxcó`•[U5n[URRU55$)u Return the `k` smallest elements. Non-null elements are always preferred over null elements. The output is not guaranteed to be in any particular order, call :func:`sort` after this function if you wish the output to be sorted. This has time complexity: .. math:: O(n) Parameters ---------- k Number of elements to return. See Also -------- top_k top_k_by bottom_k_by Examples -------- >>> df = pl.DataFrame( ... { ... "value": [1, 98, 2, 3, 99, 4], ... } ... ) >>> df.select( ... pl.col("value").top_k().alias("top_k"), ... pl.col("value").bottom_k().alias("bottom_k"), ... ) shape: (5, 2) ┌───────┬──────────┠│ top_k ┆ bottom_k │ │ --- ┆ --- │ │ i64 ┆ i64 │ â•žâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•¡ │ 4 ┆ 1 │ │ 98 ┆ 98 │ │ 2 ┆ 2 │ │ 3 ┆ 3 │ │ 99 ┆ 4 │ └───────┴──────────┘ )rr$rdÚbottom_kræs rurôÚ Expr.bottom_k*s)€ô^)¨Ó+ˆÜ˜Ÿ™×.Ñ.¨xÓ8Ó9Ð9rxcó¢•[U5n[U5n[U[U5SS5n[ UR R XTUS95$)u Return the elements corresponding to the `k` smallest elements of the `by` column(s). Non-null elements are always preferred over null elements, regardless of the value of `reverse`. The output is not guaranteed to be in any particular order, call :func:`sort` after this function if you wish the output to be sorted. This has time complexity: .. math:: O(n \log{n}) .. versionchanged:: 1.0.0 The `descending` parameter was renamed `reverse`. Parameters ---------- by Column(s) used to determine the smallest elements. Accepts expression input. Strings are parsed as column names. k Number of elements to return. reverse Consider the `k` largest elements of the `by` column(s) (instead of the `k` smallest). This can be specified per column by passing a sequence of booleans. See Also -------- top_k top_k_by bottom_k Examples -------- >>> df = pl.DataFrame( ... { ... "a": [1, 2, 3, 4, 5, 6], ... "b": [6, 5, 4, 3, 2, 1], ... "c": ["Apple", "Orange", "Apple", "Apple", "Banana", "Banana"], ... } ... ) >>> df shape: (6, 3) ┌─────┬─────┬────────┠│ a ┆ b ┆ c │ │ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ str │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•¡ │ 1 ┆ 6 ┆ Apple │ │ 2 ┆ 5 ┆ Orange │ │ 3 ┆ 4 ┆ Apple │ │ 4 ┆ 3 ┆ Apple │ │ 5 ┆ 2 ┆ Banana │ │ 6 ┆ 1 ┆ Banana │ └─────┴─────┴────────┘ Get the bottom 2 rows by column `a` or `b`. >>> df.select( ... pl.all().bottom_k_by("a", 2).name.suffix("_btm_by_a"), ... pl.all().bottom_k_by("b", 2).name.suffix("_btm_by_b"), ... ) shape: (2, 6) ┌────────────┬────────────┬────────────┬────────────┬────────────┬────────────┠│ a_btm_by_a ┆ b_btm_by_a ┆ c_btm_by_a ┆ a_btm_by_b ┆ b_btm_by_b ┆ c_btm_by_b │ │ --- ┆ --- ┆ --- ┆ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ str ┆ i64 ┆ i64 ┆ str │ â•žâ•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1 ┆ 6 ┆ Apple ┆ 6 ┆ 1 ┆ Banana │ │ 2 ┆ 5 ┆ Orange ┆ 5 ┆ 2 ┆ Banana │ └────────────┴────────────┴────────────┴────────────┴────────────┴────────────┘ Get the bottom 2 rows by multiple columns with given order. >>> df.select( ... pl.all() ... .bottom_k_by(["c", "a"], 2, reverse=[False, True]) ... .name.suffix("_by_ca"), ... pl.all() ... .bottom_k_by(["c", "b"], 2, reverse=[False, True]) ... .name.suffix("_by_cb"), ... ) shape: (2, 6) ┌─────────┬─────────┬─────────┬─────────┬─────────┬─────────┠│ a_by_ca ┆ b_by_ca ┆ c_by_ca ┆ a_by_cb ┆ b_by_cb ┆ c_by_cb │ │ --- ┆ --- ┆ --- ┆ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ str ┆ i64 ┆ i64 ┆ str │ â•žâ•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•¡ │ 4 ┆ 3 ┆ Apple ┆ 1 ┆ 6 ┆ Apple │ │ 3 ┆ 4 ┆ Apple ┆ 3 ┆ 4 ┆ Apple │ └─────────┴─────────┴─────────┴─────────┴─────────┴─────────┘ Get the bottom 2 rows by column `a` in each group. >>> ( ... df.group_by("c", maintain_order=True) ... .agg(pl.all().bottom_k_by("a", 2)) ... .explode(pl.all().exclude("c")) ... ) shape: (5, 3) ┌────────┬─────┬─────┠│ c ┆ a ┆ b │ │ --- ┆ --- ┆ --- │ │ str ┆ i64 ┆ i64 │ â•žâ•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ Apple ┆ 1 ┆ 6 │ │ Apple ┆ 3 ┆ 4 │ │ Orange ┆ 2 ┆ 5 │ │ Banana ┆ 5 ┆ 2 │ │ Banana ┆ 6 ┆ 1 │ └────────┴─────┴─────┘ r¯rîrï)rrrr†r$rdÚ bottom_k_by)r}rîrçr¯rèÚ by_pyexprs rur÷ÚExpr.bottom_k_by\sQ€ôr)¨Ó+ˆÜ2°2Ó6ˆ ܘg¤s¨9£~°yÀ$ÓGˆÜØ L‰L× $Ñ $ YÀGÐ $Ð Ló ð rxcóJ•[URRX55$)u› Get the index values that would sort this column. Parameters ---------- descending Sort in descending (descending) order. nulls_last Place null values last instead of first. Returns ------- Expr Expression of data type :class:`UInt32`. See Also -------- Expr.gather: Take values by index. Expr.rank : Get the rank of each row. Examples -------- >>> df = pl.DataFrame( ... { ... "a": [20, 10, 30], ... "b": [1, 2, 3], ... } ... ) >>> df.select(pl.col("a").arg_sort()) shape: (3, 1) ┌─────┠│ a │ │ --- │ │ u32 │ â•žâ•â•â•â•â•â•¡ │ 1 │ │ 0 │ │ 2 │ └─────┘ Use gather to apply the arg sort to other columns. >>> df.select(pl.col("b").gather(pl.col("a").arg_sort())) shape: (3, 1) ┌─────┠│ b │ │ --- │ │ i64 │ â•žâ•â•â•â•â•â•¡ │ 2 │ │ 1 │ │ 3 │ └─────┘ )r$rdÚarg_sortrás rurûÚ Expr.arg_sortÜs€ôn˜Ÿ™×.Ñ.¨zÓFÓGÐGrxcóH•[URR55$)u- Get the index of the maximal value. Examples -------- >>> df = pl.DataFrame( ... { ... "a": [20, 10, 30], ... } ... ) >>> df.select(pl.col("a").arg_max()) shape: (1, 1) ┌─────┠│ a │ │ --- │ │ u32 │ â•žâ•â•â•â•â•â•¡ │ 2 │ └─────┘ )r$rdÚarg_maxr|s rurþÚ Expr.arg_max ó€ô*˜Ÿ™×-Ñ-Ó/Ó0Ð0rxcóH•[URR55$)u- Get the index of the minimal value. Examples -------- >>> df = pl.DataFrame( ... { ... "a": [20, 10, 30], ... } ... ) >>> df.select(pl.col("a").arg_min()) shape: (1, 1) ┌─────┠│ a │ │ --- │ │ u32 │ â•žâ•â•â•â•â•â•¡ │ 1 │ └─────┘ )r$rdÚarg_minr|s rurÚ Expr.arg_min, rrxcó^•[USS9n[URRU55$)ui Get the index of the first occurrence of a value, or ``None`` if it's not found. Parameters ---------- element Value to find. Examples -------- >>> df = pl.DataFrame({"a": [1, None, 17]}) >>> df.select( ... [ ... pl.col("a").index_of(17).alias("seventeen"), ... pl.col("a").index_of(None).alias("null"), ... pl.col("a").index_of(55).alias("fiftyfive"), ... ] ... ) shape: (1, 3) ┌───────────┬──────┬───────────┠│ seventeen ┆ null ┆ fiftyfive │ │ --- ┆ --- ┆ --- │ │ u32 ┆ u32 ┆ u32 │ â•žâ•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•¡ │ 2 ┆ 1 ┆ null │ └───────────┴──────┴───────────┘ Tr›)rr$rdÚindex_of)r}ÚelementÚelement_pyexprs rurÚ Expr.index_ofC s*€ô8/¨wÀ4ÑHˆÜ˜Ÿ™×.Ñ.¨~Ó>Ó?Ð?rx)rÝcób•[USSS9n[URRXBU55$)u° Find indices where elements should be inserted to maintain order. .. math:: a[i-1] < v <= a[i] Parameters ---------- element Expression or scalar value. side : {'any', 'left', 'right'} If 'any', the index of the first suitable location found is given. If 'left', the index of the leftmost suitable location found is given. If 'right', return the rightmost suitable location found is given. descending Boolean indicating whether the values are descending or not (they are required to be sorted either way). Examples -------- >>> df = pl.DataFrame( ... { ... "values": [1, 2, 3, 5], ... } ... ) >>> df.select( ... [ ... pl.col("values").search_sorted(0).alias("zero"), ... pl.col("values").search_sorted(3).alias("three"), ... pl.col("values").search_sorted(6).alias("six"), ... ] ... ) shape: (1, 3) ┌──────┬───────┬─────┠│ zero ┆ three ┆ six │ │ --- ┆ --- ┆ --- │ │ u32 ┆ u32 ┆ u32 │ â•žâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ 0 ┆ 2 ┆ 4 │ └──────┴───────┴─────┘ T)rœÚlist_as_series)rr$rdÚ search_sorted)r}rÚsiderÝrs rur ÚExpr.search_sortedb s4€ô^/Ø  °Tñ ˆô˜Ÿ™×3Ñ3°NÈ*ÓUÓVÐVrx)rÝrÞÚ multithreadedÚmaintain_orderc ó•[U/UQ76n[U[U5SS5n[U[U5SS5n[URR XrX4U55$)uF Sort this column by the ordering of other columns. When used in a projection/selection context, the whole column is sorted. When used in a group by context, the groups are sorted. Parameters ---------- by Column(s) to sort by. Accepts expression input. Strings are parsed as column names. *more_by Additional columns to sort by, specified as positional arguments. descending Sort in descending order. When sorting by multiple columns, can be specified per column by passing a sequence of booleans. nulls_last Place null values last; can specify a single boolean applying to all columns or a sequence of booleans for per-column control. multithreaded Sort using multiple threads. maintain_order Whether the order should be maintained if elements are equal. Examples -------- Pass a single column name to sort by that column. >>> df = pl.DataFrame( ... { ... "group": ["a", "a", "b", "b"], ... "value1": [1, 3, 4, 2], ... "value2": [8, 7, 6, 5], ... } ... ) >>> df.select(pl.col("group").sort_by("value1")) shape: (4, 1) ┌───────┠│ group │ │ --- │ │ str │ â•žâ•â•â•â•â•â•â•â•¡ │ a │ │ b │ │ a │ │ b │ └───────┘ Sorting by expressions is also supported. >>> df.select(pl.col("group").sort_by(pl.col("value1") + pl.col("value2"))) shape: (4, 1) ┌───────┠│ group │ │ --- │ │ str │ â•žâ•â•â•â•â•â•â•â•¡ │ b │ │ a │ │ a │ │ b │ └───────┘ Sort by multiple columns by passing a list of columns. >>> df.select(pl.col("group").sort_by(["value1", "value2"], descending=True)) shape: (4, 1) ┌───────┠│ group │ │ --- │ │ str │ â•žâ•â•â•â•â•â•â•â•¡ │ b │ │ a │ │ b │ │ a │ └───────┘ Or use positional arguments to sort by multiple columns in the same way. >>> df.select(pl.col("group").sort_by("value1", "value2")) shape: (4, 1) ┌───────┠│ group │ │ --- │ │ str │ â•žâ•â•â•â•â•â•â•â•¡ │ a │ │ b │ │ a │ │ b │ └───────┘ When sorting in a group by context, the groups are sorted. >>> df.group_by("group").agg( ... pl.col("value1").sort_by("value2") ... ) # doctest: +IGNORE_RESULT shape: (2, 2) ┌───────┬───────────┠│ group ┆ value1 │ │ --- ┆ --- │ │ str ┆ list[i64] │ â•žâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•¡ │ a ┆ [3, 1] │ │ b ┆ [2, 4] │ └───────┴───────────┘ Take a single row from each group where a column attains its minimal value within that group. >>> df.group_by("group").agg( ... pl.all().sort_by("value2").first() ... ) # doctest: +IGNORE_RESULT shape: (2, 3) ┌───────┬────────┬────────┠│ group ┆ value1 ┆ value2 | │ --- ┆ --- ┆ --- │ │ str ┆ i64 ┆ i64 | â•žâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•¡ │ a ┆ 3 ┆ 7 | │ b ┆ 2 ┆ 5 | └───────┴────────┴────────┘ rÝrîrÞ)rrr†r$rdÚsort_by)r}rîrÝrÞrrÚmore_byrñs rurÚ Expr.sort_by– sb€ôJ4°BÐA¸ÒAˆ Ü  ¬S°«_¸lÈDÓQˆ Ü  ¬S°«_¸lÈDÓQˆ ÜØ L‰L× Ñ Ø¨ À>ó ó ð rxcó„•[U[5(a[U[5(a/[U5(aX[U[R 5(a9[ R"[R"SU[S95RnO [U5n[URRU55$)uµ Take values by index. Parameters ---------- indices An expression that leads to a UInt32 dtyped Series. Returns ------- Expr Expression of the same data type. See Also -------- Expr.get : Take a single value Examples -------- >>> df = pl.DataFrame( ... { ... "group": [ ... "one", ... "one", ... "one", ... "two", ... "two", ... "two", ... ], ... "value": [1, 98, 2, 3, 99, 4], ... } ... ) >>> df.group_by("group", maintain_order=True).agg( ... pl.col("value").gather([2, 1]) ... ) shape: (2, 2) ┌───────┬───────────┠│ group ┆ value │ │ --- ┆ --- │ │ str ┆ list[i64] │ â•žâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•¡ │ one ┆ [2, 98] │ │ two ┆ [4, 99] │ └───────┴───────────┘ Ú)rÛ)r!rrir(ÚnpÚndarrayrrÚplrGr&rdrr$Úgather)r}ÚindicesÚindices_lit_pyexprs rurÚ Expr.gather$ s€ô` w¤× )Ñ )´*¸WÄc×2JÑ2JÜ ˜W× %Ñ %¬*°W¼b¿j¹j×*IÑ*Iä!"§¢¤r§y¢y°°WÄEÑ'JÓ!K×!SÑ!SÑ ä!6°wÓ!?РܘŸ™×,Ñ,Ð-?Ó@ÓAÐArxcó`•[U5n[URRU55$)u5 Return a single value by index. Parameters ---------- index An expression that leads to a UInt32 index. Returns ------- Expr Expression of the same data type. Examples -------- >>> df = pl.DataFrame( ... { ... "group": [ ... "one", ... "one", ... "one", ... "two", ... "two", ... "two", ... ], ... "value": [1, 98, 2, 3, 99, 4], ... } ... ) >>> df.group_by("group", maintain_order=True).agg(pl.col("value").get(1)) shape: (2, 2) ┌───────┬───────┠│ group ┆ value │ │ --- ┆ --- │ │ str ┆ i64 │ â•žâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•¡ │ one ┆ 98 │ │ two ┆ 99 │ └───────┴───────┘ )rr$rdÚget)r}rEÚindex_lit_pyexprs rurÚExpr.get\ s+€ôP1°Ó7ÐܘŸ™×)Ñ)Ð*:Ó;Ó<Ð>> df = pl.DataFrame({"a": [1, 2, 3, 4]}) >>> df.with_columns(shift=pl.col("a").shift()) shape: (4, 2) ┌─────┬───────┠│ a ┆ shift │ │ --- ┆ --- │ │ i64 ┆ i64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•¡ │ 1 ┆ null │ │ 2 ┆ 1 │ │ 3 ┆ 2 │ │ 4 ┆ 3 │ └─────┴───────┘ Pass a negative value to shift in the opposite direction instead. >>> df.with_columns(shift=pl.col("a").shift(-2)) shape: (4, 2) ┌─────┬───────┠│ a ┆ shift │ │ --- ┆ --- │ │ i64 ┆ i64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•¡ │ 1 ┆ 3 │ │ 2 ┆ 4 │ │ 3 ┆ null │ │ 4 ┆ null │ └─────┴───────┘ Specify `fill_value` to fill the resulting null values. >>> df.with_columns(shift=pl.col("a").shift(-2, fill_value=100)) shape: (4, 2) ┌─────┬───────┠│ a ┆ shift │ │ --- ┆ --- │ │ i64 ┆ i64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•¡ │ 1 ┆ 3 │ │ 2 ┆ 4 │ │ 3 ┆ 100 │ │ 4 ┆ 100 │ └─────┴───────┘ NTr›)rr$rdÚshift)r}Únr!Úfill_value_pyexprÚn_pyexprs rur#Ú Expr.shift‡ sB€ðN Ñ !Ü 5°jÈTÑ RÑ à $Ð Ü(¨Ó+ˆÜ˜Ÿ™×+Ñ+¨HÓHÓIÐIrxcó.•UbUb Sn[U5eUcUc Sn[U5eUS;aUb Sn[U5eUb.[USS9n[URR U55$Uce[URR X#55$)u8 Fill null values using the specified value or strategy. To interpolate over null values see interpolate. See the examples below to fill nulls with an expression. Parameters ---------- value Value used to fill null values. strategy : {None, 'forward', 'backward', 'min', 'max', 'mean', 'zero', 'one'} Strategy used to fill null values. limit Number of consecutive null values to fill when using the 'forward' or 'backward' strategy. See Also -------- backward_fill fill_nan forward_fill Notes ----- A null value is not the same as a NaN value. To fill NaN values, use :func:`fill_nan`. Examples -------- >>> df = pl.DataFrame( ... { ... "a": [1, 2, None], ... "b": [4, None, 6], ... } ... ) >>> df.with_columns(pl.col("b").fill_null(strategy="zero")) shape: (3, 2) ┌──────┬─────┠│ a ┆ b │ │ --- ┆ --- │ │ i64 ┆ i64 │ â•žâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ 1 ┆ 4 │ │ 2 ┆ 0 │ │ null ┆ 6 │ └──────┴─────┘ >>> df.with_columns(pl.col("b").fill_null(99)) shape: (3, 2) ┌──────┬─────┠│ a ┆ b │ │ --- ┆ --- │ │ i64 ┆ i64 │ â•žâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ 1 ┆ 4 │ │ 2 ┆ 99 │ │ null ┆ 6 │ └──────┴─────┘ >>> df.with_columns(pl.col("b").fill_null(strategy="forward")) shape: (3, 2) ┌──────┬─────┠│ a ┆ b │ │ --- ┆ --- │ │ i64 ┆ i64 │ â•žâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ 1 ┆ 4 │ │ 2 ┆ 4 │ │ null ┆ 6 │ └──────┴─────┘ >>> df.with_columns(pl.col("b").fill_null(pl.col("b").median())) shape: (3, 2) ┌──────┬─────┠│ a ┆ b │ │ --- ┆ --- │ │ i64 ┆ f64 │ â•žâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ 1 ┆ 4.0 │ │ 2 ┆ 5.0 │ │ null ┆ 6.0 │ └──────┴─────┘ >>> df.with_columns(pl.all().fill_null(pl.all().median())) shape: (3, 2) ┌─────┬─────┠│ a ┆ b │ │ --- ┆ --- │ │ f64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ 1.0 ┆ 4.0 │ │ 2.0 ┆ 5.0 │ │ 1.5 ┆ 6.0 │ └─────┴─────┘ z*cannot specify both `value` and `strategy`z0must specify either a fill `value` or `strategy`)ÚforwardÚbackwardzHcan only specify `limit` when strategy is set to 'backward' or 'forward'Tr›)rRrr$rdÚ fill_nullÚfill_null_with_strategy)r}ÚvalueÚstrategyÚlimitr’Ú value_pyexprs rur+ÚExpr.fill_nullÕ s§€ðB Ñ  Ñ!5Ø>ˆCܘS“/Ð !Ø ‰]˜xÑ/ØDˆCܘS“/Ð !Ø Ð4Ó 4¸Ñ9JØ\ˆCܘS“/Ð !à Ñ Ü0°À4ÑHˆLܘTŸ\™\×3Ñ3°LÓAÓBÐ BàÑ'Ð 'Ð'ܘTŸ\™\×AÑAÀ(ÓRÓSÐ Srxcó^•[USS9n[URRU55$)uÈ Fill floating point NaN value with a fill value. Parameters ---------- value Value used to fill NaN values. See Also -------- fill_null Notes ----- A NaN value is not the same as a null value. To fill null values, use :func:`fill_null`. Examples -------- >>> df = pl.DataFrame( ... { ... "a": [1.0, None, float("nan")], ... "b": [4.0, float("nan"), 6], ... } ... ) >>> df.with_columns(pl.col("b").fill_nan(0)) shape: (3, 2) ┌──────┬─────┠│ a ┆ b │ │ --- ┆ --- │ │ f64 ┆ f64 │ â•žâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ 1.0 ┆ 4.0 │ │ null ┆ 0.0 │ │ NaN ┆ 6.0 │ └──────┴─────┘ Tr›)rr$rdÚfill_nan)r}r-r%s rur3Ú Expr.fill_nanG s-€ôL2°%ÀDÑIÐܘŸ™×.Ñ.Ð/@ÓAÓBÐBrxcó"•URSUS9$)zó Fill missing values with the last non-null value. This is an alias of `.fill_null(strategy="forward")`. Parameters ---------- limit The number of consecutive null values to forward fill. See Also -------- backward_fill fill_null shift r)©r.r/©r+©r}r/s ruÚ forward_fillÚExpr.forward_fillp s€ð"~‰~ y¸ˆ~Ð>Ð>rxcó"•URSUS9$)zô Fill missing values with the next non-null value. This is an alias of `.fill_null(strategy="backward")`. Parameters ---------- limit The number of consecutive null values to backward fill. See Also -------- fill_null forward_fill shift r*r6r7r8s ruÚ backward_fillÚExpr.backward_fillƒ s€ð"~‰~ z¸ˆ~Ð?Ð?rxcóH•[URR55$)u Reverse the selection. Examples -------- >>> df = pl.DataFrame( ... { ... "A": [1, 2, 3, 4, 5], ... "fruits": ["banana", "banana", "apple", "apple", "banana"], ... "B": [5, 4, 3, 2, 1], ... "cars": ["beetle", "audi", "beetle", "beetle", "beetle"], ... } ... ) >>> df.select( ... [ ... pl.all(), ... pl.all().reverse().name.suffix("_reverse"), ... ] ... ) shape: (5, 8) ┌─────┬────────┬─────┬────────┬───────────┬────────────────┬───────────┬──────────────┠│ A ┆ fruits ┆ B ┆ cars ┆ A_reverse ┆ fruits_reverse ┆ B_reverse ┆ cars_reverse │ │ --- ┆ --- ┆ --- ┆ --- ┆ --- ┆ --- ┆ --- ┆ --- │ │ i64 ┆ str ┆ i64 ┆ str ┆ i64 ┆ str ┆ i64 ┆ str │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1 ┆ banana ┆ 5 ┆ beetle ┆ 5 ┆ banana ┆ 1 ┆ beetle │ │ 2 ┆ banana ┆ 4 ┆ audi ┆ 4 ┆ apple ┆ 2 ┆ beetle │ │ 3 ┆ apple ┆ 3 ┆ beetle ┆ 3 ┆ apple ┆ 3 ┆ beetle │ │ 4 ┆ apple ┆ 2 ┆ beetle ┆ 2 ┆ banana ┆ 4 ┆ audi │ │ 5 ┆ banana ┆ 1 ┆ beetle ┆ 1 ┆ banana ┆ 5 ┆ beetle │ └─────┴────────┴─────┴────────┴───────────┴────────────────┴───────────┴──────────────┘ )r$rdr¯r|s rur¯Ú Expr.reverse– s€ôB˜Ÿ™×-Ñ-Ó/Ó0Ð0rxcóJ•[URRU55$)u° Get standard deviation. Parameters ---------- ddof “Delta Degrees of Freedomâ€: the divisor used in the calculation is N - ddof, where N represents the number of elements. By default ddof is 1. Examples -------- >>> df = pl.DataFrame({"a": [-1, 0, 1]}) >>> df.select(pl.col("a").std()) shape: (1, 1) ┌─────┠│ a │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•¡ │ 1.0 │ └─────┘ )r$rdÚstd©r}Úddofs rurAÚExpr.std¹ ó€ô0˜Ÿ™×)Ñ)¨$Ó/Ó0Ð0rxcóJ•[URRU55$)u¦ Get variance. Parameters ---------- ddof “Delta Degrees of Freedomâ€: the divisor used in the calculation is N - ddof, where N represents the number of elements. By default ddof is 1. Examples -------- >>> df = pl.DataFrame({"a": [-1, 0, 1]}) >>> df.select(pl.col("a").var()) shape: (1, 1) ┌─────┠│ a │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•¡ │ 1.0 │ └─────┘ )r$rdÚvarrBs rurGÚExpr.varÓ rErxcóH•[URR55$)u Get maximum value. Examples -------- >>> df = pl.DataFrame({"a": [-1.0, float("nan"), 1.0]}) >>> df.select(pl.col("a").max()) shape: (1, 1) ┌─────┠│ a │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•¡ │ 1.0 │ └─────┘ )r$rdÚmaxr|s rurJÚExpr.maxí ó€ô"˜Ÿ™×)Ñ)Ó+Ó,Ð,rxcóH•[URR55$)u  Get minimum value. Examples -------- >>> df = pl.DataFrame({"a": [-1.0, float("nan"), 1.0]}) >>> df.select(pl.col("a").min()) shape: (1, 1) ┌──────┠│ a │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•â•¡ │ -1.0 │ └──────┘ )r$rdÚminr|s rurNÚExpr.min rLrxcóH•[URR55$)u¦ Get maximum value, but propagate/poison encountered NaN values. This differs from numpy's `nanmax` as numpy defaults to propagating NaN values, whereas polars defaults to ignoring them. Examples -------- >>> df = pl.DataFrame({"a": [0.0, float("nan")]}) >>> df.select(pl.col("a").nan_max()) shape: (1, 1) ┌─────┠│ a │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•¡ │ NaN │ └─────┘ )r$rdÚnan_maxr|s rurQÚ Expr.nan_max ó€ô(˜Ÿ™×-Ñ-Ó/Ó0Ð0rxcóH•[URR55$)u¦ Get minimum value, but propagate/poison encountered NaN values. This differs from numpy's `nanmax` as numpy defaults to propagating NaN values, whereas polars defaults to ignoring them. Examples -------- >>> df = pl.DataFrame({"a": [0.0, float("nan")]}) >>> df.select(pl.col("a").nan_min()) shape: (1, 1) ┌─────┠│ a │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•¡ │ NaN │ └─────┘ )r$rdÚnan_minr|s rurUÚ Expr.nan_min) rSrxcóH•[URR55$)u$ Get sum value. Notes ----- * Dtypes in {Int8, UInt8, Int16, UInt16} are cast to Int64 before summing to prevent overflow issues. * If there are no non-null values, then the output is `0`. If you would prefer empty sums to return `None`, you can use `pl.when(expr.count()>0).then(expr.sum())` instead of `expr.sum()`. Examples -------- >>> df = pl.DataFrame({"a": [-1, 0, 1]}) >>> df.select(pl.col("a").sum()) shape: (1, 1) ┌─────┠│ a │ │ --- │ │ i64 │ â•žâ•â•â•â•â•â•¡ │ 0 │ └─────┘ )r$rdr;r|s rur;ÚExpr.sum? ó€ô4˜Ÿ™×)Ñ)Ó+Ó,Ð,rxcóH•[URR55$)uï Get mean value. Examples -------- >>> df = pl.DataFrame({"a": [-1, 0, 1]}) >>> df.select(pl.col("a").mean()) shape: (1, 1) ┌─────┠│ a │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•¡ │ 0.0 │ └─────┘ )r$rdÚmeanr|s rur[Ú Expr.mean[ ó€ô"˜Ÿ™×*Ñ*Ó,Ó-Ð-rxcóH•[URR55$)u Get median value using linear interpolation. Examples -------- >>> df = pl.DataFrame({"a": [-1, 0, 1]}) >>> df.select(pl.col("a").median()) shape: (1, 1) ┌─────┠│ a │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•¡ │ 0.0 │ └─────┘ )r$rdÚmedianr|s rur_Ú Expr.mediann s€ô"˜Ÿ™×,Ñ,Ó.Ó/Ð/rxcóH•[URR55$)uÚ Compute the product of an expression. Notes ----- If there are no non-null values, then the output is `1`. If you would prefer empty products to return `None`, you can use `pl.when(expr.count()>0).then(expr.product())` instead of `expr.product()`. Examples -------- >>> df = pl.DataFrame({"a": [1, 2, 3]}) >>> df.select(pl.col("a").product()) shape: (1, 1) ┌─────┠│ a │ │ --- │ │ i64 │ â•žâ•â•â•â•â•â•¡ │ 6 │ └─────┘ )r$rdÚproductr|s rurbÚ Expr.product s€ô0˜Ÿ™×-Ñ-Ó/Ó0Ð0rxcóH•[URR55$)u Count unique values. Notes ----- `null` is considered to be a unique value for the purposes of this operation. Examples -------- >>> df = pl.DataFrame({"x": [1, 1, 2, 2, 3], "y": [1, 1, 1, None, None]}) >>> df.select( ... x_unique=pl.col("x").n_unique(), ... y_unique=pl.col("y").n_unique(), ... ) shape: (1, 2) ┌──────────┬──────────┠│ x_unique ┆ y_unique │ │ --- ┆ --- │ │ u32 ┆ u32 │ â•žâ•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•¡ │ 3 ┆ 2 │ └──────────┴──────────┘ )r$rdÚn_uniquer|s rureÚ Expr.n_unique› s€ô0˜Ÿ™×.Ñ.Ó0Ó1Ð1rxcóH•[URR55$)u Approximate count of unique values. This is done using the HyperLogLog++ algorithm for cardinality estimation. Examples -------- >>> df = pl.DataFrame({"n": [1, 1, 2]}) >>> df.select(pl.col("n").approx_n_unique()) shape: (1, 1) ┌─────┠│ n │ │ --- │ │ u32 │ â•žâ•â•â•â•â•â•¡ │ 2 │ └─────┘ >>> df = pl.DataFrame({"n": range(1000)}) >>> df.select( ... exact=pl.col("n").n_unique(), ... approx=pl.col("n").approx_n_unique(), ... ) # doctest: +SKIP shape: (1, 2) ┌───────┬────────┠│ exact ┆ approx │ │ --- ┆ --- │ │ u32 ┆ u32 │ â•žâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•¡ │ 1000 ┆ 1005 │ └───────┴────────┘ )r$rdÚapprox_n_uniquer|s rurhÚExpr.approx_n_uniqueµ s€ô@˜Ÿ™×5Ñ5Ó7Ó8Ð8rxcóH•[URR55$)u Count null values. Examples -------- >>> df = pl.DataFrame( ... { ... "a": [None, 1, None], ... "b": [10, None, 300], ... "c": [350, 650, 850], ... } ... ) >>> df.select(pl.all().null_count()) shape: (1, 3) ┌─────┬─────┬─────┠│ a ┆ b ┆ c │ │ --- ┆ --- ┆ --- │ │ u32 ┆ u32 ┆ u32 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ 2 ┆ 1 ┆ 0 │ └─────┴─────┴─────┘ )r$rdÚ null_countr|s rurkÚExpr.null_count× s€ô.˜Ÿ™×0Ñ0Ó2Ó3Ð3rxcó(•UR5S:„$)un Check whether the expression contains one or more null values. Examples -------- >>> df = pl.DataFrame( ... { ... "a": [None, 1, None], ... "b": [10, None, 300], ... "c": [350, 650, 850], ... } ... ) >>> df.select(pl.all().has_nulls()) shape: (1, 3) ┌──────┬──────┬───────┠│ a ┆ b ┆ c │ │ --- ┆ --- ┆ --- │ │ bool ┆ bool ┆ bool │ â•žâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•¡ │ true ┆ true ┆ false │ └──────┴──────┴───────┘ r)rkr|s ruÚ has_nullsÚExpr.has_nullsð s€ð.‰Ó  1Ñ$Ð$rxcóH•[URR55$)u Get index of first unique value. Examples -------- >>> df = pl.DataFrame( ... { ... "a": [8, 9, 10], ... "b": [None, 4, 4], ... } ... ) >>> df.select(pl.col("a").arg_unique()) shape: (3, 1) ┌─────┠│ a │ │ --- │ │ u32 │ â•žâ•â•â•â•â•â•¡ │ 0 │ │ 1 │ │ 2 │ └─────┘ >>> df.select(pl.col("b").arg_unique()) shape: (2, 1) ┌─────┠│ b │ │ --- │ │ u32 │ â•žâ•â•â•â•â•â•¡ │ 0 │ │ 1 │ └─────┘ )r$rdÚ arg_uniquer|s rurqÚExpr.arg_unique s€ôD˜Ÿ™×0Ñ0Ó2Ó3Ð3rx)rcóœ•U(a#[URR55$[URR55$)uK Get unique values of this expression. Parameters ---------- maintain_order Maintain order of data. This requires more work. Examples -------- >>> df = pl.DataFrame({"a": [1, 1, 2]}) >>> df.select(pl.col("a").unique()) # doctest: +IGNORE_RESULT shape: (2, 1) ┌─────┠│ a │ │ --- │ │ i64 │ â•žâ•â•â•â•â•â•¡ │ 2 │ │ 1 │ └─────┘ >>> df.select(pl.col("a").unique(maintain_order=True)) shape: (2, 1) ┌─────┠│ a │ │ --- │ │ i64 │ â•žâ•â•â•â•â•â•¡ │ 1 │ │ 2 │ └─────┘ )r$rdÚ unique_stableÚunique)r}rs ruruÚ Expr.unique- s8€öB ܘTŸ\™\×7Ñ7Ó9Ó:Ð :ܘŸ™×,Ñ,Ó.Ó/Ð/rxcóH•[URR55$)uô Get the first value. Examples -------- >>> df = pl.DataFrame({"a": [1, 1, 2]}) >>> df.select(pl.col("a").first()) shape: (1, 1) ┌─────┠│ a │ │ --- │ │ i64 │ â•žâ•â•â•â•â•â•¡ │ 1 │ └─────┘ )r$rdÚfirstr|s rurxÚ Expr.firstR s€ô"˜Ÿ™×+Ñ+Ó-Ó.Ð.rxcóH•[URR55$)uò Get the last value. Examples -------- >>> df = pl.DataFrame({"a": [1, 3, 2]}) >>> df.select(pl.col("a").last()) shape: (1, 1) ┌─────┠│ a │ │ --- │ │ i64 │ â•žâ•â•â•â•â•â•¡ │ 2 │ └─────┘ )r$rdÚlastr|s rur{Ú Expr.laste r]rxÚ group_to_rows)Úorder_byrÝrÞÚmapping_strategyc ó”•Ub [U/UQ76nOSnUb [U5nOSn[URRUUUSUS95$)uª Compute expressions over the given groups. This expression is similar to performing a group by aggregation and joining the result back into the original DataFrame. The outcome is similar to how `window functions `_ work in PostgreSQL. Parameters ---------- partition_by Column(s) to group by. Accepts expression input. Strings are parsed as column names. *more_exprs Additional columns to group by, specified as positional arguments. order_by Order the window functions/aggregations with the partitioned groups by the result of the expression passed to `order_by`. descending In case 'order_by' is given, indicate whether to order in ascending or descending order. nulls_last In case 'order_by' is given, indicate whether to order the nulls in last position. mapping_strategy: {'group_to_rows', 'join', 'explode'} - group_to_rows If the aggregation results in multiple values, assign them back to their position in the DataFrame. This can only be done if the group yields the same elements before aggregation as after. - join Join the groups as 'List' to the row positions. warning: this can be memory intensive. - explode Explodes the grouped data into new rows, similar to the results of `group_by` + `agg` + `explode`. Sorting of the given groups is required if the groups are not part of the window operation for the operation, otherwise the result would not make sense. This operation changes the number of rows. Examples -------- Pass the name of a column to compute the expression over that column. >>> df = pl.DataFrame( ... { ... "a": ["a", "a", "b", "b", "b"], ... "b": [1, 2, 3, 5, 3], ... "c": [5, 4, 3, 2, 1], ... } ... ) >>> df.with_columns(c_max=pl.col("c").max().over("a")) shape: (5, 4) ┌─────┬─────┬─────┬───────┠│ a ┆ b ┆ c ┆ c_max │ │ --- ┆ --- ┆ --- ┆ --- │ │ str ┆ i64 ┆ i64 ┆ i64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•¡ │ a ┆ 1 ┆ 5 ┆ 5 │ │ a ┆ 2 ┆ 4 ┆ 5 │ │ b ┆ 3 ┆ 3 ┆ 3 │ │ b ┆ 5 ┆ 2 ┆ 3 │ │ b ┆ 3 ┆ 1 ┆ 3 │ └─────┴─────┴─────┴───────┘ Expression input is also supported. >>> df.with_columns(c_max=pl.col("c").max().over(pl.col("b") // 2)) shape: (5, 4) ┌─────┬─────┬─────┬───────┠│ a ┆ b ┆ c ┆ c_max │ │ --- ┆ --- ┆ --- ┆ --- │ │ str ┆ i64 ┆ i64 ┆ i64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•¡ │ a ┆ 1 ┆ 5 ┆ 5 │ │ a ┆ 2 ┆ 4 ┆ 4 │ │ b ┆ 3 ┆ 3 ┆ 4 │ │ b ┆ 5 ┆ 2 ┆ 2 │ │ b ┆ 3 ┆ 1 ┆ 4 │ └─────┴─────┴─────┴───────┘ Group by multiple columns by passing multiple column names or expressions. >>> df.with_columns(c_min=pl.col("c").min().over("a", pl.col("b") % 2)) shape: (5, 4) ┌─────┬─────┬─────┬───────┠│ a ┆ b ┆ c ┆ c_min │ │ --- ┆ --- ┆ --- ┆ --- │ │ str ┆ i64 ┆ i64 ┆ i64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•¡ │ a ┆ 1 ┆ 5 ┆ 5 │ │ a ┆ 2 ┆ 4 ┆ 4 │ │ b ┆ 3 ┆ 3 ┆ 1 │ │ b ┆ 5 ┆ 2 ┆ 1 │ │ b ┆ 3 ┆ 1 ┆ 1 │ └─────┴─────┴─────┴───────┘ You can use non-elementwise expressions with `over` too. By default they are evaluated using row-order, but you can specify a different one using `order_by`. >>> from datetime import date >>> df = pl.DataFrame( ... { ... "store_id": ["a", "a", "b", "b"], ... "date": [ ... date(2024, 9, 18), ... date(2024, 9, 17), ... date(2024, 9, 18), ... date(2024, 9, 16), ... ], ... "sales": [7, 9, 8, 10], ... } ... ) >>> df.with_columns( ... cumulative_sales=pl.col("sales") ... .cum_sum() ... .over("store_id", order_by="date") ... ) shape: (4, 4) ┌──────────┬────────────┬───────┬──────────────────┠│ store_id ┆ date ┆ sales ┆ cumulative_sales │ │ --- ┆ --- ┆ --- ┆ --- │ │ str ┆ date ┆ i64 ┆ i64 │ â•žâ•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ a ┆ 2024-09-18 ┆ 7 ┆ 16 │ │ a ┆ 2024-09-17 ┆ 9 ┆ 9 │ │ b ┆ 2024-09-18 ┆ 8 ┆ 18 │ │ b ┆ 2024-09-16 ┆ 10 ┆ 10 │ └──────────┴────────────┴───────┴──────────────────┘ If you don't require that the group order be preserved, then the more performant option is to use `mapping_strategy='explode'` - be careful however to only ever use this in a `select` statement, not a `with_columns` one. >>> window = { ... "partition_by": "store_id", ... "order_by": "date", ... "mapping_strategy": "explode", ... } >>> df.select( ... pl.all().over(**window), ... cumulative_sales=pl.col("sales").cum_sum().over(**window), ... ) shape: (4, 4) ┌──────────┬────────────┬───────┬──────────────────┠│ store_id ┆ date ┆ sales ┆ cumulative_sales │ │ --- ┆ --- ┆ --- ┆ --- │ │ str ┆ date ┆ i64 ┆ i64 │ â•žâ•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ a ┆ 2024-09-17 ┆ 9 ┆ 9 │ │ a ┆ 2024-09-18 ┆ 7 ┆ 16 │ │ b ┆ 2024-09-16 ┆ 10 ┆ 10 │ │ b ┆ 2024-09-18 ┆ 8 ┆ 18 │ └──────────┴────────────┴───────┴──────────────────┘ NF)r~Úorder_by_descendingÚorder_by_nulls_lastr)rr$rdÚover) r}Ú partition_byr~rÝrÞrÚ more_exprsÚpartition_by_pyexprsÚorder_by_pyexprss rurƒÚ Expr.overx ss€ðJ Ñ #Ü#AØð$Ø)ò$Ñ ð$(Ð à Ñ Ü=¸hÓGÑ à#Ð äØ L‰L× Ñ Ø$Ø)Ø$.Ø$)Ø!1ð ð ó ð rxÚright)rŸÚclosedcó¦•Uc[[U55n[U5n[U5n[URR XX455$)ut Create rolling groups based on a temporal or integer column. If you have a time series ``, then by default the windows created will be * (t_0 - period, t_0] * (t_1 - period, t_1] * ... * (t_n - period, t_n] whereas if you pass a non-default `offset`, then the windows will be * (t_0 + offset, t_0 + offset + period] * (t_1 + offset, t_1 + offset + period] * ... * (t_n + offset, t_n + offset + period] The `period` and `offset` arguments are created either from a timedelta, or by using the following string language: - 1ns (1 nanosecond) - 1us (1 microsecond) - 1ms (1 millisecond) - 1s (1 second) - 1m (1 minute) - 1h (1 hour) - 1d (1 calendar day) - 1w (1 calendar week) - 1mo (1 calendar month) - 1q (1 calendar quarter) - 1y (1 calendar year) - 1i (1 index count) Or combine them: "3d12h4m25s" # 3 days, 12 hours, 4 minutes, and 25 seconds By "calendar day", we mean the corresponding time on the next day (which may not be 24 hours, due to daylight savings). Similarly for "calendar week", "calendar month", "calendar quarter", and "calendar year". Parameters ---------- index_column Column used to group based on the time window. Often of type Date/Datetime. This column must be sorted in ascending order. In case of a rolling group by on indices, dtype needs to be one of {UInt32, UInt64, Int32, Int64}. Note that the first three get temporarily cast to Int64, so if performance matters use an Int64 column. period Length of the window - must be non-negative. offset Offset of the window. Default is `-period`. closed : {'right', 'left', 'both', 'none'} Define which sides of the temporal interval are closed (inclusive). Examples -------- >>> dates = [ ... "2020-01-01 13:45:48", ... "2020-01-01 16:42:13", ... "2020-01-01 16:45:09", ... "2020-01-02 18:12:48", ... "2020-01-03 19:45:32", ... "2020-01-08 23:16:43", ... ] >>> df = pl.DataFrame({"dt": dates, "a": [3, 7, 5, 9, 2, 1]}).with_columns( ... pl.col("dt").str.strptime(pl.Datetime).set_sorted() ... ) >>> df.with_columns( ... sum_a=pl.sum("a").rolling(index_column="dt", period="2d"), ... min_a=pl.min("a").rolling(index_column="dt", period="2d"), ... max_a=pl.max("a").rolling(index_column="dt", period="2d"), ... ) shape: (6, 5) ┌─────────────────────┬─────┬───────┬───────┬───────┠│ dt ┆ a ┆ sum_a ┆ min_a ┆ max_a │ │ --- ┆ --- ┆ --- ┆ --- ┆ --- │ │ datetime[μs] ┆ i64 ┆ i64 ┆ i64 ┆ i64 │ â•žâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•¡ │ 2020-01-01 13:45:48 ┆ 3 ┆ 3 ┆ 3 ┆ 3 │ │ 2020-01-01 16:42:13 ┆ 7 ┆ 10 ┆ 3 ┆ 7 │ │ 2020-01-01 16:45:09 ┆ 5 ┆ 15 ┆ 3 ┆ 7 │ │ 2020-01-02 18:12:48 ┆ 9 ┆ 24 ┆ 3 ┆ 9 │ │ 2020-01-03 19:45:32 ┆ 2 ┆ 11 ┆ 2 ┆ 9 │ │ 2020-01-08 23:16:43 ┆ 1 ┆ 1 ┆ 1 ┆ 1 │ └─────────────────────┴─────┴───────┴───────┴───────┘ )rrr$rdÚrolling)r}Ú index_columnÚperiodrŸrŠs rurŒÚ Expr.rolling3sJ€ðB ‰>Ü+Ô,DÀVÓ,LÓMˆFä)¨&Ó1ˆÜ)¨&Ó1ˆä˜Ÿ™×-Ñ-¨lÀFÓSÓTÐTrxcóH•[URR55$)u4 Get mask of unique values. Examples -------- >>> df = pl.DataFrame({"a": [1, 1, 2]}) >>> df.select(pl.col("a").is_unique()) shape: (3, 1) ┌───────┠│ a │ │ --- │ │ bool │ â•žâ•â•â•â•â•â•â•â•¡ │ false │ │ false │ │ true │ └───────┘ )r$rdÚ is_uniquer|s rur‘ÚExpr.is_uniqueœs€ô&˜Ÿ™×/Ñ/Ó1Ó2Ð2rxcóH•[URR55$)u` Return a boolean mask indicating the first occurrence of each distinct value. Returns ------- Expr Expression of data type :class:`Boolean`. Examples -------- >>> df = pl.DataFrame({"a": [1, 1, 2, 3, 2]}) >>> df.with_columns(pl.col("a").is_first_distinct().alias("first")) shape: (5, 2) ┌─────┬───────┠│ a ┆ first │ │ --- ┆ --- │ │ i64 ┆ bool │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•¡ │ 1 ┆ true │ │ 1 ┆ false │ │ 2 ┆ true │ │ 3 ┆ true │ │ 2 ┆ false │ └─────┴───────┘ )r$rdÚis_first_distinctr|s rur”ÚExpr.is_first_distinct±s€ô4˜Ÿ™×7Ñ7Ó9Ó:Ð:rxcóH•[URR55$)u] Return a boolean mask indicating the last occurrence of each distinct value. Returns ------- Expr Expression of data type :class:`Boolean`. Examples -------- >>> df = pl.DataFrame({"a": [1, 1, 2, 3, 2]}) >>> df.with_columns(pl.col("a").is_last_distinct().alias("last")) shape: (5, 2) ┌─────┬───────┠│ a ┆ last │ │ --- ┆ --- │ │ i64 ┆ bool │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•¡ │ 1 ┆ false │ │ 1 ┆ true │ │ 2 ┆ false │ │ 3 ┆ true │ │ 2 ┆ true │ └─────┴───────┘ )r$rdÚis_last_distinctr|s rur—ÚExpr.is_last_distinctÍs€ô4˜Ÿ™×6Ñ6Ó8Ó9Ð9rxcóH•[URR55$)u• Return a boolean mask indicating duplicated values. Returns ------- Expr Expression of data type :class:`Boolean`. Examples -------- >>> df = pl.DataFrame({"a": [1, 1, 2]}) >>> df.select(pl.col("a").is_duplicated()) shape: (3, 1) ┌───────┠│ a │ │ --- │ │ bool │ â•žâ•â•â•â•â•â•â•â•¡ │ true │ │ true │ │ false │ └───────┘ )r$rdÚ is_duplicatedr|s ruršÚExpr.is_duplicatedés€ô0˜Ÿ™×3Ñ3Ó5Ó6Ð6rxcóH•[URR55$)ui Get a boolean mask of the local maximum peaks. Examples -------- >>> df = pl.DataFrame({"a": [1, 2, 3, 4, 5]}) >>> df.select(pl.col("a").peak_max()) shape: (5, 1) ┌───────┠│ a │ │ --- │ │ bool │ â•žâ•â•â•â•â•â•â•â•¡ │ false │ │ false │ │ false │ │ false │ │ true │ └───────┘ )r$rdÚpeak_maxr|s rurÚ Expr.peak_maxó€ô*˜Ÿ™×.Ñ.Ó0Ó1Ð1rxcóH•[URR55$)ui Get a boolean mask of the local minimum peaks. Examples -------- >>> df = pl.DataFrame({"a": [4, 1, 3, 2, 5]}) >>> df.select(pl.col("a").peak_min()) shape: (5, 1) ┌───────┠│ a │ │ --- │ │ bool │ â•žâ•â•â•â•â•â•â•â•¡ │ false │ │ true │ │ false │ │ true │ │ false │ └───────┘ )r$rdÚpeak_minr|s rur¡Ú Expr.peak_minrŸrxÚnearestcó`•[U5n[URRX255$)u¸ Get quantile value. Parameters ---------- quantile Quantile between 0.0 and 1.0. interpolation : {'nearest', 'higher', 'lower', 'midpoint', 'linear', 'equiprobable'} Interpolation method. Examples -------- >>> df = pl.DataFrame({"a": [0, 1, 2, 3, 4, 5]}) >>> df.select(pl.col("a").quantile(0.3)) shape: (1, 1) ┌─────┠│ a │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•¡ │ 2.0 │ └─────┘ >>> df.select(pl.col("a").quantile(0.3, interpolation="higher")) shape: (1, 1) ┌─────┠│ a │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•¡ │ 2.0 │ └─────┘ >>> df.select(pl.col("a").quantile(0.3, interpolation="lower")) shape: (1, 1) ┌─────┠│ a │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•¡ │ 1.0 │ └─────┘ >>> df.select(pl.col("a").quantile(0.3, interpolation="midpoint")) shape: (1, 1) ┌─────┠│ a │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•¡ │ 1.5 │ └─────┘ >>> df.select(pl.col("a").quantile(0.3, interpolation="linear")) shape: (1, 1) ┌─────┠│ a │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•¡ │ 1.5 │ └─────┘ )rr$rdÚquantile)r}r¥Ú interpolationÚquantile_pyexprs rur¥Ú Expr.quantile1s)€ô@0°Ó9ˆÜ˜Ÿ™×.Ñ.¨ÓNÓOÐOrx)ÚlabelsÚ left_closedÚinclude_breakscóL•[URRXX455$)ul Bin continuous values into discrete categories. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. Parameters ---------- breaks List of unique cut points. labels Names of the categories. The number of labels must be equal to the number of cut points plus one. left_closed Set the intervals to be left-closed instead of right-closed. include_breaks Include a column with the right endpoint of the bin each observation falls in. This will change the data type of the output from a :class:`Categorical` to a :class:`Struct`. Returns ------- Expr Expression of data type :class:`Categorical` if `include_breaks` is set to `False` (default), otherwise an expression of data type :class:`Struct`. See Also -------- qcut Examples -------- Divide a column into three categories. >>> df = pl.DataFrame({"foo": [-2, -1, 0, 1, 2]}) >>> df.with_columns( ... pl.col("foo").cut([-1, 1], labels=["a", "b", "c"]).alias("cut") ... ) shape: (5, 2) ┌─────┬─────┠│ foo ┆ cut │ │ --- ┆ --- │ │ i64 ┆ cat │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ -2 ┆ a │ │ -1 ┆ a │ │ 0 ┆ b │ │ 1 ┆ b │ │ 2 ┆ c │ └─────┴─────┘ Add both the category and the breakpoint. >>> df.with_columns( ... pl.col("foo").cut([-1, 1], include_breaks=True).alias("cut") ... ).unnest("cut") shape: (5, 3) ┌─────┬────────────┬────────────┠│ foo ┆ breakpoint ┆ category │ │ --- ┆ --- ┆ --- │ │ i64 ┆ f64 ┆ cat │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ -2 ┆ -1.0 ┆ (-inf, -1] │ │ -1 ┆ -1.0 ┆ (-inf, -1] │ │ 0 ┆ 1.0 ┆ (-1, 1] │ │ 1 ┆ 1.0 ┆ (-1, 1] │ │ 2 ┆ inf ┆ (1, inf] │ └─────┴────────────┴────────────┘ )r$rdÚcut)r}Úbreaksr©rªr«s rur­ÚExpr.cutts!€ô^˜Ÿ™×)Ñ)¨&¸+ÓVÓWÐWrx)r©rªÚallow_duplicatesr«có¸•[U[5(aURRXX4U5nOURR XX4U5n[ U5$)u Bin continuous values into discrete categories based on their quantiles. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. Parameters ---------- quantiles Either a list of quantile probabilities between 0 and 1 or a positive integer determining the number of bins with uniform probability. labels Names of the categories. The number of labels must be equal to the number of categories. left_closed Set the intervals to be left-closed instead of right-closed. allow_duplicates If set to `True`, duplicates in the resulting quantiles are dropped, rather than raising a `DuplicateError`. This can happen even with unique probabilities, depending on the data. include_breaks Include a column with the right endpoint of the bin each observation falls in. This will change the data type of the output from a :class:`Categorical` to a :class:`Struct`. Returns ------- Expr Expression of data type :class:`Categorical` if `include_breaks` is set to `False` (default), otherwise an expression of data type :class:`Struct`. See Also -------- cut Examples -------- Divide a column into three categories according to pre-defined quantile probabilities. >>> df = pl.DataFrame({"foo": [-2, -1, 0, 1, 2]}) >>> df.with_columns( ... pl.col("foo").qcut([0.25, 0.75], labels=["a", "b", "c"]).alias("qcut") ... ) shape: (5, 2) ┌─────┬──────┠│ foo ┆ qcut │ │ --- ┆ --- │ │ i64 ┆ cat │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•¡ │ -2 ┆ a │ │ -1 ┆ a │ │ 0 ┆ b │ │ 1 ┆ b │ │ 2 ┆ c │ └─────┴──────┘ Divide a column into two categories using uniform quantile probabilities. >>> df.with_columns( ... pl.col("foo") ... .qcut(2, labels=["low", "high"], left_closed=True) ... .alias("qcut") ... ) shape: (5, 2) ┌─────┬──────┠│ foo ┆ qcut │ │ --- ┆ --- │ │ i64 ┆ cat │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•¡ │ -2 ┆ low │ │ -1 ┆ low │ │ 0 ┆ high │ │ 1 ┆ high │ │ 2 ┆ high │ └─────┴──────┘ Add both the category and the breakpoint. >>> df.with_columns( ... pl.col("foo").qcut([0.25, 0.75], include_breaks=True).alias("qcut") ... ).unnest("qcut") shape: (5, 3) ┌─────┬────────────┬────────────┠│ foo ┆ breakpoint ┆ category │ │ --- ┆ --- ┆ --- │ │ i64 ┆ f64 ┆ cat │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ -2 ┆ -1.0 ┆ (-inf, -1] │ │ -1 ┆ -1.0 ┆ (-inf, -1] │ │ 0 ┆ 1.0 ┆ (-1, 1] │ │ 1 ┆ 1.0 ┆ (-1, 1] │ │ 2 ┆ inf ┆ (1, inf] │ └─────┴────────────┴────────────┘ )r!ÚintrdÚ qcut_uniformÚqcutr$)r}Ú quantilesr©rªr°r«rss rur´Ú Expr.qcutÅsW€ôT i¤× %Ñ %Ø—\‘\×.Ñ.Ø ;À.ó‰Fð—\‘\×&Ñ&Ø ;À.óˆFô˜Ó Ð rxcóH•[URR55$)u) Compress the column data using run-length encoding. Run-length encoding (RLE) encodes data by storing each *run* of identical values as a single value and its length. Returns ------- Expr Expression of data type `Struct` with fields `len` of data type `UInt32` and `value` of the original data type. See Also -------- rle_id Examples -------- >>> df = pl.DataFrame({"a": [1, 1, 2, 1, None, 1, 3, 3]}) >>> df.select(pl.col("a").rle()).unnest("a") shape: (6, 2) ┌─────┬───────┠│ len ┆ value │ │ --- ┆ --- │ │ u32 ┆ i64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•¡ │ 2 ┆ 1 │ │ 1 ┆ 2 │ │ 1 ┆ 1 │ │ 1 ┆ null │ │ 1 ┆ 1 │ │ 2 ┆ 3 │ └─────┴───────┘ )r$rdÚrler|s rur¸ÚExpr.rle:s€ôF˜Ÿ™×)Ñ)Ó+Ó,Ð,rxcóH•[URR55$)us Get a distinct integer ID for each run of identical values. The ID starts at 0 and increases by one each time the value of the column changes. Returns ------- Expr Expression of data type `UInt32`. See Also -------- rle Notes ----- This functionality is especially useful for defining a new group for every time a column's value changes, rather than for every distinct value of that column. Examples -------- >>> df = pl.DataFrame( ... { ... "a": [1, 2, 1, 1, 1], ... "b": ["x", "x", None, "y", "y"], ... } ... ) >>> df.with_columns( ... rle_id_a=pl.col("a").rle_id(), ... rle_id_ab=pl.struct("a", "b").rle_id(), ... ) shape: (5, 4) ┌─────┬──────┬──────────┬───────────┠│ a ┆ b ┆ rle_id_a ┆ rle_id_ab │ │ --- ┆ --- ┆ --- ┆ --- │ │ i64 ┆ str ┆ u32 ┆ u32 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1 ┆ x ┆ 0 ┆ 0 │ │ 2 ┆ x ┆ 1 ┆ 1 │ │ 1 ┆ null ┆ 2 ┆ 2 │ │ 1 ┆ y ┆ 2 ┆ 3 │ │ 1 ┆ y ┆ 2 ┆ 3 │ └─────┴──────┴──────────┴───────────┘ )r$rdÚrle_idr|s rur»Ú Expr.rle_id_s€ô\˜Ÿ™×,Ñ,Ó.Ó/Ð/rxcó`•[U0UD6n[URRU55$)u• Filter the expression based on one or more predicate expressions. The original order of the remaining elements is preserved. Elements where the filter does not evaluate to True are discarded, including nulls. Mostly useful in an aggregation context. If you want to filter on a DataFrame level, use `LazyFrame.filter`. Parameters ---------- predicates Expression(s) that evaluates to a boolean Series. constraints Column filters; use `name = value` to filter columns by the supplied value. Each constraint will behave the same as `pl.col(name).eq(value)`, and be implicitly joined with the other filter conditions using `&`. Examples -------- >>> df = pl.DataFrame( ... { ... "group_col": ["g1", "g1", "g2"], ... "b": [1, 2, 3], ... } ... ) >>> df.group_by("group_col").agg( ... lt=pl.col("b").filter(pl.col("b") < 2).sum(), ... gte=pl.col("b").filter(pl.col("b") >= 2).sum(), ... ).sort("group_col") shape: (2, 3) ┌───────────┬─────┬─────┠│ group_col ┆ lt ┆ gte │ │ --- ┆ --- ┆ --- │ │ str ┆ i64 ┆ i64 │ â•žâ•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ g1 ┆ 1 ┆ 2 │ │ g2 ┆ 0 ┆ 3 │ └───────────┴─────┴─────┘ Filter expressions can also take constraints as keyword arguments. >>> df = pl.DataFrame( ... { ... "key": ["a", "a", "a", "a", "b", "b", "b", "b", "b"], ... "n": [1, 2, 2, 3, 1, 3, 3, 2, 3], ... }, ... ) >>> df.group_by("key").agg( ... n_1=pl.col("n").filter(n=1).sum(), ... n_2=pl.col("n").filter(n=2).sum(), ... n_3=pl.col("n").filter(n=3).sum(), ... ).sort(by="key") shape: (2, 4) ┌─────┬─────┬─────┬─────┠│ key ┆ n_1 ┆ n_2 ┆ n_3 │ │ --- ┆ --- ┆ --- ┆ --- │ │ str ┆ i64 ┆ i64 ┆ i64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ a ┆ 1 ┆ 4 ┆ 3 │ │ b ┆ 1 ┆ 2 ┆ 9 │ └─────┴─────┴─────┴─────┘ )rr$rdÚfilter)r}Ú predicatesÚ constraintsÚ predicates rur¾Ú Expr.filters7€ôLAØ ð Ø&ñ ˆ ô˜Ÿ™×,Ñ,¨YÓ7Ó8Ð8rxz,`where` is deprecated; use `filter` instead.có$•URU5$)u¿ Filter a single column. .. deprecated:: 0.20.4 Use the :func:`filter` method instead. Alias for :func:`filter`. Parameters ---------- predicate Boolean expression. Examples -------- >>> df = pl.DataFrame( ... { ... "group_col": ["g1", "g1", "g2"], ... "b": [1, 2, 3], ... } ... ) >>> df.group_by("group_col").agg( # doctest: +SKIP ... [ ... pl.col("b").where(pl.col("b") < 2).sum().alias("lt"), ... pl.col("b").where(pl.col("b") >= 2).sum().alias("gte"), ... ] ... ).sort("group_col") shape: (2, 3) ┌───────────┬─────┬─────┠│ group_col ┆ lt ┆ gte │ │ --- ┆ --- ┆ --- │ │ str ┆ i64 ┆ i64 │ â•žâ•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ g1 ┆ 1 ┆ 2 │ │ g2 ┆ 0 ┆ 3 │ └───────────┴─────┴─────┘ )r¾)r}rÁs ruÚwhereÚ Expr.whereÚs€ðN{‰{˜9Ó%Ð%rx)Úagg_listrÚreturns_scalarcóv^•U(aSUS3n[U5eSU4Sjjn[R"U/UUUUS9$)u( Apply a custom python function to a whole Series or sequence of Series. The output of this custom function is presumed to be either a Series, or a NumPy array (in which case it will be automatically converted into a Series), or a scalar that will be converted into a Series. If the result is a scalar and you want it to stay as a scalar, pass in ``returns_scalar=True``. If you want to apply a custom function elementwise over single values, see :func:`map_elements`. A reasonable use case for `map` functions is transforming the values represented by an expression using a third-party library. Parameters ---------- function Lambda/function to apply. return_dtype Datatype of the output Series. It is recommended to set this whenever possible. If this is `None`, it tries to infer the datatype by calling the function with dummy data and looking at the output. agg_list First implode when in a group-by aggregation. .. deprecated:: 1.32.0 Use `expr.implode().map_batches(..)` instead. is_elementwise Set to true if the operations is elementwise for better performance and optimization. An elementwise operations has unit or equal length for all inputs and can be ran sequentially on slices without results being affected. returns_scalar If the function returns a scalar, by default it will be wrapped in a list in the output, since the assumption is that the function always returns something Series-like. If you want to keep the result as a scalar, set this argument to True. Notes ----- A UDF passed to `map_batches` must be pure, meaning that it cannot modify or depend on state other than its arguments. Polars may call the function with arbitrary input data. See Also -------- map_elements replace Examples -------- >>> df = pl.DataFrame( ... { ... "sine": [0.0, 1.0, 0.0, -1.0], ... "cosine": [1.0, 0.0, -1.0, 0.0], ... } ... ) >>> df.select( ... pl.all().map_batches( ... lambda x: x.to_numpy().argmax(), ... returns_scalar=True, ... ) ... ) shape: (1, 2) ┌──────┬────────┠│ sine ┆ cosine │ │ --- ┆ --- │ │ i64 ┆ i64 │ â•žâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•¡ │ 1 ┆ 0 │ └──────┴────────┘ Here's an example of a function that returns a scalar, where we want it to stay as a scalar: >>> df = pl.DataFrame( ... { ... "a": [0, 1, 0, 1], ... "b": [1, 2, 3, 4], ... } ... ) >>> df.group_by("a").agg( ... pl.col("b").map_batches( ... lambda x: x.max(), returns_scalar=True, return_dtype=pl.self_dtype() ... ) ... ) # doctest: +IGNORE_RESULT shape: (2, 2) ┌─────┬─────┠│ a ┆ b │ │ --- ┆ --- │ │ i64 ┆ i64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ 1 ┆ 4 │ │ 0 ┆ 3 │ └─────┴─────┘ Call a function that takes multiple arguments by creating a `struct` and referencing its fields inside the function call. >>> df = pl.DataFrame( ... { ... "a": [5, 1, 0, 3], ... "b": [4, 2, 3, 4], ... } ... ) >>> df.with_columns( ... a_times_b=pl.struct("a", "b").map_batches( ... lambda x: np.multiply(x.struct.field("a"), x.struct.field("b")), ... return_dtype=pl.Int64, ... ) ... ) shape: (4, 3) ┌─────┬─────┬───────────┠│ a ┆ b ┆ a_times_b │ │ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ i64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•¡ │ 5 ┆ 4 ┆ 20 │ │ 1 ┆ 2 ┆ 2 │ │ 0 ┆ 3 ┆ 0 │ │ 3 ┆ 4 ┆ 12 │ └─────┴─────┴───────────┘ zOusing 'agg_list=True' is deprecated and will be removed in 2.0 Consider using z.implode() insteadcó">•T"US/UQ70UD6$rrî)Úslr,r/r2s €ruÚ_wrapÚExpr.map_batches.._wrapsø€Ù˜B˜q™EÐ3 DÒ3¨FÑ3Ð 3rx)rrÇ)rÊzSequence[pl.Series]r,r r/r r5z pl.Series)ÚDeprecationWarningÚimploderr:)r}r2Ú return_dtyperÆrrÇr’rËs ` rur:ÚExpr.map_batchessSø€öL ðàˆvÐ'ð+ˆCô% SÓ)Ð )÷ 4ô}Š}Ø ˆFØ Ø Ø)Ø)ñ  ð rxÚ thread_local)Ú skip_nullsÚ pass_namer.rÇcóh^^^^ •US:Xa [S5 SSKJn URR 5n[ U5S:”aU"TUSS9 U(a SUU4Sjjm O SUU4Sjjm US :XaUR T S TS S S 9$US:XaSUU 4S jjn UR U S TS S S 9$SU<S3n [U 5e)uÏ Map a custom/user-defined function (UDF) to each element of a column. .. warning:: This method is much slower than the native expressions API. Only use it if you cannot implement your logic otherwise. Suppose that the function is: `x ↦ sqrt(x)`: - For mapping elements of a series, consider: `pl.col("col_name").sqrt()`. - For mapping inner elements of lists, consider: `pl.col("col_name").list.eval(pl.element().sqrt())`. - For mapping elements of struct fields, consider: `pl.col("col_name").struct.field("field_name").sqrt()`. If you want to replace the original column or field, consider :meth:`.with_columns ` and :meth:`.with_fields `. Parameters ---------- function Lambda/function to map. return_dtype Datatype of the output Series. It is recommended to set this whenever possible. If this is `None`, it tries to infer the datatype by calling the function with dummy data and looking at the output. skip_nulls Don't map the function over values that contain nulls (this is faster). pass_name Pass the Series name to the custom function (this is more expensive). returns_scalar .. deprecated:: 1.32.0 Is ignored and will be removed in 2.0. strategy : {'thread_local', 'threading'} The threading strategy to use. - 'thread_local': run the python function on a single thread. - 'threading': run the python function on separate threads. Use with care as this can slow performance. This might only speed up your code if the amount of work per element is significant and the python function releases the GIL (e.g. via calling a c function) .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. Notes ----- * Using `map_elements` is strongly discouraged as you will be effectively running python "for" loops, which will be very slow. Wherever possible you should prefer the native expression API to achieve the best performance. * If your function is expensive and you don't want it to be called more than once for a given input, consider applying an `@lru_cache` decorator to it. If your data is suitable you may achieve *significant* speedups. * Window function application using `over` is considered a GroupBy context here, so `map_elements` can be used to map functions over window groups. * A UDF passed to `map_elements` must be pure, meaning that it cannot modify or depend on state other than its arguments. Polars may call the function with arbitrary input data. Examples -------- >>> df = pl.DataFrame( ... { ... "a": [1, 2, 3, 1], ... "b": ["a", "b", "c", "c"], ... } ... ) The function is applied to each element of column `'a'`: >>> df.with_columns( # doctest: +SKIP ... pl.col("a") ... .map_elements(lambda x: x * 2, return_dtype=pl.self_dtype()) ... .alias("a_times_2"), ... ) shape: (4, 3) ┌─────┬─────┬───────────┠│ a ┆ b ┆ a_times_2 │ │ --- ┆ --- ┆ --- │ │ i64 ┆ str ┆ i64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1 ┆ a ┆ 2 │ │ 2 ┆ b ┆ 4 │ │ 3 ┆ c ┆ 6 │ │ 1 ┆ c ┆ 2 │ └─────┴─────┴───────────┘ Tip: it is better to implement this with an expression: >>> df.with_columns( ... (pl.col("a") * 2).alias("a_times_2"), ... ) # doctest: +IGNORE_RESULT >>> ( ... df.lazy() ... .group_by("b") ... .agg( ... pl.col("a") ... .implode() ... .map_elements(lambda x: x.sum(), return_dtype=pl.Int64) ... ) ... .collect() ... ) # doctest: +IGNORE_RESULT shape: (3, 2) ┌─────┬─────┠│ b ┆ a │ │ --- ┆ --- │ │ str ┆ i64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ a ┆ 1 │ │ b ┆ 2 │ │ c ┆ 4 │ └─────┴─────┘ Tip: again, it is better to implement this with an expression: >>> ( ... df.lazy() ... .group_by("b", maintain_order=True) ... .agg(pl.col("a").sum()) ... .collect() ... ) # doctest: +IGNORE_RESULT Window function application using `over` will behave as a GroupBy context, with your function receiving individual window groups: >>> df = pl.DataFrame( ... { ... "key": ["x", "x", "y", "x", "y", "z"], ... "val": [1, 1, 1, 1, 1, 1], ... } ... ) >>> df.with_columns( ... scaled=pl.col("val") ... .implode() ... .map_elements(lambda s: s * len(s), return_dtype=pl.List(pl.Int64)) ... .explode() ... .over("key"), ... ).sort("key") shape: (6, 3) ┌─────┬─────┬────────┠│ key ┆ val ┆ scaled │ │ --- ┆ --- ┆ --- │ │ str ┆ i64 ┆ i64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•¡ │ x ┆ 1 ┆ 3 │ │ x ┆ 1 ┆ 3 │ │ x ┆ 1 ┆ 3 │ │ y ┆ 1 ┆ 2 │ │ y ┆ 1 ┆ 2 │ │ z ┆ 1 ┆ 1 │ └─────┴─────┴────────┘ Note that this function would *also* be better-implemented natively: >>> df.with_columns( ... scaled=(pl.col("val") * pl.col("val").count()).over("key"), ... ).sort("key") # doctest: +IGNORE_RESULT Ú threadingzCthe 'threading' strategy for `map_elements` is considered unstable.r)Úwarn_on_inefficient_maprt)rzÚ map_targetcóØ>^•USnSUU4Sjjn[R"5 [R"S[5 TR X2TS9sSSS5 $!,(df  g=f)NrÏcóˆ>•[U[R5(aURTR5nT"U5$rp)r!rrGr=rl)r+r2Úxs €€ruÚinnerÚ0Expr.map_elements..wrap_f..inner`s/ø€Ü! !¤R§Y¡Y×/Ñ/ØŸG™G A§F¡F›O˜Ù# A›;Ð&rxÚignore©rÏrÒ)r+z Series | Anyr5rG©r8Úcatch_warningsÚ simplefilterr,Ú map_elements)rÚr/rÏrÛr2rÒs` €€ruÚwrap_fÚ!Expr.map_elements..wrap_f]sXù€Ø% nÑ5 ÷'ð'ô ×,Ò,Õ.Ü×)Ò)¨(Ô4OÔPØŸ>™>ØÀZð*ð÷/×.×.ús ¦+AÁ A)cóÆ>•USn[R"5 [R"S[5 UR TUTS9sSSS5 $!,(df  g=f)NrÏrÝrÞrß)rÚr/rÏr2rÒs €€rurãrämsNø€Ø% nÑ5 Ü×,Ò,Õ.Ü×)Ò)¨(Ô4OÔPàŸ>™>Ø ¨|È ð*ð÷/×.×.ús œ,AÁ A rÑFT)rÆrÏrÇrcó¬>•SUU4SjjnURS5nUR5S:Xa$U"U5R5R5$[ 5nUR5U-nUR5U-nUS:Xa[ U5Vs/sHnSPM nnO%[ U5Vs/sHnX…:aUS-OUPM nn/n Sn UH*n U n X«-n X,U 2SS24n U R U"U 55 M, [R"U 5Vs/sHo"R5PM nn[R"USS9$s snfs snfs snf)Nc óŠ>•UR5R[R"S5R TSTSS95$)NrÚF)rÆrÏrÇ)ÚlazyÚselectrÚcolr:)ÚdfrÏrãs €€ruÚget_lazy_promiseÚCExpr.map_elements..wrap_threading..get_lazy_promisesCø€ØŸ7™7›9×+Ñ+ÜŸš˜c› ×.Ñ.Ø"Ø%*Ø)5Ø+0ð /ðóðrxrÚrrF)r¦)rërEr5rF) Úto_framer†ÚcollectÚ to_seriesr?Úranger*rÚ collect_allÚconcat)rÚrìrëÚ n_threadsÚ chunk_sizeÚ remainderÚ_Ú chunk_sizesr-Ú partitionsÚbÚstepÚaÚ partition_dfÚoutrÏrãs €€ruÚwrap_threadingÚ)Expr.map_elements..wrap_threading€sRø€÷ðð—Z‘Z “_à—5‘5“7˜a“<Ù+¨BÓ/×7Ñ7Ó9×CÑCÓEÐEä,Ó. ØŸU™U›W¨ Ñ1 ØŸE™E›G iÑ/ Ø “?Ü.3°IÔ.>Ó"?Ò.>¨£1Ñ.>KÐ"?Kô"' yÔ!1ó#â!1˜Að+,«-˜  Qš¸ZÒGÙ!1ð ð#ð ØÛ'DØAØ™AØ#%¨ cª1 f¡:LØ×%Ñ%Ñ&6°|Ó&DÖEñ (ô 12· ² ¸jÔ0IÓJÒ0I¨"—|‘|–~Ñ0IÐJÜ—x’x ¨UÑ3Ð3ùò%#@ùò#ùòKs EÂ3E ÄEz strategy z is not supported)rÚrGr/r r5rG)rÚrGr5rG)rÚpolars._utils.udfsrÖrkÚ root_namesr†r:rR) r}r2rÏrÒrÓr.rÇrÖrrÿr’rãs ``` @rurâÚExpr.map_elements›séû€ðh {Ó "Ü "ØUô õ ?à—Y‘Y×)Ñ)Ó+ˆ Ü ˆz‹?˜QÓ Ù # H°jÈVÒ Tæ ÷ ñ ÷  ð ð ~Ó %Ø×#Ñ#ØØØ)Ø$Ø#ð $ðð ð˜Ó $÷& 4ð& 4ðP×#Ñ#ØØØ)Ø$Ø#ð $ðð ð˜h™\Ð):Ð;ˆCܘS“/Ð !rxcóH•[URR55$)u„ Flatten a list or string column. Alias for :func:`Expr.list.explode`. Examples -------- >>> df = pl.DataFrame( ... { ... "group": ["a", "b", "b"], ... "values": [[1, 2], [2, 3], [4]], ... } ... ) >>> df.group_by("group").agg(pl.col("values").flatten()) # doctest: +SKIP shape: (2, 2) ┌───────┬───────────┠│ group ┆ values │ │ --- ┆ --- │ │ str ┆ list[i64] │ â•žâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•¡ │ a ┆ [1, 2] │ │ b ┆ [2, 3, 4] │ └───────┴───────────┘ ©r$rdÚexploder|s ruÚflattenÚ Expr.flatten³r¨rxcóH•[URR55$)u˜ Explode a list expression. This means that every item is expanded to a new row. Returns ------- Expr Expression with the data type of the list elements. See Also -------- Expr.list.explode : Explode a list column. Examples -------- >>> df = pl.DataFrame( ... { ... "group": ["a", "b"], ... "values": [ ... [1, 2], ... [3, 4], ... ], ... } ... ) >>> df.select(pl.col("values").explode()) shape: (4, 1) ┌────────┠│ values │ │ --- │ │ i64 │ â•žâ•â•â•â•â•â•â•â•â•¡ │ 1 │ │ 2 │ │ 3 │ │ 4 │ └────────┘ rr|s rurÚ Expr.explodeÎs€ôN˜Ÿ™×-Ñ-Ó/Ó0Ð0rxcóH•[URR55$)u/ Aggregate values into a list. Examples -------- >>> df = pl.DataFrame( ... { ... "a": [1, 2, 3], ... "b": [4, 5, 6], ... } ... ) >>> df.select(pl.all().implode()) shape: (1, 2) ┌───────────┬───────────┠│ a ┆ b │ │ --- ┆ --- │ │ list[i64] ┆ list[i64] │ â•žâ•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•¡ │ [1, 2, 3] ┆ [4, 5, 6] │ └───────────┴───────────┘ )r$rdrÎr|s rurÎÚ Expr.implode÷ó€ô,˜Ÿ™×-Ñ-Ó/Ó0Ð0rxcóJ•[URRX55$)uu Take every nth value in the Series and return as a new Series. Parameters ---------- n Gather every *n*-th row. offset Starting index. Examples -------- >>> df = pl.DataFrame({"foo": [1, 2, 3, 4, 5, 6, 7, 8, 9]}) >>> df.select(pl.col("foo").gather_every(3)) shape: (3, 1) ┌─────┠│ foo │ │ --- │ │ i64 │ â•žâ•â•â•â•â•â•¡ │ 1 │ │ 4 │ │ 7 │ └─────┘ >>> df.select(pl.col("foo").gather_every(3, offset=1)) shape: (3, 1) ┌─────┠│ foo │ │ --- │ │ i64 │ â•žâ•â•â•â•â•â•¡ │ 2 │ │ 5 │ │ 8 │ └─────┘ )r$rdÚ gather_every©r}r$rŸs rurÚExpr.gather_everys€ôL˜Ÿ™×2Ñ2°1Ó=Ó>Ð>rxcó&•URSU5$)uV Get the first `n` rows. Parameters ---------- n Number of rows to return. Examples -------- >>> df = pl.DataFrame({"foo": [1, 2, 3, 4, 5, 6, 7]}) >>> df.select(pl.col("foo").head(3)) shape: (3, 1) ┌─────┠│ foo │ │ --- │ │ i64 │ â•žâ•â•â•â•â•â•¡ │ 1 │ │ 2 │ │ 3 │ └─────┘ r)rž©r}r$s ruÚheadÚ Expr.head7s€ð0z‰z˜!˜QÓÐrxcót•[[U55R[SSS9*nUR X!5$)uU Get the last `n` rows. Parameters ---------- n Number of rows to return. Examples -------- >>> df = pl.DataFrame({"foo": [1, 2, 3, 4, 5, 6, 7]}) >>> df.select(pl.col("foo").tail(3)) shape: (3, 1) ┌─────┠│ foo │ │ --- │ │ i64 │ â•žâ•â•â•â•â•â•¡ │ 5 │ │ 6 │ │ 7 │ └─────┘ FTrÕ)r$rrÙr&ržrs ruÚtailÚ Expr.tailQsA€ô6 Ô+¨AÓ.Ó /× 4Ñ 4ܘe°Dð 5ð ð ˆð z‰z˜&Ó$Ð$rxcó$•URU5$)uu Get the first `n` rows (alias for :func:`Expr.head`). Parameters ---------- n Number of rows to return. Examples -------- >>> df = pl.DataFrame({"foo": [1, 2, 3, 4, 5, 6, 7]}) >>> df.select(pl.col("foo").limit(3)) shape: (3, 1) ┌─────┠│ foo │ │ --- │ │ i64 │ â•žâ•â•â•â•â•â•¡ │ 1 │ │ 2 │ │ 3 │ └─────┘ )rrs rur/Ú Expr.limitrs€ð0y‰y˜‹|Ðrxcó>•[[RU/UQ75$)u> Method equivalent of bitwise "and" operator `expr & other & ...`. Parameters ---------- *others One or more integer or boolean expressions to evaluate/combine. Examples -------- >>> df = pl.DataFrame( ... data={ ... "x": [5, 6, 7, 4, 8], ... "y": [1.5, 2.5, 1.0, 4.0, -5.75], ... "z": [-9, 2, -1, 4, 8], ... } ... ) >>> df.select( ... (pl.col("x") >= pl.col("z")) ... .and_( ... pl.col("y") >= pl.col("z"), ... pl.col("y") == pl.col("y"), ... pl.col("z") <= pl.col("x"), ... pl.col("y") != pl.col("x"), ... ) ... .alias("all") ... ) shape: (5, 1) ┌───────┠│ all │ │ --- │ │ bool │ â•žâ•â•â•â•â•â•â•â•¡ │ true │ │ true │ │ true │ │ false │ │ false │ └───────┘ )rÚoperatorr§©r}Úotherss rur§Ú Expr.and_Œs€ôR”h—m‘m d _¨V¡_Ó5Ð5rxcó>•[[RU4U-5$)u Method equivalent of bitwise "or" operator `expr | other | ...`. Parameters ---------- *others One or more integer or boolean expressions to evaluate/combine. Examples -------- >>> df = pl.DataFrame( ... data={ ... "x": [5, 6, 7, 4, 8], ... "y": [1.5, 2.5, 1.0, 4.0, -5.75], ... "z": [-9, 2, -1, 4, 8], ... } ... ) >>> df.select( ... (pl.col("x") == pl.col("y")) ... .or_( ... pl.col("x") == pl.col("y"), ... pl.col("y") == pl.col("z"), ... pl.col("y").cast(int) == pl.col("z"), ... ) ... .alias("any") ... ) shape: (5, 1) ┌───────┠│ any │ │ --- │ │ bool │ â•žâ•â•â•â•â•â•â•â•¡ │ false │ │ true │ │ false │ │ true │ │ false │ └───────┘ )rrrçrs rurçÚExpr.or_·s€ôP”h—l‘l T G¨fÑ$4Ó5Ð5rxcó$•URU5$)u2 Method equivalent of equality operator `expr == other`. Parameters ---------- other A literal or expression value to compare with. Examples -------- >>> df = pl.DataFrame( ... data={ ... "x": [1.0, 2.0, float("nan"), 4.0], ... "y": [2.0, 2.0, float("nan"), 4.0], ... } ... ) >>> df.with_columns( ... pl.col("x").eq(pl.col("y")).alias("x == y"), ... ) shape: (4, 3) ┌─────┬─────┬────────┠│ x ┆ y ┆ x == y │ │ --- ┆ --- ┆ --- │ │ f64 ┆ f64 ┆ bool │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•¡ │ 1.0 ┆ 2.0 ┆ false │ │ 2.0 ┆ 2.0 ┆ true │ │ NaN ┆ NaN ┆ true │ │ 4.0 ┆ 4.0 ┆ true │ └─────┴─────┴────────┘ )r³©r}rŸs rur²ÚExpr.eqáó€ð@{‰{˜5Ó!Ð!rxcó^•[USS9n[URRU55$)u‹ Method equivalent of equality operator `expr == other` where `None == None`. This differs from default `eq` where null values are propagated. Parameters ---------- other A literal or expression value to compare with. Examples -------- >>> df = pl.DataFrame( ... data={ ... "x": [1.0, 2.0, float("nan"), 4.0, None, None], ... "y": [2.0, 2.0, float("nan"), 4.0, 5.0, None], ... } ... ) >>> df.with_columns( ... pl.col("x").eq(pl.col("y")).alias("x eq y"), ... pl.col("x").eq_missing(pl.col("y")).alias("x eq_missing y"), ... ) shape: (6, 4) ┌──────┬──────┬────────┬────────────────┠│ x ┆ y ┆ x eq y ┆ x eq_missing y │ │ --- ┆ --- ┆ --- ┆ --- │ │ f64 ┆ f64 ┆ bool ┆ bool │ â•žâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1.0 ┆ 2.0 ┆ false ┆ false │ │ 2.0 ┆ 2.0 ┆ true ┆ true │ │ NaN ┆ NaN ┆ true ┆ true │ │ 4.0 ┆ 4.0 ┆ true ┆ true │ │ null ┆ 5.0 ┆ null ┆ false │ │ null ┆ null ┆ null ┆ true │ └──────┴──────┴────────┴────────────────┘ Tr›)rr$rdÚ eq_missingržs rur'ÚExpr.eq_missings+€ôJ-¨U¸tÑDˆ ܘŸ™×0Ñ0°Ó>Ó?Ð?rxcó$•URU5$)uA Method equivalent of "greater than or equal" operator `expr >= other`. Parameters ---------- other A literal or expression value to compare with. Examples -------- >>> df = pl.DataFrame( ... data={ ... "x": [5.0, 4.0, float("nan"), 2.0], ... "y": [5.0, 3.0, float("nan"), 1.0], ... } ... ) >>> df.with_columns( ... pl.col("x").ge(pl.col("y")).alias("x >= y"), ... ) shape: (4, 3) ┌─────┬─────┬────────┠│ x ┆ y ┆ x >= y │ │ --- ┆ --- ┆ --- │ │ f64 ┆ f64 ┆ bool │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•¡ │ 5.0 ┆ 5.0 ┆ true │ │ 4.0 ┆ 3.0 ┆ true │ │ NaN ┆ NaN ┆ true │ │ 2.0 ┆ 1.0 ┆ true │ └─────┴─────┴────────┘ )r¾r#s ruÚgeÚExpr.ge+r%rxcó$•URU5$)u& Method equivalent of "greater than" operator `expr > other`. Parameters ---------- other A literal or expression value to compare with. Examples -------- >>> df = pl.DataFrame( ... data={ ... "x": [5.0, 4.0, float("nan"), 2.0], ... "y": [5.0, 3.0, float("nan"), 1.0], ... } ... ) >>> df.with_columns( ... pl.col("x").gt(pl.col("y")).alias("x > y"), ... ) shape: (4, 3) ┌─────┬─────┬───────┠│ x ┆ y ┆ x > y │ │ --- ┆ --- ┆ --- │ │ f64 ┆ f64 ┆ bool │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•¡ │ 5.0 ┆ 5.0 ┆ false │ │ 4.0 ┆ 3.0 ┆ true │ │ NaN ┆ NaN ┆ false │ │ 2.0 ┆ 1.0 ┆ true │ └─────┴─────┴───────┘ )rÃr#s rurÂÚExpr.gtMr%rxcó$•URU5$)u> Method equivalent of "less than or equal" operator `expr <= other`. Parameters ---------- other A literal or expression value to compare with. Examples -------- >>> df = pl.DataFrame( ... data={ ... "x": [5.0, 4.0, float("nan"), 0.5], ... "y": [5.0, 3.5, float("nan"), 2.0], ... } ... ) >>> df.with_columns( ... pl.col("x").le(pl.col("y")).alias("x <= y"), ... ) shape: (4, 3) ┌─────┬─────┬────────┠│ x ┆ y ┆ x <= y │ │ --- ┆ --- ┆ --- │ │ f64 ┆ f64 ┆ bool │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•¡ │ 5.0 ┆ 5.0 ┆ true │ │ 4.0 ┆ 3.5 ┆ false │ │ NaN ┆ NaN ┆ true │ │ 0.5 ┆ 2.0 ┆ true │ └─────┴─────┴────────┘ )rËr#s ruÚleÚExpr.leor%rxcó$•URU5$)u# Method equivalent of "less than" operator `expr < other`. Parameters ---------- other A literal or expression value to compare with. Examples -------- >>> df = pl.DataFrame( ... data={ ... "x": [1.0, 2.0, float("nan"), 3.0], ... "y": [2.0, 2.0, float("nan"), 4.0], ... } ... ) >>> df.with_columns( ... pl.col("x").lt(pl.col("y")).alias("x < y"), ... ) shape: (4, 3) ┌─────┬─────┬───────┠│ x ┆ y ┆ x < y │ │ --- ┆ --- ┆ --- │ │ f64 ┆ f64 ┆ bool │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•¡ │ 1.0 ┆ 2.0 ┆ true │ │ 2.0 ┆ 2.0 ┆ false │ │ NaN ┆ NaN ┆ false │ │ 3.0 ┆ 4.0 ┆ true │ └─────┴─────┴───────┘ )rÏr#s rurÎÚExpr.lt‘r%rxcó$•URU5$)u4 Method equivalent of inequality operator `expr != other`. Parameters ---------- other A literal or expression value to compare with. Examples -------- >>> df = pl.DataFrame( ... data={ ... "x": [1.0, 2.0, float("nan"), 4.0], ... "y": [2.0, 2.0, float("nan"), 4.0], ... } ... ) >>> df.with_columns( ... pl.col("x").ne(pl.col("y")).alias("x != y"), ... ) shape: (4, 3) ┌─────┬─────┬────────┠│ x ┆ y ┆ x != y │ │ --- ┆ --- ┆ --- │ │ f64 ┆ f64 ┆ bool │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•¡ │ 1.0 ┆ 2.0 ┆ true │ │ 2.0 ┆ 2.0 ┆ false │ │ NaN ┆ NaN ┆ false │ │ 4.0 ┆ 4.0 ┆ false │ └─────┴─────┴────────┘ )rár#s ruÚneÚExpr.ne³r%rxcó^•[USS9n[URRU55$)u‹ Method equivalent of equality operator `expr != other` where `None == None`. This differs from default `ne` where null values are propagated. Parameters ---------- other A literal or expression value to compare with. Examples -------- >>> df = pl.DataFrame( ... data={ ... "x": [1.0, 2.0, float("nan"), 4.0, None, None], ... "y": [2.0, 2.0, float("nan"), 4.0, 5.0, None], ... } ... ) >>> df.with_columns( ... pl.col("x").ne(pl.col("y")).alias("x ne y"), ... pl.col("x").ne_missing(pl.col("y")).alias("x ne_missing y"), ... ) shape: (6, 4) ┌──────┬──────┬────────┬────────────────┠│ x ┆ y ┆ x ne y ┆ x ne_missing y │ │ --- ┆ --- ┆ --- ┆ --- │ │ f64 ┆ f64 ┆ bool ┆ bool │ â•žâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1.0 ┆ 2.0 ┆ true ┆ true │ │ 2.0 ┆ 2.0 ┆ false ┆ false │ │ NaN ┆ NaN ┆ false ┆ false │ │ 4.0 ┆ 4.0 ┆ false ┆ false │ │ null ┆ 5.0 ┆ null ┆ true │ │ null ┆ null ┆ null ┆ false │ └──────┴──────┴────────┴────────────────┘ Tr›)rr$rdÚ neq_missingržs ruÚ ne_missingÚExpr.ne_missingÕs+€ôJ-¨U¸tÑDˆ ܘŸ™×1Ñ1°,Ó?Ó@Ð@rxcó$•URU5$)uÈ Method equivalent of addition operator `expr + other`. Parameters ---------- other numeric or string value; accepts expression input. Examples -------- >>> df = pl.DataFrame({"x": [1, 2, 3, 4, 5]}) >>> df.with_columns( ... pl.col("x").add(2).alias("x+int"), ... pl.col("x").add(pl.col("x").cum_prod()).alias("x+expr"), ... ) shape: (5, 3) ┌─────┬───────┬────────┠│ x ┆ x+int ┆ x+expr │ │ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ i64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•¡ │ 1 ┆ 3 ┆ 2 │ │ 2 ┆ 4 ┆ 4 │ │ 3 ┆ 5 ┆ 9 │ │ 4 ┆ 6 ┆ 28 │ │ 5 ┆ 7 ┆ 125 │ └─────┴───────┴────────┘ >>> df = pl.DataFrame( ... {"x": ["a", "d", "g"], "y": ["b", "e", "h"], "z": ["c", "f", "i"]} ... ) >>> df.with_columns(pl.col("x").add(pl.col("y")).add(pl.col("z")).alias("xyz")) shape: (3, 4) ┌─────┬─────┬─────┬─────┠│ x ┆ y ┆ z ┆ xyz │ │ --- ┆ --- ┆ --- ┆ --- │ │ str ┆ str ┆ str ┆ str │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ a ┆ b ┆ c ┆ abc │ │ d ┆ e ┆ f ┆ def │ │ g ┆ h ┆ i ┆ ghi │ └─────┴─────┴─────┴─────┘ )r¡r#s ruÚaddÚExpr.addýs€ðX|‰|˜EÓ"Ð"rxcó$•URU5$)u÷ Method equivalent of integer division operator `expr // other`. Parameters ---------- other Numeric literal or expression value. See Also -------- truediv Examples -------- >>> df = pl.DataFrame({"x": [1, 2, 3, 4, 5]}) >>> df.with_columns( ... pl.col("x").truediv(2).alias("x/2"), ... pl.col("x").floordiv(2).alias("x//2"), ... ) shape: (5, 3) ┌─────┬─────┬──────┠│ x ┆ x/2 ┆ x//2 │ │ --- ┆ --- ┆ --- │ │ i64 ┆ f64 ┆ i64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•¡ │ 1 ┆ 0.5 ┆ 0 │ │ 2 ┆ 1.0 ┆ 1 │ │ 3 ┆ 1.5 ┆ 1 │ │ 4 ┆ 2.0 ┆ 2 │ │ 5 ┆ 2.5 ┆ 2 │ └─────┴─────┴──────┘ Note that Polars' `floordiv` is subtly different from Python's floor division. For example, consider 6.0 floor-divided by 0.1. Python gives: >>> 6.0 // 0.1 59.0 because `0.1` is not represented internally as that exact value, but a slightly larger value. So the result of the division is slightly less than 60, meaning the flooring operation returns 59.0. Polars instead first does the floating-point division, resulting in a floating-point value of 60.0, and then performs the flooring operation using :any:`floor`: >>> df = pl.DataFrame({"x": [6.0, 6.03]}) >>> df.with_columns( ... pl.col("x").truediv(0.1).alias("x/0.1"), ... ).with_columns( ... pl.col("x/0.1").floor().alias("x/0.1 floor"), ... ) shape: (2, 3) ┌──────┬───────┬─────────────┠│ x ┆ x/0.1 ┆ x/0.1 floor │ │ --- ┆ --- ┆ --- │ │ f64 ┆ f64 ┆ f64 │ â•žâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 6.0 ┆ 60.0 ┆ 60.0 │ │ 6.03 ┆ 60.3 ┆ 60.0 │ └──────┴───────┴─────────────┘ yielding the more intuitive result 60.0. The row with x = 6.03 is included to demonstrate the effect of the flooring operation. `floordiv` combines those two steps to give the same result with one expression: >>> df.with_columns( ... pl.col("x").floordiv(0.1).alias("x//0.1"), ... ) shape: (2, 2) ┌──────┬────────┠│ x ┆ x//0.1 │ │ --- ┆ --- │ │ f64 ┆ f64 │ â•žâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•¡ │ 6.0 ┆ 60.0 │ │ 6.03 ┆ 60.0 │ └──────┴────────┘ )r·r#s ruÚfloordivÚ Expr.floordiv+s€ðj× Ñ  Ó'Ð'rxcó$•URU5$)u Method equivalent of modulus operator `expr % other`. Parameters ---------- other Numeric literal or expression value. Examples -------- >>> df = pl.DataFrame({"x": [0, 1, 2, 3, 4]}) >>> df.with_columns(pl.col("x").mod(2).alias("x%2")) shape: (5, 2) ┌─────┬─────┠│ x ┆ x%2 │ │ --- ┆ --- │ │ i64 ┆ i64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ 0 ┆ 0 │ │ 1 ┆ 1 │ │ 2 ┆ 0 │ │ 3 ┆ 1 │ │ 4 ┆ 0 │ └─────┴─────┘ )rÒr#s ruÚmodÚExpr.mod‚s€ð4|‰|˜EÓ"Ð"rxcó$•URU5$)uL Method equivalent of multiplication operator `expr * other`. Parameters ---------- other Numeric literal or expression value. Examples -------- >>> df = pl.DataFrame({"x": [1, 2, 4, 8, 16]}) >>> df.with_columns( ... pl.col("x").mul(2).alias("x*2"), ... pl.col("x").mul(pl.col("x").log(2)).alias("x * xlog2"), ... ) shape: (5, 3) ┌─────┬─────┬───────────┠│ x ┆ x*2 ┆ x * xlog2 │ │ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1 ┆ 2 ┆ 0.0 │ │ 2 ┆ 4 ┆ 2.0 │ │ 4 ┆ 8 ┆ 8.0 │ │ 8 ┆ 16 ┆ 24.0 │ │ 16 ┆ 32 ┆ 64.0 │ └─────┴─────┴───────────┘ )rÚr#s ruÚmulÚExpr.mulžó€ð:|‰|˜EÓ"Ð"rxcó$•URU5$)u Method equivalent of subtraction operator `expr - other`. Parameters ---------- other Numeric literal or expression value. Examples -------- >>> df = pl.DataFrame({"x": [0, 1, 2, 3, 4]}) >>> df.with_columns( ... pl.col("x").sub(2).alias("x-2"), ... pl.col("x").sub(pl.col("x").cum_sum()).alias("x-expr"), ... ) shape: (5, 3) ┌─────┬─────┬────────┠│ x ┆ x-2 ┆ x-expr │ │ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ i64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•¡ │ 0 ┆ -2 ┆ 0 │ │ 1 ┆ -1 ┆ 0 │ │ 2 ┆ 0 ┆ -1 │ │ 3 ┆ 1 ┆ -3 │ │ 4 ┆ 2 ┆ -6 │ └─────┴─────┴────────┘ )rþr#s ruÚsubÚExpr.sub½rFrxcó"•UR5$)uQ Method equivalent of unary minus operator `-expr`. Examples -------- >>> df = pl.DataFrame({"a": [-1, 0, 2, None]}) >>> df.with_columns(pl.col("a").neg()) shape: (4, 1) ┌──────┠│ a │ │ --- │ │ i64 │ â•žâ•â•â•â•â•â•â•¡ │ 1 │ │ 0 │ │ -2 │ │ null │ └──────┘ )rär|s ruÚnegÚExpr.negÜs€ð(|‰|‹~Ðrxcó$•URU5$)u­ Method equivalent of float division operator `expr / other`. Parameters ---------- other Numeric literal or expression value. Notes ----- Zero-division behaviour follows IEEE-754: 0/0: Invalid operation - mathematically undefined, returns NaN. n/0: On finite operands gives an exact infinite result, eg: ±infinity. See Also -------- floordiv Examples -------- >>> df = pl.DataFrame( ... data={"x": [-2, -1, 0, 1, 2], "y": [0.5, 0.0, 0.0, -4.0, -0.5]} ... ) >>> df.with_columns( ... pl.col("x").truediv(2).alias("x/2"), ... pl.col("x").truediv(pl.col("y")).alias("x/y"), ... ) shape: (5, 4) ┌─────┬──────┬──────┬───────┠│ x ┆ y ┆ x/2 ┆ x/y │ │ --- ┆ --- ┆ --- ┆ --- │ │ i64 ┆ f64 ┆ f64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•¡ │ -2 ┆ 0.5 ┆ -1.0 ┆ -4.0 │ │ -1 ┆ 0.0 ┆ -0.5 ┆ -inf │ │ 0 ┆ 0.0 ┆ 0.0 ┆ NaN │ │ 1 ┆ -4.0 ┆ 0.5 ┆ -0.25 │ │ 2 ┆ -0.5 ┆ 1.0 ┆ -4.0 │ └─────┴──────┴──────┴───────┘ )rr#s ruÚtruedivÚ Expr.truedivòs€ðT×Ñ Ó&Ð&rxcó$•URU5$)u Method equivalent of exponentiation operator `expr ** exponent`. If the exponent is float, the result follows the dtype of exponent. Otherwise, it follows dtype of base. Parameters ---------- exponent Numeric literal or expression exponent value. Examples -------- >>> df = pl.DataFrame({"x": [1, 2, 4, 8]}) >>> df.with_columns( ... pl.col("x").pow(3).alias("cube"), ... pl.col("x").pow(pl.col("x").log(2)).alias("x ** xlog2"), ... ) shape: (4, 3) ┌─────┬──────┬────────────┠│ x ┆ cube ┆ x ** xlog2 │ │ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1 ┆ 1 ┆ 1.0 │ │ 2 ┆ 8 ┆ 2.0 │ │ 4 ┆ 64 ┆ 16.0 │ │ 8 ┆ 512 ┆ 512.0 │ └─────┴──────┴────────────┘ Raising an integer to a positive integer results in an integer - in order to raise to a negative integer, you can cast either the base or the exponent to float first: >>> df.with_columns( ... x_squared=pl.col("x").pow(2), ... x_inverse=pl.col("x").pow(-1.0), ... ) shape: (4, 3) ┌─────┬───────────┬───────────┠│ x ┆ x_squared ┆ x_inverse │ │ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1 ┆ 1 ┆ 1.0 │ │ 2 ┆ 4 ┆ 0.5 │ │ 4 ┆ 16 ┆ 0.25 │ │ 8 ┆ 64 ┆ 0.125 │ └─────┴───────────┴───────────┘ )rõ)r}rós ruròÚExpr.pows€ðf|‰|˜HÓ%Ð%rxcó$•URU5$)uÀ Method equivalent of bitwise exclusive-or operator `expr ^ other`. Parameters ---------- other Integer or boolean value; accepts expression input. Examples -------- >>> df = pl.DataFrame( ... {"x": [True, False, True, False], "y": [True, True, False, False]} ... ) >>> df.with_columns(pl.col("x").xor(pl.col("y")).alias("x ^ y")) shape: (4, 3) ┌───────┬───────┬───────┠│ x ┆ y ┆ x ^ y │ │ --- ┆ --- ┆ --- │ │ bool ┆ bool ┆ bool │ â•žâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•¡ │ true ┆ true ┆ false │ │ false ┆ true ┆ true │ │ true ┆ false ┆ true │ │ false ┆ false ┆ false │ └───────┴───────┴───────┘ >>> def binary_string(n: int) -> str: ... return bin(n)[2:].zfill(8) >>> >>> df = pl.DataFrame( ... data={"x": [10, 8, 250, 66], "y": [1, 2, 3, 4]}, ... schema={"x": pl.UInt8, "y": pl.UInt8}, ... ) >>> df.with_columns( ... pl.col("x") ... .map_elements(binary_string, return_dtype=pl.String) ... .alias("bin_x"), ... pl.col("y") ... .map_elements(binary_string, return_dtype=pl.String) ... .alias("bin_y"), ... pl.col("x").xor(pl.col("y")).alias("xor_xy"), ... pl.col("x") ... .xor(pl.col("y")) ... .map_elements(binary_string, return_dtype=pl.String) ... .alias("bin_xor_xy"), ... ) shape: (4, 6) ┌─────┬─────┬──────────┬──────────┬────────┬────────────┠│ x ┆ y ┆ bin_x ┆ bin_y ┆ xor_xy ┆ bin_xor_xy │ │ --- ┆ --- ┆ --- ┆ --- ┆ --- ┆ --- │ │ u8 ┆ u8 ┆ str ┆ str ┆ u8 ┆ str │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 10 ┆ 1 ┆ 00001010 ┆ 00000001 ┆ 11 ┆ 00001011 │ │ 8 ┆ 2 ┆ 00001000 ┆ 00000010 ┆ 10 ┆ 00001010 │ │ 250 ┆ 3 ┆ 11111010 ┆ 00000011 ┆ 249 ┆ 11111001 │ │ 66 ┆ 4 ┆ 01000010 ┆ 00000100 ┆ 70 ┆ 01000110 │ └─────┴─────┴──────────┴──────────┴────────┴────────────┘ )r r#s ruÚxorÚExpr.xorSs€ðv|‰|˜EÓ"Ð"rx)Ú nulls_equalcóê•[U[5(a0[U[[R45(d [ U5n[ U5n[URRX255$)uÒ Check if elements of this expression are present in the other Series. Parameters ---------- other Series or sequence of primitive type. nulls_equal : bool, default False If True, treat null as a distinct value. Null values will not propagate. Returns ------- Expr Expression of data type :class:`Boolean`. Examples -------- >>> df = pl.DataFrame( ... {"sets": [[1, 2, 3], [1, 2], [9, 10]], "optional_members": [1, 2, 3]} ... ) >>> df.with_columns(contains=pl.col("optional_members").is_in("sets")) shape: (3, 3) ┌───────────┬──────────────────┬──────────┠│ sets ┆ optional_members ┆ contains │ │ --- ┆ --- ┆ --- │ │ list[i64] ┆ i64 ┆ bool │ â•žâ•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•¡ │ [1, 2, 3] ┆ 1 ┆ true │ │ [1, 2] ┆ 2 ┆ true │ │ [9, 10] ┆ 3 ┆ false │ └───────────┴──────────────────┴──────────┘ ) r!rrirrGrjrr$rdÚis_in)r}rŸrUr s rurWÚ Expr.is_insT€ôL eœZ× (Ñ (´¸EÄCÌÏÉÐCS×1TÑ1Tܘ“KˆEä,¨UÓ3ˆ ܘŸ™×+Ñ+¨LÓFÓGÐGrxcó`•[U5n[URRU55$)u¸ Repeat the elements in this Series as specified in the given expression. The repeated elements are expanded into a `List`. Parameters ---------- by Numeric column that determines how often the values will be repeated. The column will be coerced to UInt32. Give this dtype to make the coercion a no-op. Returns ------- Expr Expression of data type :class:`List`, where the inner data type is equal to the original data type. Examples -------- >>> df = pl.DataFrame( ... { ... "a": ["x", "y", "z"], ... "n": [1, 2, 3], ... } ... ) >>> df.select(pl.col("a").repeat_by("n")) shape: (3, 1) ┌─────────────────┠│ a │ │ --- │ │ list[str] │ â•žâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ ["x"] │ │ ["y", "y"] │ │ ["z", "z", "z"] │ └─────────────────┘ )rr$rdÚ repeat_by©r}rîrøs rurZÚExpr.repeat_by¼s)€ôN*¨"Ó-ˆ ܘŸ™×/Ñ/° Ó:Ó;Ð;rxcóx•[U5n[U5n[URRXEU55$)uc Check if this expression is between the given lower and upper bounds. Parameters ---------- lower_bound Lower bound value. Accepts expression input. Strings are parsed as column names, other non-expression inputs are parsed as literals. upper_bound Upper bound value. Accepts expression input. Strings are parsed as column names, other non-expression inputs are parsed as literals. closed : {'both', 'left', 'right', 'none'} Define which sides of the interval are closed (inclusive). Notes ----- If the value of the `lower_bound` is greater than that of the `upper_bound` then the result will be False, as no value can satisfy the condition. Returns ------- Expr Expression of data type :class:`Boolean`. Examples -------- >>> df = pl.DataFrame({"num": [1, 2, 3, 4, 5]}) >>> df.with_columns(pl.col("num").is_between(2, 4).alias("is_between")) shape: (5, 2) ┌─────┬────────────┠│ num ┆ is_between │ │ --- ┆ --- │ │ i64 ┆ bool │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1 ┆ false │ │ 2 ┆ true │ │ 3 ┆ true │ │ 4 ┆ true │ │ 5 ┆ false │ └─────┴────────────┘ Use the `closed` argument to include or exclude the values at the bounds: >>> df.with_columns( ... pl.col("num").is_between(2, 4, closed="left").alias("is_between") ... ) shape: (5, 2) ┌─────┬────────────┠│ num ┆ is_between │ │ --- ┆ --- │ │ i64 ┆ bool │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1 ┆ false │ │ 2 ┆ true │ │ 3 ┆ true │ │ 4 ┆ false │ │ 5 ┆ false │ └─────┴────────────┘ You can also use strings as well as numeric/temporal values (note: ensure that string literals are wrapped with `lit` so as not to conflate them with column names): >>> df = pl.DataFrame({"a": ["a", "b", "c", "d", "e"]}) >>> df.with_columns( ... pl.col("a") ... .is_between(pl.lit("a"), pl.lit("c"), closed="both") ... .alias("is_between") ... ) shape: (5, 2) ┌─────┬────────────┠│ a ┆ is_between │ │ --- ┆ --- │ │ str ┆ bool │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ a ┆ true │ │ b ┆ true │ │ c ┆ true │ │ d ┆ false │ │ e ┆ false │ └─────┴────────────┘ Use column expressions as lower/upper bounds, comparing to a literal value: >>> df = pl.DataFrame({"a": [1, 2, 3, 4, 5], "b": [5, 4, 3, 2, 1]}) >>> df.with_columns( ... pl.lit(3).is_between(pl.col("a"), pl.col("b")).alias("between_ab") ... ) shape: (5, 3) ┌─────┬─────┬────────────┠│ a ┆ b ┆ between_ab │ │ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ bool │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1 ┆ 5 ┆ true │ │ 2 ┆ 4 ┆ true │ │ 3 ┆ 3 ┆ true │ │ 4 ┆ 2 ┆ false │ │ 5 ┆ 1 ┆ false │ └─────┴─────┴────────────┘ )rr$rdÚ is_between)r}Ú lower_boundÚ upper_boundrŠÚlower_bound_pyexprÚupper_bound_pyexprs rur^ÚExpr.is_betweenæs=€ôV3°;Ó?ÐÜ2°;Ó?ÐäØ L‰L× #Ñ #Ð$6ÈFÓ Só ð rxçg•Ö&è .>)Úabs_tolÚrel_tolÚ nans_equalcób•[U5n[URRXRX455$)u× Check if this expression is close, i.e. almost equal, to the other expression. Two values `a` and `b` are considered close if the following condition holds: .. math:: |a-b| \le max \{ \text{rel_tol} \cdot max \{ |a|, |b| \}, \text{abs_tol} \} Parameters ---------- abs_tol Absolute tolerance. This is the maximum allowed absolute difference between two values. Must be non-negative. rel_tol Relative tolerance. This is the maximum allowed difference between two values, relative to the larger absolute value. Must be non-negative. nans_equal Whether NaN values should be considered equal. Returns ------- Expr Expression of data type :class:`Boolean`. Notes ----- The implementation of this method is symmetric and mirrors the behavior of :meth:`math.isclose`. Specifically note that this behavior is different to :meth:`numpy.isclose`. Examples -------- >>> df = pl.DataFrame({"a": [1.5, 2.0, 2.5], "b": [1.55, 2.2, 3.0]}) >>> df.with_columns(pl.col("a").is_close("b", abs_tol=0.1).alias("is_close")) shape: (3, 3) ┌─────┬──────┬──────────┠│ a ┆ b ┆ is_close │ │ --- ┆ --- ┆ --- │ │ f64 ┆ f64 ┆ bool │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•¡ │ 1.5 ┆ 1.55 ┆ true │ │ 2.0 ┆ 2.2 ┆ false │ │ 2.5 ┆ 3.0 ┆ false │ └─────┴──────┴──────────┘ )rr$rdÚis_close)r}rŸrerfrgr s ruriÚ Expr.is_closeXs0€ôj-¨UÓ3ˆ ÜØ L‰L× !Ñ ! ,¸Ó Mó ð rxcóz•UnUbUOUnUbUOUnUbUOUn[URRXVXx55$)uÌ Hash the elements in the selection. The hash value is of type `UInt64`. Parameters ---------- seed Random seed parameter. Defaults to 0. seed_1 Random seed parameter. Defaults to `seed` if not set. seed_2 Random seed parameter. Defaults to `seed` if not set. seed_3 Random seed parameter. Defaults to `seed` if not set. Notes ----- This implementation of `hash` does not guarantee stable results across different Polars versions. Its stability is only guaranteed within a single version. Examples -------- >>> df = pl.DataFrame( ... { ... "a": [1, 2, None], ... "b": ["x", None, "z"], ... } ... ) >>> df.with_columns(pl.all().hash(10, 20, 30, 40)) # doctest: +IGNORE_RESULT shape: (3, 2) ┌──────────────────────┬──────────────────────┠│ a ┆ b │ │ --- ┆ --- │ │ u64 ┆ u64 │ â•žâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 9774092659964970114 ┆ 13614470193936745724 │ │ 1101441246220388612 ┆ 11638928888656214026 │ │ 11638928888656214026 ┆ 13382926553367784577 │ └──────────────────────┴──────────────────────┘ )r$rdÚhash) r}ÚseedÚseed_1Úseed_2Úseed_3Úk0Úk1Úk2Úk3s rurlÚ Expr.hash’sJ€ðbˆØÑ)‰V¨tˆØÑ)‰V¨tˆØÑ)‰V¨tˆÜ˜Ÿ™×*Ñ*¨2°2Ó:Ó;Ð;rx)ÚsignedcóJ•[URRU55$)uþ Reinterpret the underlying bits as a signed/unsigned integer. This operation is only allowed for 64bit integers. For lower bits integers, you can safely use that cast operation. Parameters ---------- signed If True, reinterpret as `pl.Int64`. Otherwise, reinterpret as `pl.UInt64`. Examples -------- >>> s = pl.Series("a", [1, 1, 2], dtype=pl.UInt64) >>> df = pl.DataFrame([s]) >>> df.select( ... [ ... pl.col("a").reinterpret(signed=True).alias("reinterpreted"), ... pl.col("a").alias("original"), ... ] ... ) shape: (3, 2) ┌───────────────┬──────────┠│ reinterpreted ┆ original │ │ --- ┆ --- │ │ i64 ┆ u64 │ â•žâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•¡ │ 1 ┆ 1 │ │ 1 ┆ 1 │ │ 2 ┆ 2 │ └───────────────┴──────────┘ )r$rdÚ reinterpret)r}rvs rurxÚExpr.reinterpretÉs€ôB˜Ÿ™×1Ñ1°&Ó9Ó:Ð:rxcó\^•SU4SjjnURU[R"U5S9$)u« Print the value that this expression evaluates to and pass on the value. Examples -------- >>> df = pl.DataFrame({"foo": [1, 1, 2]}) >>> df.select(pl.col("foo").cum_sum().inspect("value is: {}").alias("bar")) value is: shape: (3,) Series: 'foo' [i64] [ 1 2 4 ] shape: (3, 1) ┌─────┠│ bar │ │ --- │ │ i64 │ â•žâ•â•â•â•â•â•¡ │ 1 │ │ 2 │ │ 4 │ └─────┘ có<>•[TRU55 U$rp)ÚprintrJ)r+Úfmts €ruÚinspectÚExpr.inspect..inspectsø€Ü #—*‘*˜Q“-Ô ØˆHrx)rÏr4)r:rÚdtype_of)r}r}r~s ` rur~Ú Expr.inspectìs)ø€÷6 ð×Ñ ´a·j²jÀÓ6FÐÐGÐGrxcóJ•[URRU55$)u Interpolate intermediate values. Nulls at the beginning and end of the series remain null. Parameters ---------- method : {'linear', 'nearest'} Interpolation method. Examples -------- Fill null values using linear interpolation. >>> df = pl.DataFrame( ... { ... "a": [1, None, 3], ... "b": [1.0, float("nan"), 3.0], ... } ... ) >>> df.select(pl.all().interpolate()) shape: (3, 2) ┌─────┬─────┠│ a ┆ b │ │ --- ┆ --- │ │ f64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ 1.0 ┆ 1.0 │ │ 2.0 ┆ NaN │ │ 3.0 ┆ 3.0 │ └─────┴─────┘ Fill null values using nearest interpolation. >>> df.select(pl.all().interpolate("nearest")) shape: (3, 2) ┌─────┬─────┠│ a ┆ b │ │ --- ┆ --- │ │ i64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ 1 ┆ 1.0 │ │ 3 ┆ NaN │ │ 3 ┆ 3.0 │ └─────┴─────┘ Regrid data to a new grid. >>> df_original_grid = pl.DataFrame( ... { ... "grid_points": [1, 3, 10], ... "values": [2.0, 6.0, 20.0], ... } ... ) # Interpolate from this to the new grid >>> df_new_grid = pl.DataFrame({"grid_points": range(1, 11)}) >>> df_new_grid.join( ... df_original_grid, on="grid_points", how="left", coalesce=True ... ).with_columns(pl.col("values").interpolate()) shape: (10, 2) ┌─────────────┬────────┠│ grid_points ┆ values │ │ --- ┆ --- │ │ i64 ┆ f64 │ â•žâ•â•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•¡ │ 1 ┆ 2.0 │ │ 2 ┆ 4.0 │ │ 3 ┆ 6.0 │ │ 4 ┆ 8.0 │ │ 5 ┆ 10.0 │ │ 6 ┆ 12.0 │ │ 7 ┆ 14.0 │ │ 8 ┆ 16.0 │ │ 9 ┆ 18.0 │ │ 10 ┆ 20.0 │ └─────────────┴────────┘ )r$rdÚ interpolate)r}r>s rurƒÚExpr.interpolate s€ôZ˜Ÿ™×1Ñ1°&Ó9Ó:Ð:rxcó`•[U5n[URRU55$)uù Fill null values using interpolation based on another column. Nulls at the beginning and end of the series remain null. Parameters ---------- by Column to interpolate values based on. Examples -------- Fill null values using linear interpolation. >>> df = pl.DataFrame( ... { ... "a": [1, None, None, 3], ... "b": [1, 2, 7, 8], ... } ... ) >>> df.with_columns(a_interpolated=pl.col("a").interpolate_by("b")) shape: (4, 3) ┌──────┬─────┬────────────────┠│ a ┆ b ┆ a_interpolated │ │ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ f64 │ â•žâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1 ┆ 1 ┆ 1.0 │ │ null ┆ 2 ┆ 1.285714 │ │ null ┆ 7 ┆ 2.714286 │ │ 3 ┆ 8 ┆ 3.0 │ └──────┴─────┴────────────────┘ )rr$rdÚinterpolate_byr[s rur†ÚExpr.interpolate_by\s)€ôD*¨"Ó-ˆ ܘŸ™×4Ñ4°YÓ?Ó@Ð@rxÚ min_periodsÚ min_samplesz1.21.0)r‰rŠcóx•[U5n[U5n[URR XRX455$)uf Apply a rolling min based on another column. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. Given a `by` column ``, then `closed="right"` (the default) means the windows will be: - (t_0 - window_size, t_0] - (t_1 - window_size, t_1] - ... - (t_n - window_size, t_n] .. versionchanged:: 1.21.0 The `min_periods` parameter was renamed `min_samples`. Parameters ---------- by Should be ``DateTime``, ``Date``, ``UInt64``, ``UInt32``, ``Int64``, or ``Int32`` data type (note that the integral ones require using `'i'` in `window size`). window_size The length of the window. Can be a dynamic temporal size indicated by a timedelta or the following string language: - 1ns (1 nanosecond) - 1us (1 microsecond) - 1ms (1 millisecond) - 1s (1 second) - 1m (1 minute) - 1h (1 hour) - 1d (1 calendar day) - 1w (1 calendar week) - 1mo (1 calendar month) - 1q (1 calendar quarter) - 1y (1 calendar year) - 1i (1 index count) By "calendar day", we mean the corresponding time on the next day (which may not be 24 hours, due to daylight savings). Similarly for "calendar week", "calendar month", "calendar quarter", and "calendar year". min_samples The number of values in the window that should be non-null before computing a result. closed : {'left', 'right', 'both', 'none'} Define which sides of the temporal interval are closed (inclusive), defaults to `'right'`. Notes ----- If you want to compute multiple aggregation statistics over the same dynamic window, consider using `rolling` - this method can cache the window size computation. Examples -------- Create a DataFrame with a datetime column and a row number column >>> from datetime import timedelta, datetime >>> start = datetime(2001, 1, 1) >>> stop = datetime(2001, 1, 2) >>> df_temporal = pl.DataFrame( ... {"date": pl.datetime_range(start, stop, "1h", eager=True)} ... ).with_row_index() >>> df_temporal shape: (25, 2) ┌───────┬─────────────────────┠│ index ┆ date │ │ --- ┆ --- │ │ u32 ┆ datetime[μs] │ â•žâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 0 ┆ 2001-01-01 00:00:00 │ │ 1 ┆ 2001-01-01 01:00:00 │ │ 2 ┆ 2001-01-01 02:00:00 │ │ 3 ┆ 2001-01-01 03:00:00 │ │ 4 ┆ 2001-01-01 04:00:00 │ │ … ┆ … │ │ 20 ┆ 2001-01-01 20:00:00 │ │ 21 ┆ 2001-01-01 21:00:00 │ │ 22 ┆ 2001-01-01 22:00:00 │ │ 23 ┆ 2001-01-01 23:00:00 │ │ 24 ┆ 2001-01-02 00:00:00 │ └───────┴─────────────────────┘ Compute the rolling min with the temporal windows closed on the right (default) >>> df_temporal.with_columns( ... rolling_row_min=pl.col("index").rolling_min_by("date", window_size="2h") ... ) shape: (25, 3) ┌───────┬─────────────────────┬─────────────────┠│ index ┆ date ┆ rolling_row_min │ │ --- ┆ --- ┆ --- │ │ u32 ┆ datetime[μs] ┆ u32 │ â•žâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 0 ┆ 2001-01-01 00:00:00 ┆ 0 │ │ 1 ┆ 2001-01-01 01:00:00 ┆ 0 │ │ 2 ┆ 2001-01-01 02:00:00 ┆ 1 │ │ 3 ┆ 2001-01-01 03:00:00 ┆ 2 │ │ 4 ┆ 2001-01-01 04:00:00 ┆ 3 │ │ … ┆ … ┆ … │ │ 20 ┆ 2001-01-01 20:00:00 ┆ 19 │ │ 21 ┆ 2001-01-01 21:00:00 ┆ 20 │ │ 22 ┆ 2001-01-01 22:00:00 ┆ 21 │ │ 23 ┆ 2001-01-01 23:00:00 ┆ 22 │ │ 24 ┆ 2001-01-02 00:00:00 ┆ 23 │ └───────┴─────────────────────┴─────────────────┘ )Ú_prepare_rolling_by_window_argsrr$rdÚrolling_min_by©r}rîÚ window_sizer‰rŠrøs rurŒÚExpr.rolling_min_bys:€ôt6°kÓBˆ Ü)¨"Ó-ˆ ÜØ L‰L× 'Ñ '¨ À Ó Tó ð rxcóx•[U5n[U5n[URR XRX455$)uB Apply a rolling max based on another column. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. Given a `by` column ``, then `closed="right"` (the default) means the windows will be: - (t_0 - window_size, t_0] - (t_1 - window_size, t_1] - ... - (t_n - window_size, t_n] .. versionchanged:: 1.21.0 The `min_periods` parameter was renamed `min_samples`. Parameters ---------- by Should be ``DateTime``, ``Date``, ``UInt64``, ``UInt32``, ``Int64``, or ``Int32`` data type (note that the integral ones require using `'i'` in `window size`). window_size The length of the window. Can be a dynamic temporal size indicated by a timedelta or the following string language: - 1ns (1 nanosecond) - 1us (1 microsecond) - 1ms (1 millisecond) - 1s (1 second) - 1m (1 minute) - 1h (1 hour) - 1d (1 calendar day) - 1w (1 calendar week) - 1mo (1 calendar month) - 1q (1 calendar quarter) - 1y (1 calendar year) - 1i (1 index count) By "calendar day", we mean the corresponding time on the next day (which may not be 24 hours, due to daylight savings). Similarly for "calendar week", "calendar month", "calendar quarter", and "calendar year". min_samples The number of values in the window that should be non-null before computing a result. closed : {'left', 'right', 'both', 'none'} Define which sides of the temporal interval are closed (inclusive), defaults to `'right'`. Notes ----- If you want to compute multiple aggregation statistics over the same dynamic window, consider using `rolling` - this method can cache the window size computation. Examples -------- Create a DataFrame with a datetime column and a row number column >>> from datetime import timedelta, datetime >>> start = datetime(2001, 1, 1) >>> stop = datetime(2001, 1, 2) >>> df_temporal = pl.DataFrame( ... {"date": pl.datetime_range(start, stop, "1h", eager=True)} ... ).with_row_index() >>> df_temporal shape: (25, 2) ┌───────┬─────────────────────┠│ index ┆ date │ │ --- ┆ --- │ │ u32 ┆ datetime[μs] │ â•žâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 0 ┆ 2001-01-01 00:00:00 │ │ 1 ┆ 2001-01-01 01:00:00 │ │ 2 ┆ 2001-01-01 02:00:00 │ │ 3 ┆ 2001-01-01 03:00:00 │ │ 4 ┆ 2001-01-01 04:00:00 │ │ … ┆ … │ │ 20 ┆ 2001-01-01 20:00:00 │ │ 21 ┆ 2001-01-01 21:00:00 │ │ 22 ┆ 2001-01-01 22:00:00 │ │ 23 ┆ 2001-01-01 23:00:00 │ │ 24 ┆ 2001-01-02 00:00:00 │ └───────┴─────────────────────┘ Compute the rolling max with the temporal windows closed on the right (default) >>> df_temporal.with_columns( ... rolling_row_max=pl.col("index").rolling_max_by("date", window_size="2h") ... ) shape: (25, 3) ┌───────┬─────────────────────┬─────────────────┠│ index ┆ date ┆ rolling_row_max │ │ --- ┆ --- ┆ --- │ │ u32 ┆ datetime[μs] ┆ u32 │ â•žâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 0 ┆ 2001-01-01 00:00:00 ┆ 0 │ │ 1 ┆ 2001-01-01 01:00:00 ┆ 1 │ │ 2 ┆ 2001-01-01 02:00:00 ┆ 2 │ │ 3 ┆ 2001-01-01 03:00:00 ┆ 3 │ │ 4 ┆ 2001-01-01 04:00:00 ┆ 4 │ │ … ┆ … ┆ … │ │ 20 ┆ 2001-01-01 20:00:00 ┆ 20 │ │ 21 ┆ 2001-01-01 21:00:00 ┆ 21 │ │ 22 ┆ 2001-01-01 22:00:00 ┆ 22 │ │ 23 ┆ 2001-01-01 23:00:00 ┆ 23 │ │ 24 ┆ 2001-01-02 00:00:00 ┆ 24 │ └───────┴─────────────────────┴─────────────────┘ Compute the rolling max with the closure of windows on both sides >>> df_temporal.with_columns( ... rolling_row_max=pl.col("index").rolling_max_by( ... "date", window_size="2h", closed="both" ... ) ... ) shape: (25, 3) ┌───────┬─────────────────────┬─────────────────┠│ index ┆ date ┆ rolling_row_max │ │ --- ┆ --- ┆ --- │ │ u32 ┆ datetime[μs] ┆ u32 │ â•žâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 0 ┆ 2001-01-01 00:00:00 ┆ 0 │ │ 1 ┆ 2001-01-01 01:00:00 ┆ 1 │ │ 2 ┆ 2001-01-01 02:00:00 ┆ 2 │ │ 3 ┆ 2001-01-01 03:00:00 ┆ 3 │ │ 4 ┆ 2001-01-01 04:00:00 ┆ 4 │ │ … ┆ … ┆ … │ │ 20 ┆ 2001-01-01 20:00:00 ┆ 20 │ │ 21 ┆ 2001-01-01 21:00:00 ┆ 21 │ │ 22 ┆ 2001-01-01 22:00:00 ┆ 22 │ │ 23 ┆ 2001-01-01 23:00:00 ┆ 23 │ │ 24 ┆ 2001-01-02 00:00:00 ┆ 24 │ └───────┴─────────────────────┴─────────────────┘ )r‹rr$rdÚrolling_max_byrs rur‘ÚExpr.rolling_max_byó:€ôh6°kÓBˆ Ü)¨"Ó-ˆ ÜØ L‰L× 'Ñ '¨ À Ó Tó ð rxcó|•[U5n[U5n[URR UUUU55$)u Apply a rolling mean based on another column. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. Given a `by` column ``, then `closed="right"` (the default) means the windows will be: - (t_0 - window_size, t_0] - (t_1 - window_size, t_1] - ... - (t_n - window_size, t_n] .. versionchanged:: 1.21.0 The `min_periods` parameter was renamed `min_samples`. Parameters ---------- by Should be ``DateTime``, ``Date``, ``UInt64``, ``UInt32``, ``Int64``, or ``Int32`` data type (note that the integral ones require using `'i'` in `window size`). window_size The length of the window. Can be a dynamic temporal size indicated by a timedelta or the following string language: - 1ns (1 nanosecond) - 1us (1 microsecond) - 1ms (1 millisecond) - 1s (1 second) - 1m (1 minute) - 1h (1 hour) - 1d (1 calendar day) - 1w (1 calendar week) - 1mo (1 calendar month) - 1q (1 calendar quarter) - 1y (1 calendar year) - 1i (1 index count) By "calendar day", we mean the corresponding time on the next day (which may not be 24 hours, due to daylight savings). Similarly for "calendar week", "calendar month", "calendar quarter", and "calendar year". min_samples The number of values in the window that should be non-null before computing a result. closed : {'left', 'right', 'both', 'none'} Define which sides of the temporal interval are closed (inclusive), defaults to `'right'`. Notes ----- If you want to compute multiple aggregation statistics over the same dynamic window, consider using `rolling` - this method can cache the window size computation. Examples -------- Create a DataFrame with a datetime column and a row number column >>> from datetime import timedelta, datetime >>> start = datetime(2001, 1, 1) >>> stop = datetime(2001, 1, 2) >>> df_temporal = pl.DataFrame( ... {"date": pl.datetime_range(start, stop, "1h", eager=True)} ... ).with_row_index() >>> df_temporal shape: (25, 2) ┌───────┬─────────────────────┠│ index ┆ date │ │ --- ┆ --- │ │ u32 ┆ datetime[μs] │ â•žâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 0 ┆ 2001-01-01 00:00:00 │ │ 1 ┆ 2001-01-01 01:00:00 │ │ 2 ┆ 2001-01-01 02:00:00 │ │ 3 ┆ 2001-01-01 03:00:00 │ │ 4 ┆ 2001-01-01 04:00:00 │ │ … ┆ … │ │ 20 ┆ 2001-01-01 20:00:00 │ │ 21 ┆ 2001-01-01 21:00:00 │ │ 22 ┆ 2001-01-01 22:00:00 │ │ 23 ┆ 2001-01-01 23:00:00 │ │ 24 ┆ 2001-01-02 00:00:00 │ └───────┴─────────────────────┘ Compute the rolling mean with the temporal windows closed on the right (default) >>> df_temporal.with_columns( ... rolling_row_mean=pl.col("index").rolling_mean_by( ... "date", window_size="2h" ... ) ... ) shape: (25, 3) ┌───────┬─────────────────────┬──────────────────┠│ index ┆ date ┆ rolling_row_mean │ │ --- ┆ --- ┆ --- │ │ u32 ┆ datetime[μs] ┆ f64 │ â•žâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 0 ┆ 2001-01-01 00:00:00 ┆ 0.0 │ │ 1 ┆ 2001-01-01 01:00:00 ┆ 0.5 │ │ 2 ┆ 2001-01-01 02:00:00 ┆ 1.5 │ │ 3 ┆ 2001-01-01 03:00:00 ┆ 2.5 │ │ 4 ┆ 2001-01-01 04:00:00 ┆ 3.5 │ │ … ┆ … ┆ … │ │ 20 ┆ 2001-01-01 20:00:00 ┆ 19.5 │ │ 21 ┆ 2001-01-01 21:00:00 ┆ 20.5 │ │ 22 ┆ 2001-01-01 22:00:00 ┆ 21.5 │ │ 23 ┆ 2001-01-01 23:00:00 ┆ 22.5 │ │ 24 ┆ 2001-01-02 00:00:00 ┆ 23.5 │ └───────┴─────────────────────┴──────────────────┘ Compute the rolling mean with the closure of windows on both sides >>> df_temporal.with_columns( ... rolling_row_mean=pl.col("index").rolling_mean_by( ... "date", window_size="2h", closed="both" ... ) ... ) shape: (25, 3) ┌───────┬─────────────────────┬──────────────────┠│ index ┆ date ┆ rolling_row_mean │ │ --- ┆ --- ┆ --- │ │ u32 ┆ datetime[μs] ┆ f64 │ â•žâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 0 ┆ 2001-01-01 00:00:00 ┆ 0.0 │ │ 1 ┆ 2001-01-01 01:00:00 ┆ 0.5 │ │ 2 ┆ 2001-01-01 02:00:00 ┆ 1.0 │ │ 3 ┆ 2001-01-01 03:00:00 ┆ 2.0 │ │ 4 ┆ 2001-01-01 04:00:00 ┆ 3.0 │ │ … ┆ … ┆ … │ │ 20 ┆ 2001-01-01 20:00:00 ┆ 19.0 │ │ 21 ┆ 2001-01-01 21:00:00 ┆ 20.0 │ │ 22 ┆ 2001-01-01 22:00:00 ┆ 21.0 │ │ 23 ┆ 2001-01-01 23:00:00 ┆ 22.0 │ │ 24 ┆ 2001-01-02 00:00:00 ┆ 23.0 │ └───────┴─────────────────────┴──────────────────┘ )r‹rr$rdÚrolling_mean_byrs rur•ÚExpr.rolling_mean_by›sD€ôl6°kÓBˆ Ü)¨"Ó-ˆ ÜØ L‰L× (Ñ (ØØØØó  ó ð rxcóx•[U5n[U5n[URR XRX455$)uB Apply a rolling sum based on another column. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. Given a `by` column ``, then `closed="right"` (the default) means the windows will be: - (t_0 - window_size, t_0] - (t_1 - window_size, t_1] - ... - (t_n - window_size, t_n] .. versionchanged:: 1.21.0 The `min_periods` parameter was renamed `min_samples`. Parameters ---------- window_size The length of the window. Can be a dynamic temporal size indicated by a timedelta or the following string language: - 1ns (1 nanosecond) - 1us (1 microsecond) - 1ms (1 millisecond) - 1s (1 second) - 1m (1 minute) - 1h (1 hour) - 1d (1 calendar day) - 1w (1 calendar week) - 1mo (1 calendar month) - 1q (1 calendar quarter) - 1y (1 calendar year) - 1i (1 index count) By "calendar day", we mean the corresponding time on the next day (which may not be 24 hours, due to daylight savings). Similarly for "calendar week", "calendar month", "calendar quarter", and "calendar year". min_samples The number of values in the window that should be non-null before computing a result. by Should be ``DateTime``, ``Date``, ``UInt64``, ``UInt32``, ``Int64``, or ``Int32`` data type (note that the integral ones require using `'i'` in `window size`). closed : {'left', 'right', 'both', 'none'} Define which sides of the temporal interval are closed (inclusive), defaults to `'right'`. Notes ----- If you want to compute multiple aggregation statistics over the same dynamic window, consider using `rolling` - this method can cache the window size computation. Examples -------- Create a DataFrame with a datetime column and a row number column >>> from datetime import timedelta, datetime >>> start = datetime(2001, 1, 1) >>> stop = datetime(2001, 1, 2) >>> df_temporal = pl.DataFrame( ... {"date": pl.datetime_range(start, stop, "1h", eager=True)} ... ).with_row_index() >>> df_temporal shape: (25, 2) ┌───────┬─────────────────────┠│ index ┆ date │ │ --- ┆ --- │ │ u32 ┆ datetime[μs] │ â•žâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 0 ┆ 2001-01-01 00:00:00 │ │ 1 ┆ 2001-01-01 01:00:00 │ │ 2 ┆ 2001-01-01 02:00:00 │ │ 3 ┆ 2001-01-01 03:00:00 │ │ 4 ┆ 2001-01-01 04:00:00 │ │ … ┆ … │ │ 20 ┆ 2001-01-01 20:00:00 │ │ 21 ┆ 2001-01-01 21:00:00 │ │ 22 ┆ 2001-01-01 22:00:00 │ │ 23 ┆ 2001-01-01 23:00:00 │ │ 24 ┆ 2001-01-02 00:00:00 │ └───────┴─────────────────────┘ Compute the rolling sum with the temporal windows closed on the right (default) >>> df_temporal.with_columns( ... rolling_row_sum=pl.col("index").rolling_sum_by("date", window_size="2h") ... ) shape: (25, 3) ┌───────┬─────────────────────┬─────────────────┠│ index ┆ date ┆ rolling_row_sum │ │ --- ┆ --- ┆ --- │ │ u32 ┆ datetime[μs] ┆ u32 │ â•žâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 0 ┆ 2001-01-01 00:00:00 ┆ 0 │ │ 1 ┆ 2001-01-01 01:00:00 ┆ 1 │ │ 2 ┆ 2001-01-01 02:00:00 ┆ 3 │ │ 3 ┆ 2001-01-01 03:00:00 ┆ 5 │ │ 4 ┆ 2001-01-01 04:00:00 ┆ 7 │ │ … ┆ … ┆ … │ │ 20 ┆ 2001-01-01 20:00:00 ┆ 39 │ │ 21 ┆ 2001-01-01 21:00:00 ┆ 41 │ │ 22 ┆ 2001-01-01 22:00:00 ┆ 43 │ │ 23 ┆ 2001-01-01 23:00:00 ┆ 45 │ │ 24 ┆ 2001-01-02 00:00:00 ┆ 47 │ └───────┴─────────────────────┴─────────────────┘ Compute the rolling sum with the closure of windows on both sides >>> df_temporal.with_columns( ... rolling_row_sum=pl.col("index").rolling_sum_by( ... "date", window_size="2h", closed="both" ... ) ... ) shape: (25, 3) ┌───────┬─────────────────────┬─────────────────┠│ index ┆ date ┆ rolling_row_sum │ │ --- ┆ --- ┆ --- │ │ u32 ┆ datetime[μs] ┆ u32 │ â•žâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 0 ┆ 2001-01-01 00:00:00 ┆ 0 │ │ 1 ┆ 2001-01-01 01:00:00 ┆ 1 │ │ 2 ┆ 2001-01-01 02:00:00 ┆ 3 │ │ 3 ┆ 2001-01-01 03:00:00 ┆ 6 │ │ 4 ┆ 2001-01-01 04:00:00 ┆ 9 │ │ … ┆ … ┆ … │ │ 20 ┆ 2001-01-01 20:00:00 ┆ 57 │ │ 21 ┆ 2001-01-01 21:00:00 ┆ 60 │ │ 22 ┆ 2001-01-01 22:00:00 ┆ 63 │ │ 23 ┆ 2001-01-01 23:00:00 ┆ 66 │ │ 24 ┆ 2001-01-02 00:00:00 ┆ 69 │ └───────┴─────────────────────┴─────────────────┘ )r‹rr$rdÚrolling_sum_byrs rur˜ÚExpr.rolling_sum_by<r“rx)r‰rŠrCc ó~•[U5n[U5n[URR UUUUU55$)u¦ Compute a rolling standard deviation based on another column. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. Given a `by` column ``, then `closed="right"` (the default) means the windows will be: - (t_0 - window_size, t_0] - (t_1 - window_size, t_1] - ... - (t_n - window_size, t_n] .. versionchanged:: 1.21.0 The `min_periods` parameter was renamed `min_samples`. Parameters ---------- by Should be ``DateTime``, ``Date``, ``UInt64``, ``UInt32``, ``Int64``, or ``Int32`` data type (note that the integral ones require using `'i'` in `window size`). window_size The length of the window. Can be a dynamic temporal size indicated by a timedelta or the following string language: - 1ns (1 nanosecond) - 1us (1 microsecond) - 1ms (1 millisecond) - 1s (1 second) - 1m (1 minute) - 1h (1 hour) - 1d (1 calendar day) - 1w (1 calendar week) - 1mo (1 calendar month) - 1q (1 calendar quarter) - 1y (1 calendar year) - 1i (1 index count) By "calendar day", we mean the corresponding time on the next day (which may not be 24 hours, due to daylight savings). Similarly for "calendar week", "calendar month", "calendar quarter", and "calendar year". min_samples The number of values in the window that should be non-null before computing a result. closed : {'left', 'right', 'both', 'none'} Define which sides of the temporal interval are closed (inclusive), defaults to `'right'`. ddof "Delta Degrees of Freedom": The divisor for a length N window is N - ddof Notes ----- If you want to compute multiple aggregation statistics over the same dynamic window, consider using `rolling` - this method can cache the window size computation. Examples -------- Create a DataFrame with a datetime column and a row number column >>> from datetime import timedelta, datetime >>> start = datetime(2001, 1, 1) >>> stop = datetime(2001, 1, 2) >>> df_temporal = pl.DataFrame( ... {"date": pl.datetime_range(start, stop, "1h", eager=True)} ... ).with_row_index() >>> df_temporal shape: (25, 2) ┌───────┬─────────────────────┠│ index ┆ date │ │ --- ┆ --- │ │ u32 ┆ datetime[μs] │ â•žâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 0 ┆ 2001-01-01 00:00:00 │ │ 1 ┆ 2001-01-01 01:00:00 │ │ 2 ┆ 2001-01-01 02:00:00 │ │ 3 ┆ 2001-01-01 03:00:00 │ │ 4 ┆ 2001-01-01 04:00:00 │ │ … ┆ … │ │ 20 ┆ 2001-01-01 20:00:00 │ │ 21 ┆ 2001-01-01 21:00:00 │ │ 22 ┆ 2001-01-01 22:00:00 │ │ 23 ┆ 2001-01-01 23:00:00 │ │ 24 ┆ 2001-01-02 00:00:00 │ └───────┴─────────────────────┘ Compute the rolling std with the temporal windows closed on the right (default) >>> df_temporal.with_columns( ... rolling_row_std=pl.col("index").rolling_std_by("date", window_size="2h") ... ) shape: (25, 3) ┌───────┬─────────────────────┬─────────────────┠│ index ┆ date ┆ rolling_row_std │ │ --- ┆ --- ┆ --- │ │ u32 ┆ datetime[μs] ┆ f64 │ â•žâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 0 ┆ 2001-01-01 00:00:00 ┆ null │ │ 1 ┆ 2001-01-01 01:00:00 ┆ 0.707107 │ │ 2 ┆ 2001-01-01 02:00:00 ┆ 0.707107 │ │ 3 ┆ 2001-01-01 03:00:00 ┆ 0.707107 │ │ 4 ┆ 2001-01-01 04:00:00 ┆ 0.707107 │ │ … ┆ … ┆ … │ │ 20 ┆ 2001-01-01 20:00:00 ┆ 0.707107 │ │ 21 ┆ 2001-01-01 21:00:00 ┆ 0.707107 │ │ 22 ┆ 2001-01-01 22:00:00 ┆ 0.707107 │ │ 23 ┆ 2001-01-01 23:00:00 ┆ 0.707107 │ │ 24 ┆ 2001-01-02 00:00:00 ┆ 0.707107 │ └───────┴─────────────────────┴─────────────────┘ Compute the rolling std with the closure of windows on both sides >>> df_temporal.with_columns( ... rolling_row_std=pl.col("index").rolling_std_by( ... "date", window_size="2h", closed="both" ... ) ... ) shape: (25, 3) ┌───────┬─────────────────────┬─────────────────┠│ index ┆ date ┆ rolling_row_std │ │ --- ┆ --- ┆ --- │ │ u32 ┆ datetime[μs] ┆ f64 │ â•žâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 0 ┆ 2001-01-01 00:00:00 ┆ null │ │ 1 ┆ 2001-01-01 01:00:00 ┆ 0.707107 │ │ 2 ┆ 2001-01-01 02:00:00 ┆ 1.0 │ │ 3 ┆ 2001-01-01 03:00:00 ┆ 1.0 │ │ 4 ┆ 2001-01-01 04:00:00 ┆ 1.0 │ │ … ┆ … ┆ … │ │ 20 ┆ 2001-01-01 20:00:00 ┆ 1.0 │ │ 21 ┆ 2001-01-01 21:00:00 ┆ 1.0 │ │ 22 ┆ 2001-01-01 22:00:00 ┆ 1.0 │ │ 23 ┆ 2001-01-01 23:00:00 ┆ 1.0 │ │ 24 ┆ 2001-01-02 00:00:00 ┆ 1.0 │ └───────┴─────────────────────┴─────────────────┘ )r‹rr$rdÚrolling_std_by©r}rîrŽr‰rŠrCrøs rur›ÚExpr.rolling_std_byÖóG€ôn6°kÓBˆ Ü)¨"Ó-ˆ ÜØ L‰L× 'Ñ 'ØØØØØó  ó ð rxc ó~•[U5n[U5n[URR UUUUU55$)uœ Compute a rolling variance based on another column. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. Given a `by` column ``, then `closed="right"` (the default) means the windows will be: - (t_0 - window_size, t_0] - (t_1 - window_size, t_1] - ... - (t_n - window_size, t_n] .. versionchanged:: 1.21.0 The `min_periods` parameter was renamed `min_samples`. Parameters ---------- by Should be ``DateTime``, ``Date``, ``UInt64``, ``UInt32``, ``Int64``, or ``Int32`` data type (note that the integral ones require using `'i'` in `window size`). window_size The length of the window. Can be a dynamic temporal size indicated by a timedelta or the following string language: - 1ns (1 nanosecond) - 1us (1 microsecond) - 1ms (1 millisecond) - 1s (1 second) - 1m (1 minute) - 1h (1 hour) - 1d (1 calendar day) - 1w (1 calendar week) - 1mo (1 calendar month) - 1q (1 calendar quarter) - 1y (1 calendar year) - 1i (1 index count) By "calendar day", we mean the corresponding time on the next day (which may not be 24 hours, due to daylight savings). Similarly for "calendar week", "calendar month", "calendar quarter", and "calendar year". min_samples The number of values in the window that should be non-null before computing a result. closed : {'left', 'right', 'both', 'none'} Define which sides of the temporal interval are closed (inclusive), defaults to `'right'`. ddof "Delta Degrees of Freedom": The divisor for a length N window is N - ddof Notes ----- If you want to compute multiple aggregation statistics over the same dynamic window, consider using `rolling` - this method can cache the window size computation. Examples -------- Create a DataFrame with a datetime column and a row number column >>> from datetime import timedelta, datetime >>> start = datetime(2001, 1, 1) >>> stop = datetime(2001, 1, 2) >>> df_temporal = pl.DataFrame( ... {"date": pl.datetime_range(start, stop, "1h", eager=True)} ... ).with_row_index() >>> df_temporal shape: (25, 2) ┌───────┬─────────────────────┠│ index ┆ date │ │ --- ┆ --- │ │ u32 ┆ datetime[μs] │ â•žâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 0 ┆ 2001-01-01 00:00:00 │ │ 1 ┆ 2001-01-01 01:00:00 │ │ 2 ┆ 2001-01-01 02:00:00 │ │ 3 ┆ 2001-01-01 03:00:00 │ │ 4 ┆ 2001-01-01 04:00:00 │ │ … ┆ … │ │ 20 ┆ 2001-01-01 20:00:00 │ │ 21 ┆ 2001-01-01 21:00:00 │ │ 22 ┆ 2001-01-01 22:00:00 │ │ 23 ┆ 2001-01-01 23:00:00 │ │ 24 ┆ 2001-01-02 00:00:00 │ └───────┴─────────────────────┘ Compute the rolling var with the temporal windows closed on the right (default) >>> df_temporal.with_columns( ... rolling_row_var=pl.col("index").rolling_var_by("date", window_size="2h") ... ) shape: (25, 3) ┌───────┬─────────────────────┬─────────────────┠│ index ┆ date ┆ rolling_row_var │ │ --- ┆ --- ┆ --- │ │ u32 ┆ datetime[μs] ┆ f64 │ â•žâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 0 ┆ 2001-01-01 00:00:00 ┆ null │ │ 1 ┆ 2001-01-01 01:00:00 ┆ 0.5 │ │ 2 ┆ 2001-01-01 02:00:00 ┆ 0.5 │ │ 3 ┆ 2001-01-01 03:00:00 ┆ 0.5 │ │ 4 ┆ 2001-01-01 04:00:00 ┆ 0.5 │ │ … ┆ … ┆ … │ │ 20 ┆ 2001-01-01 20:00:00 ┆ 0.5 │ │ 21 ┆ 2001-01-01 21:00:00 ┆ 0.5 │ │ 22 ┆ 2001-01-01 22:00:00 ┆ 0.5 │ │ 23 ┆ 2001-01-01 23:00:00 ┆ 0.5 │ │ 24 ┆ 2001-01-02 00:00:00 ┆ 0.5 │ └───────┴─────────────────────┴─────────────────┘ Compute the rolling var with the closure of windows on both sides >>> df_temporal.with_columns( ... rolling_row_var=pl.col("index").rolling_var_by( ... "date", window_size="2h", closed="both" ... ) ... ) shape: (25, 3) ┌───────┬─────────────────────┬─────────────────┠│ index ┆ date ┆ rolling_row_var │ │ --- ┆ --- ┆ --- │ │ u32 ┆ datetime[μs] ┆ f64 │ â•žâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 0 ┆ 2001-01-01 00:00:00 ┆ null │ │ 1 ┆ 2001-01-01 01:00:00 ┆ 0.5 │ │ 2 ┆ 2001-01-01 02:00:00 ┆ 1.0 │ │ 3 ┆ 2001-01-01 03:00:00 ┆ 1.0 │ │ 4 ┆ 2001-01-01 04:00:00 ┆ 1.0 │ │ … ┆ … ┆ … │ │ 20 ┆ 2001-01-01 20:00:00 ┆ 1.0 │ │ 21 ┆ 2001-01-01 21:00:00 ┆ 1.0 │ │ 22 ┆ 2001-01-01 22:00:00 ┆ 1.0 │ │ 23 ┆ 2001-01-01 23:00:00 ┆ 1.0 │ │ 24 ┆ 2001-01-02 00:00:00 ┆ 1.0 │ └───────┴─────────────────────┴─────────────────┘ )r‹rr$rdÚrolling_var_byrœs rur ÚExpr.rolling_var_byyržrxcóx•[U5n[U5n[URR XRX455$)uÆ Compute a rolling median based on another column. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. Given a `by` column ``, then `closed="right"` (the default) means the windows will be: - (t_0 - window_size, t_0] - (t_1 - window_size, t_1] - ... - (t_n - window_size, t_n] .. versionchanged:: 1.21.0 The `min_periods` parameter was renamed `min_samples`. Parameters ---------- by Should be ``DateTime``, ``Date``, ``UInt64``, ``UInt32``, ``Int64``, or ``Int32`` data type (note that the integral ones require using `'i'` in `window size`). window_size The length of the window. Can be a dynamic temporal size indicated by a timedelta or the following string language: - 1ns (1 nanosecond) - 1us (1 microsecond) - 1ms (1 millisecond) - 1s (1 second) - 1m (1 minute) - 1h (1 hour) - 1d (1 calendar day) - 1w (1 calendar week) - 1mo (1 calendar month) - 1q (1 calendar quarter) - 1y (1 calendar year) - 1i (1 index count) By "calendar day", we mean the corresponding time on the next day (which may not be 24 hours, due to daylight savings). Similarly for "calendar week", "calendar month", "calendar quarter", and "calendar year". min_samples The number of values in the window that should be non-null before computing a result. closed : {'left', 'right', 'both', 'none'} Define which sides of the temporal interval are closed (inclusive), defaults to `'right'`. Notes ----- If you want to compute multiple aggregation statistics over the same dynamic window, consider using `rolling` - this method can cache the window size computation. Examples -------- Create a DataFrame with a datetime column and a row number column >>> from datetime import timedelta, datetime >>> start = datetime(2001, 1, 1) >>> stop = datetime(2001, 1, 2) >>> df_temporal = pl.DataFrame( ... {"date": pl.datetime_range(start, stop, "1h", eager=True)} ... ).with_row_index() >>> df_temporal shape: (25, 2) ┌───────┬─────────────────────┠│ index ┆ date │ │ --- ┆ --- │ │ u32 ┆ datetime[μs] │ â•žâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 0 ┆ 2001-01-01 00:00:00 │ │ 1 ┆ 2001-01-01 01:00:00 │ │ 2 ┆ 2001-01-01 02:00:00 │ │ 3 ┆ 2001-01-01 03:00:00 │ │ 4 ┆ 2001-01-01 04:00:00 │ │ … ┆ … │ │ 20 ┆ 2001-01-01 20:00:00 │ │ 21 ┆ 2001-01-01 21:00:00 │ │ 22 ┆ 2001-01-01 22:00:00 │ │ 23 ┆ 2001-01-01 23:00:00 │ │ 24 ┆ 2001-01-02 00:00:00 │ └───────┴─────────────────────┘ Compute the rolling median with the temporal windows closed on the right: >>> df_temporal.with_columns( ... rolling_row_median=pl.col("index").rolling_median_by( ... "date", window_size="2h" ... ) ... ) shape: (25, 3) ┌───────┬─────────────────────┬────────────────────┠│ index ┆ date ┆ rolling_row_median │ │ --- ┆ --- ┆ --- │ │ u32 ┆ datetime[μs] ┆ f64 │ â•žâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 0 ┆ 2001-01-01 00:00:00 ┆ 0.0 │ │ 1 ┆ 2001-01-01 01:00:00 ┆ 0.5 │ │ 2 ┆ 2001-01-01 02:00:00 ┆ 1.5 │ │ 3 ┆ 2001-01-01 03:00:00 ┆ 2.5 │ │ 4 ┆ 2001-01-01 04:00:00 ┆ 3.5 │ │ … ┆ … ┆ … │ │ 20 ┆ 2001-01-01 20:00:00 ┆ 19.5 │ │ 21 ┆ 2001-01-01 21:00:00 ┆ 20.5 │ │ 22 ┆ 2001-01-01 22:00:00 ┆ 21.5 │ │ 23 ┆ 2001-01-01 23:00:00 ┆ 22.5 │ │ 24 ┆ 2001-01-02 00:00:00 ┆ 23.5 │ └───────┴─────────────────────┴────────────────────┘ )r‹rr$rdÚrolling_median_byrs rur£ÚExpr.rolling_median_bys:€ôx6°kÓBˆ Ü)¨"Ó-ˆ ÜØ L‰L× *Ñ *¨9À;Ó Wó ð rx)r¦r‰rŠc ó€•[U5n[U5n[URR UUUUUU55$)u¤ Compute a rolling quantile based on another column. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. Given a `by` column ``, then `closed="right"` (the default) means the windows will be: - (t_0 - window_size, t_0] - (t_1 - window_size, t_1] - ... - (t_n - window_size, t_n] .. versionchanged:: 1.21.0 The `min_periods` parameter was renamed `min_samples`. Parameters ---------- by Should be ``DateTime``, ``Date``, ``UInt64``, ``UInt32``, ``Int64``, or ``Int32`` data type (note that the integral ones require using `'i'` in `window size`). quantile Quantile between 0.0 and 1.0. interpolation : {'nearest', 'higher', 'lower', 'midpoint', 'linear', 'equiprobable'} Interpolation method. window_size The length of the window. Can be a dynamic temporal size indicated by a timedelta or the following string language: - 1ns (1 nanosecond) - 1us (1 microsecond) - 1ms (1 millisecond) - 1s (1 second) - 1m (1 minute) - 1h (1 hour) - 1d (1 calendar day) - 1w (1 calendar week) - 1mo (1 calendar month) - 1q (1 calendar quarter) - 1y (1 calendar year) - 1i (1 index count) By "calendar day", we mean the corresponding time on the next day (which may not be 24 hours, due to daylight savings). Similarly for "calendar week", "calendar month", "calendar quarter", and "calendar year". min_samples The number of values in the window that should be non-null before computing a result. closed : {'left', 'right', 'both', 'none'} Define which sides of the temporal interval are closed (inclusive), defaults to `'right'`. Notes ----- If you want to compute multiple aggregation statistics over the same dynamic window, consider using `rolling` - this method can cache the window size computation. Examples -------- Create a DataFrame with a datetime column and a row number column >>> from datetime import timedelta, datetime >>> start = datetime(2001, 1, 1) >>> stop = datetime(2001, 1, 2) >>> df_temporal = pl.DataFrame( ... {"date": pl.datetime_range(start, stop, "1h", eager=True)} ... ).with_row_index() >>> df_temporal shape: (25, 2) ┌───────┬─────────────────────┠│ index ┆ date │ │ --- ┆ --- │ │ u32 ┆ datetime[μs] │ â•žâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 0 ┆ 2001-01-01 00:00:00 │ │ 1 ┆ 2001-01-01 01:00:00 │ │ 2 ┆ 2001-01-01 02:00:00 │ │ 3 ┆ 2001-01-01 03:00:00 │ │ 4 ┆ 2001-01-01 04:00:00 │ │ … ┆ … │ │ 20 ┆ 2001-01-01 20:00:00 │ │ 21 ┆ 2001-01-01 21:00:00 │ │ 22 ┆ 2001-01-01 22:00:00 │ │ 23 ┆ 2001-01-01 23:00:00 │ │ 24 ┆ 2001-01-02 00:00:00 │ └───────┴─────────────────────┘ Compute the rolling quantile with the temporal windows closed on the right: >>> df_temporal.with_columns( ... rolling_row_quantile=pl.col("index").rolling_quantile_by( ... "date", window_size="2h", quantile=0.3 ... ) ... ) shape: (25, 3) ┌───────┬─────────────────────┬──────────────────────┠│ index ┆ date ┆ rolling_row_quantile │ │ --- ┆ --- ┆ --- │ │ u32 ┆ datetime[μs] ┆ f64 │ â•žâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 0 ┆ 2001-01-01 00:00:00 ┆ 0.0 │ │ 1 ┆ 2001-01-01 01:00:00 ┆ 0.0 │ │ 2 ┆ 2001-01-01 02:00:00 ┆ 1.0 │ │ 3 ┆ 2001-01-01 03:00:00 ┆ 2.0 │ │ 4 ┆ 2001-01-01 04:00:00 ┆ 3.0 │ │ … ┆ … ┆ … │ │ 20 ┆ 2001-01-01 20:00:00 ┆ 19.0 │ │ 21 ┆ 2001-01-01 21:00:00 ┆ 20.0 │ │ 22 ┆ 2001-01-01 22:00:00 ┆ 21.0 │ │ 23 ┆ 2001-01-01 23:00:00 ┆ 22.0 │ │ 24 ┆ 2001-01-02 00:00:00 ┆ 23.0 │ └───────┴─────────────────────┴──────────────────────┘ )r‹rr$rdÚrolling_quantile_by)r}rîrŽr¥r¦r‰rŠrøs rur¦ÚExpr.rolling_quantile_byžsJ€ôD6°kÓBˆ Ü)¨"Ó-ˆ ÜØ L‰L× ,Ñ ,ØØØØØØó  ó  ð rx)r‰Úcenterc óL•[URRUUUUS95$)už Apply a rolling min (moving min) over the values in this array. A window of length `window_size` will traverse the array. The values that fill this window will (optionally) be multiplied with the weights given by the `weights` vector. The resulting values will be aggregated to their min. The window at a given row will include the row itself, and the `window_size - 1` elements before it. .. versionchanged:: 1.21.0 The `min_periods` parameter was renamed `min_samples`. Parameters ---------- window_size The length of the window in number of elements. weights An optional slice with the same length as the window that will be multiplied elementwise with the values in the window. min_samples The number of values in the window that should be non-null before computing a result. If set to `None` (default), it will be set equal to `window_size`. center Set the labels at the center of the window. Notes ----- If you want to compute multiple aggregation statistics over the same dynamic window, consider using `rolling` - this method can cache the window size computation. Examples -------- >>> df = pl.DataFrame({"A": [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]}) >>> df.with_columns( ... rolling_min=pl.col("A").rolling_min(window_size=2), ... ) shape: (6, 2) ┌─────┬─────────────┠│ A ┆ rolling_min │ │ --- ┆ --- │ │ f64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1.0 ┆ null │ │ 2.0 ┆ 1.0 │ │ 3.0 ┆ 2.0 │ │ 4.0 ┆ 3.0 │ │ 5.0 ┆ 4.0 │ │ 6.0 ┆ 5.0 │ └─────┴─────────────┘ Specify weights to multiply the values in the window with: >>> df.with_columns( ... rolling_min=pl.col("A").rolling_min( ... window_size=2, weights=[0.25, 0.75] ... ), ... ) shape: (6, 2) ┌─────┬─────────────┠│ A ┆ rolling_min │ │ --- ┆ --- │ │ f64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1.0 ┆ null │ │ 2.0 ┆ 0.25 │ │ 3.0 ┆ 0.5 │ │ 4.0 ┆ 0.75 │ │ 5.0 ┆ 1.0 │ │ 6.0 ┆ 1.25 │ └─────┴─────────────┘ Center the values in the window >>> df.with_columns( ... rolling_min=pl.col("A").rolling_min(window_size=3, center=True), ... ) shape: (6, 2) ┌─────┬─────────────┠│ A ┆ rolling_min │ │ --- ┆ --- │ │ f64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1.0 ┆ null │ │ 2.0 ┆ 1.0 │ │ 3.0 ┆ 2.0 │ │ 4.0 ┆ 3.0 │ │ 5.0 ┆ 4.0 │ │ 6.0 ┆ null │ └─────┴─────────────┘ ©r¨)r$rdÚ rolling_min©r}rŽÚweightsr‰r¨s rur«ÚExpr.rolling_min-s5€ôJØ L‰L× $Ñ $ØØØØð %ð ó ð rxcóP•[URRUUUU55$)už Apply a rolling max (moving max) over the values in this array. A window of length `window_size` will traverse the array. The values that fill this window will (optionally) be multiplied with the weights given by the `weights` vector. The resulting values will be aggregated to their max. The window at a given row will include the row itself, and the `window_size - 1` elements before it. .. versionchanged:: 1.21.0 The `min_periods` parameter was renamed `min_samples`. Parameters ---------- window_size The length of the window in number of elements. weights An optional slice with the same length as the window that will be multiplied elementwise with the values in the window. min_samples The number of values in the window that should be non-null before computing a result. If set to `None` (default), it will be set equal to `window_size`. center Set the labels at the center of the window. Notes ----- If you want to compute multiple aggregation statistics over the same dynamic window, consider using `rolling` - this method can cache the window size computation. Examples -------- >>> df = pl.DataFrame({"A": [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]}) >>> df.with_columns( ... rolling_max=pl.col("A").rolling_max(window_size=2), ... ) shape: (6, 2) ┌─────┬─────────────┠│ A ┆ rolling_max │ │ --- ┆ --- │ │ f64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1.0 ┆ null │ │ 2.0 ┆ 2.0 │ │ 3.0 ┆ 3.0 │ │ 4.0 ┆ 4.0 │ │ 5.0 ┆ 5.0 │ │ 6.0 ┆ 6.0 │ └─────┴─────────────┘ Specify weights to multiply the values in the window with: >>> df.with_columns( ... rolling_max=pl.col("A").rolling_max( ... window_size=2, weights=[0.25, 0.75] ... ), ... ) shape: (6, 2) ┌─────┬─────────────┠│ A ┆ rolling_max │ │ --- ┆ --- │ │ f64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1.0 ┆ null │ │ 2.0 ┆ 1.5 │ │ 3.0 ┆ 2.25 │ │ 4.0 ┆ 3.0 │ │ 5.0 ┆ 3.75 │ │ 6.0 ┆ 4.5 │ └─────┴─────────────┘ Center the values in the window >>> df.with_columns( ... rolling_max=pl.col("A").rolling_max(window_size=3, center=True), ... ) shape: (6, 2) ┌─────┬─────────────┠│ A ┆ rolling_max │ │ --- ┆ --- │ │ f64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1.0 ┆ null │ │ 2.0 ┆ 3.0 │ │ 3.0 ┆ 4.0 │ │ 4.0 ┆ 5.0 │ │ 5.0 ┆ 6.0 │ │ 6.0 ┆ null │ └─────┴─────────────┘ )r$rdÚ rolling_maxr¬s rur°ÚExpr.rolling_max›ó0€ôJØ L‰L× $Ñ $ØØØØó  ó ð rxcóP•[URRUUUU55$)u) Apply a rolling mean (moving mean) over the values in this array. A window of length `window_size` will traverse the array. The values that fill this window will (optionally) be multiplied with the weights given by the `weights` vector. The resulting values will be aggregated to their mean. Weights are normalized to sum to 1. The window at a given row will include the row itself, and the `window_size - 1` elements before it. .. versionchanged:: 1.21.0 The `min_periods` parameter was renamed `min_samples`. Parameters ---------- window_size The length of the window in number of elements. weights An optional slice with the same length as the window that will be multiplied elementwise with the values in the window, after being normalized to sum to 1. min_samples The number of values in the window that should be non-null before computing a result. If set to `None` (default), it will be set equal to `window_size`. center Set the labels at the center of the window. Notes ----- If you want to compute multiple aggregation statistics over the same dynamic window, consider using `rolling` - this method can cache the window size computation. Examples -------- >>> df = pl.DataFrame({"A": [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]}) >>> df.with_columns( ... rolling_mean=pl.col("A").rolling_mean(window_size=2), ... ) shape: (6, 2) ┌─────┬──────────────┠│ A ┆ rolling_mean │ │ --- ┆ --- │ │ f64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1.0 ┆ null │ │ 2.0 ┆ 1.5 │ │ 3.0 ┆ 2.5 │ │ 4.0 ┆ 3.5 │ │ 5.0 ┆ 4.5 │ │ 6.0 ┆ 5.5 │ └─────┴──────────────┘ Specify weights to multiply the values in the window with: >>> df.with_columns( ... rolling_mean=pl.col("A").rolling_mean( ... window_size=2, weights=[0.25, 0.75] ... ), ... ) shape: (6, 2) ┌─────┬──────────────┠│ A ┆ rolling_mean │ │ --- ┆ --- │ │ f64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1.0 ┆ null │ │ 2.0 ┆ 1.75 │ │ 3.0 ┆ 2.75 │ │ 4.0 ┆ 3.75 │ │ 5.0 ┆ 4.75 │ │ 6.0 ┆ 5.75 │ └─────┴──────────────┘ Center the values in the window >>> df.with_columns( ... rolling_mean=pl.col("A").rolling_mean(window_size=3, center=True), ... ) shape: (6, 2) ┌─────┬──────────────┠│ A ┆ rolling_mean │ │ --- ┆ --- │ │ f64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1.0 ┆ null │ │ 2.0 ┆ 2.0 │ │ 3.0 ┆ 3.0 │ │ 4.0 ┆ 4.0 │ │ 5.0 ┆ 5.0 │ │ 6.0 ┆ null │ └─────┴──────────────┘ )r$rdÚ rolling_meanr¬s rur´ÚExpr.rolling_mean s0€ôNØ L‰L× %Ñ %ØØØØó  ó ð rxcóP•[URRUUUU55$)už Apply a rolling sum (moving sum) over the values in this array. A window of length `window_size` will traverse the array. The values that fill this window will (optionally) be multiplied with the weights given by the `weights` vector. The resulting values will be aggregated to their sum. The window at a given row will include the row itself, and the `window_size - 1` elements before it. .. versionchanged:: 1.21.0 The `min_periods` parameter was renamed `min_samples`. Parameters ---------- window_size The length of the window in number of elements. weights An optional slice with the same length as the window that will be multiplied elementwise with the values in the window. min_samples The number of values in the window that should be non-null before computing a result. If set to `None` (default), it will be set equal to `window_size`. center Set the labels at the center of the window. Notes ----- If you want to compute multiple aggregation statistics over the same dynamic window, consider using `rolling` - this method can cache the window size computation. Examples -------- >>> df = pl.DataFrame({"A": [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]}) >>> df.with_columns( ... rolling_sum=pl.col("A").rolling_sum(window_size=2), ... ) shape: (6, 2) ┌─────┬─────────────┠│ A ┆ rolling_sum │ │ --- ┆ --- │ │ f64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1.0 ┆ null │ │ 2.0 ┆ 3.0 │ │ 3.0 ┆ 5.0 │ │ 4.0 ┆ 7.0 │ │ 5.0 ┆ 9.0 │ │ 6.0 ┆ 11.0 │ └─────┴─────────────┘ Specify weights to multiply the values in the window with: >>> df.with_columns( ... rolling_sum=pl.col("A").rolling_sum( ... window_size=2, weights=[0.25, 0.75] ... ), ... ) shape: (6, 2) ┌─────┬─────────────┠│ A ┆ rolling_sum │ │ --- ┆ --- │ │ f64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1.0 ┆ null │ │ 2.0 ┆ 1.75 │ │ 3.0 ┆ 2.75 │ │ 4.0 ┆ 3.75 │ │ 5.0 ┆ 4.75 │ │ 6.0 ┆ 5.75 │ └─────┴─────────────┘ Center the values in the window >>> df.with_columns( ... rolling_sum=pl.col("A").rolling_sum(window_size=3, center=True), ... ) shape: (6, 2) ┌─────┬─────────────┠│ A ┆ rolling_sum │ │ --- ┆ --- │ │ f64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1.0 ┆ null │ │ 2.0 ┆ 6.0 │ │ 3.0 ┆ 9.0 │ │ 4.0 ┆ 12.0 │ │ 5.0 ┆ 15.0 │ │ 6.0 ┆ null │ └─────┴─────────────┘ )r$rdÚ rolling_sumr¬s rur·ÚExpr.rolling_sumyr²rx)r‰r¨rCc óN•[URRUUUUUS95$)u" Compute a rolling standard deviation. A window of length `window_size` will traverse the array. The values that fill this window will (optionally) be multiplied with the weights given by the `weights` vector. The resulting values will be aggregated to their std. Weights are normalized to sum to 1. The window at a given row will include the row itself, and the `window_size - 1` elements before it. .. versionchanged:: 1.21.0 The `min_periods` parameter was renamed `min_samples`. Parameters ---------- window_size The length of the window in number of elements. weights An optional slice with the same length as the window that will be multiplied elementwise with the values in the window after being normalized to sum to 1. min_samples The number of values in the window that should be non-null before computing a result. If set to `None` (default), it will be set equal to `window_size`. center Set the labels at the center of the window. ddof "Delta Degrees of Freedom": The divisor for a length N window is N - ddof Notes ----- If you want to compute multiple aggregation statistics over the same dynamic window, consider using `rolling` - this method can cache the window size computation. Examples -------- >>> df = pl.DataFrame({"A": [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]}) >>> df.with_columns( ... rolling_std=pl.col("A").rolling_std(window_size=2), ... ) shape: (6, 2) ┌─────┬─────────────┠│ A ┆ rolling_std │ │ --- ┆ --- │ │ f64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1.0 ┆ null │ │ 2.0 ┆ 0.707107 │ │ 3.0 ┆ 0.707107 │ │ 4.0 ┆ 0.707107 │ │ 5.0 ┆ 0.707107 │ │ 6.0 ┆ 0.707107 │ └─────┴─────────────┘ Specify weights to multiply the values in the window with: >>> df.with_columns( ... rolling_std=pl.col("A").rolling_std( ... window_size=2, weights=[0.25, 0.75] ... ), ... ) shape: (6, 2) ┌─────┬─────────────┠│ A ┆ rolling_std │ │ --- ┆ --- │ │ f64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1.0 ┆ null │ │ 2.0 ┆ 0.433013 │ │ 3.0 ┆ 0.433013 │ │ 4.0 ┆ 0.433013 │ │ 5.0 ┆ 0.433013 │ │ 6.0 ┆ 0.433013 │ └─────┴─────────────┘ Center the values in the window >>> df.with_columns( ... rolling_std=pl.col("A").rolling_std(window_size=3, center=True), ... ) shape: (6, 2) ┌─────┬─────────────┠│ A ┆ rolling_std │ │ --- ┆ --- │ │ f64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1.0 ┆ null │ │ 2.0 ┆ 1.0 │ │ 3.0 ┆ 1.0 │ │ 4.0 ┆ 1.0 │ │ 5.0 ┆ 1.0 │ │ 6.0 ┆ null │ └─────┴─────────────┘ ©r¨rC)r$rdÚ rolling_std©r}rŽr­r‰r¨rCs rur»ÚExpr.rolling_stdçó8€ôTØ L‰L× $Ñ $ØØØØØð %ð ó ð rxc óN•[URRUUUUUS95$)u Compute a rolling variance. A window of length `window_size` will traverse the array. The values that fill this window will (optionally) be multiplied with the weights given by the `weights` vector. The resulting values will be aggregated to their var. Weights are normalized to sum to 1. The window at a given row will include the row itself, and the `window_size - 1` elements before it. .. versionchanged:: 1.21.0 The `min_periods` parameter was renamed `min_samples`. Parameters ---------- window_size The length of the window in number of elements. weights An optional slice with the same length as the window that will be multiplied elementwise with the values in the window after being normalized to sum to 1. min_samples The number of values in the window that should be non-null before computing a result. If set to `None` (default), it will be set equal to `window_size`. center Set the labels at the center of the window. ddof "Delta Degrees of Freedom": The divisor for a length N window is N - ddof Notes ----- If you want to compute multiple aggregation statistics over the same dynamic window, consider using `rolling` - this method can cache the window size computation. Examples -------- >>> df = pl.DataFrame({"A": [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]}) >>> df.with_columns( ... rolling_var=pl.col("A").rolling_var(window_size=2), ... ) shape: (6, 2) ┌─────┬─────────────┠│ A ┆ rolling_var │ │ --- ┆ --- │ │ f64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1.0 ┆ null │ │ 2.0 ┆ 0.5 │ │ 3.0 ┆ 0.5 │ │ 4.0 ┆ 0.5 │ │ 5.0 ┆ 0.5 │ │ 6.0 ┆ 0.5 │ └─────┴─────────────┘ Specify weights to multiply the values in the window with: >>> df.with_columns( ... rolling_var=pl.col("A").rolling_var( ... window_size=2, weights=[0.25, 0.75] ... ), ... ) shape: (6, 2) ┌─────┬─────────────┠│ A ┆ rolling_var │ │ --- ┆ --- │ │ f64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1.0 ┆ null │ │ 2.0 ┆ 0.1875 │ │ 3.0 ┆ 0.1875 │ │ 4.0 ┆ 0.1875 │ │ 5.0 ┆ 0.1875 │ │ 6.0 ┆ 0.1875 │ └─────┴─────────────┘ Center the values in the window >>> df.with_columns( ... rolling_var=pl.col("A").rolling_var(window_size=3, center=True), ... ) shape: (6, 2) ┌─────┬─────────────┠│ A ┆ rolling_var │ │ --- ┆ --- │ │ f64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1.0 ┆ null │ │ 2.0 ┆ 1.0 │ │ 3.0 ┆ 1.0 │ │ 4.0 ┆ 1.0 │ │ 5.0 ┆ 1.0 │ │ 6.0 ┆ null │ └─────┴─────────────┘ rº)r$rdÚ rolling_varr¼s rurÀÚExpr.rolling_var[r¾rxc óL•[URRUUUUS95$)u# Compute a rolling median. A window of length `window_size` will traverse the array. The values that fill this window will (optionally) be multiplied with the weights given by the `weights` vector. The resulting values will be aggregated to their median. The window at a given row will include the row itself, and the `window_size - 1` elements before it. .. versionchanged:: 1.21.0 The `min_periods` parameter was renamed `min_samples`. Parameters ---------- window_size The length of the window in number of elements. weights An optional slice with the same length as the window that will be multiplied elementwise with the values in the window. min_samples The number of values in the window that should be non-null before computing a result. If set to `None` (default), it will be set equal to `window_size`. center Set the labels at the center of the window. Notes ----- If you want to compute multiple aggregation statistics over the same dynamic window, consider using `rolling` - this method can cache the window size computation. Examples -------- >>> df = pl.DataFrame({"A": [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]}) >>> df.with_columns( ... rolling_median=pl.col("A").rolling_median(window_size=2), ... ) shape: (6, 2) ┌─────┬────────────────┠│ A ┆ rolling_median │ │ --- ┆ --- │ │ f64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1.0 ┆ null │ │ 2.0 ┆ 1.5 │ │ 3.0 ┆ 2.5 │ │ 4.0 ┆ 3.5 │ │ 5.0 ┆ 4.5 │ │ 6.0 ┆ 5.5 │ └─────┴────────────────┘ Specify weights for the values in each window: >>> df.with_columns( ... rolling_median=pl.col("A").rolling_median( ... window_size=2, weights=[0.25, 0.75] ... ), ... ) shape: (6, 2) ┌─────┬────────────────┠│ A ┆ rolling_median │ │ --- ┆ --- │ │ f64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1.0 ┆ null │ │ 2.0 ┆ 1.5 │ │ 3.0 ┆ 2.5 │ │ 4.0 ┆ 3.5 │ │ 5.0 ┆ 4.5 │ │ 6.0 ┆ 5.5 │ └─────┴────────────────┘ Center the values in the window >>> df.with_columns( ... rolling_median=pl.col("A").rolling_median(window_size=3, center=True), ... ) shape: (6, 2) ┌─────┬────────────────┠│ A ┆ rolling_median │ │ --- ┆ --- │ │ f64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1.0 ┆ null │ │ 2.0 ┆ 2.0 │ │ 3.0 ┆ 3.0 │ │ 4.0 ┆ 4.0 │ │ 5.0 ┆ 5.0 │ │ 6.0 ┆ null │ └─────┴────────────────┘ rª)r$rdÚrolling_medianr¬s rurÃÚExpr.rolling_medianÏs5€ôJØ L‰L× 'Ñ 'ØØØØð (ð ó ð rxc óP•[URRUUUUUUS95$)uÉ Compute a rolling quantile. A window of length `window_size` will traverse the array. The values that fill this window will (optionally) be multiplied with the weights given by the `weights` vector. The resulting values will be aggregated to their quantile. The window at a given row will include the row itself, and the `window_size - 1` elements before it. .. versionchanged:: 1.21.0 The `min_periods` parameter was renamed `min_samples`. Parameters ---------- quantile Quantile between 0.0 and 1.0. interpolation : {'nearest', 'higher', 'lower', 'midpoint', 'linear', 'equiprobable'} Interpolation method. window_size The length of the window in number of elements. weights An optional slice with the same length as the window that will be multiplied elementwise with the values in the window. min_samples The number of values in the window that should be non-null before computing a result. If set to `None` (default), it will be set equal to `window_size`. center Set the labels at the center of the window. Notes ----- If you want to compute multiple aggregation statistics over the same dynamic window, consider using `rolling` - this method can cache the window size computation. Examples -------- >>> df = pl.DataFrame({"A": [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]}) >>> df.with_columns( ... rolling_quantile=pl.col("A").rolling_quantile( ... quantile=0.25, window_size=4 ... ), ... ) shape: (6, 2) ┌─────┬──────────────────┠│ A ┆ rolling_quantile │ │ --- ┆ --- │ │ f64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1.0 ┆ null │ │ 2.0 ┆ null │ │ 3.0 ┆ null │ │ 4.0 ┆ 2.0 │ │ 5.0 ┆ 3.0 │ │ 6.0 ┆ 4.0 │ └─────┴──────────────────┘ Specify weights for the values in each window: >>> df.with_columns( ... rolling_quantile=pl.col("A").rolling_quantile( ... quantile=0.25, window_size=4, weights=[0.2, 0.4, 0.4, 0.2] ... ), ... ) shape: (6, 2) ┌─────┬──────────────────┠│ A ┆ rolling_quantile │ │ --- ┆ --- │ │ f64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1.0 ┆ null │ │ 2.0 ┆ null │ │ 3.0 ┆ null │ │ 4.0 ┆ 2.0 │ │ 5.0 ┆ 3.0 │ │ 6.0 ┆ 4.0 │ └─────┴──────────────────┘ Specify weights and interpolation method >>> df.with_columns( ... rolling_quantile=pl.col("A").rolling_quantile( ... quantile=0.25, ... window_size=4, ... weights=[0.2, 0.4, 0.4, 0.2], ... interpolation="linear", ... ), ... ) shape: (6, 2) ┌─────┬──────────────────┠│ A ┆ rolling_quantile │ │ --- ┆ --- │ │ f64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1.0 ┆ null │ │ 2.0 ┆ null │ │ 3.0 ┆ null │ │ 4.0 ┆ 1.625 │ │ 5.0 ┆ 2.625 │ │ 6.0 ┆ 3.625 │ └─────┴──────────────────┘ Center the values in the window >>> df.with_columns( ... rolling_quantile=pl.col("A").rolling_quantile( ... quantile=0.2, window_size=5, center=True ... ), ... ) shape: (6, 2) ┌─────┬──────────────────┠│ A ┆ rolling_quantile │ │ --- ┆ --- │ │ f64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1.0 ┆ null │ │ 2.0 ┆ null │ │ 3.0 ┆ 2.0 │ │ 4.0 ┆ 3.0 │ │ 5.0 ┆ null │ │ 6.0 ┆ null │ └─────┴──────────────────┘ rª)r$rdÚrolling_quantile)r}r¥r¦rŽr­r‰r¨s rurÆÚExpr.rolling_quantile= s;€ôNØ L‰L× )Ñ )ØØØØØØð *ð ó  ð rx)Úbiasr‰r¨c óH•[URRXX4S95$)u¶ Compute a rolling skew. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. The window at a given row will include the row itself, and the `window_size - 1` elements before it. Parameters ---------- window_size Integer size of the rolling window. bias If False, the calculations are corrected for statistical bias. bias: bool = True, min_samples The number of values in the window that should be non-null before computing a result. If set to `None` (default), it will be set equal to `window_size`. center Set the labels at the center of the window. See Also -------- Expr.skew Examples -------- >>> df = pl.DataFrame({"a": [1, 4, 2, 9]}) >>> df.select(pl.col("a").rolling_skew(3)) shape: (4, 1) ┌──────────┠│ a │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•â•â•â•â•â•¡ │ null │ │ null │ │ 0.381802 │ │ 0.47033 │ └──────────┘ Note how the values match the following: >>> pl.Series([1, 4, 2]).skew(), pl.Series([4, 2, 9]).skew() (0.38180177416060584, 0.47033046033698594) )rÈrˆr¨)r$rdÚ rolling_skew)r}rŽrÈr‰r¨s rurÊÚExpr.rolling_skewÏ s.€ôrØ L‰L× %Ñ %Ø°Kð &ð ó ð rx)ÚfisherrÈr‰r¨c óN•[URRUUUUUS95$)up Compute a rolling kurtosis. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. The window at a given row will include the row itself, and the `window_size - 1` elements before it. Parameters ---------- window_size Integer size of the rolling window. fisher : bool, optional If True, Fisher's definition is used (normal ==> 0.0). If False, Pearson's definition is used (normal ==> 3.0). bias : bool, optional If False, the calculations are corrected for statistical bias. min_samples The number of values in the window that should be non-null before computing a result. If set to `None` (default), it will be set equal to `window_size`. center Set the labels at the center of the window. See Also -------- Expr.kurtosis Examples -------- >>> df = pl.DataFrame({"a": [1, 4, 2, 9]}) >>> df.select(pl.col("a").rolling_kurtosis(3)) shape: (4, 1) ┌──────┠│ a │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•â•¡ │ null │ │ null │ │ -1.5 │ │ -1.5 │ └──────┘ )rÌrÈrˆr¨)r$rdÚrolling_kurtosis)r}rŽrÌrÈr‰r¨s rurÎÚExpr.rolling_kurtosis!s8€ônØ L‰L× )Ñ )ØØØØ'Øð *ð ó ð rxc ój^•UcUnSU4Sjjn[URRXbX4U55$)u  Compute a custom rolling window function. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. .. versionchanged:: 1.21.0 The `min_periods` parameter was renamed `min_samples`. Parameters ---------- function Custom aggregation function. window_size The length of the window in number of elements. weights An optional slice with the same length as the window that will be multiplied elementwise with the values in the window. min_samples The number of values in the window that should be non-null before computing a result. If set to `None` (default), it will be set equal to `window_size`. center Set the labels at the center of the window. Warnings -------- Computing custom functions is extremely slow. Use specialized rolling functions such as :func:`Expr.rolling_sum` if at all possible. Examples -------- >>> from numpy import nansum >>> df = pl.DataFrame({"a": [11.0, 2.0, 9.0, float("nan"), 8.0]}) >>> df.select(pl.col("a").rolling_map(nansum, window_size=3)) shape: (5, 1) ┌──────┠│ a │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•â•¡ │ null │ │ null │ │ 22.0 │ │ 11.0 │ │ 17.0 │ └──────┘ cóÂ>•[U5nT"U5n[U[R5(a UR$[R"U/5R$rp)r%r!rrGÚ_s)Úpysr+Úrvr2s €rurËÚExpr.rolling_map.._wrap!sEø€Üs“ ˆAÙ˜!“ˆBܘ"œbŸi™i×(Ñ(Ø—u‘u Ü—9’9˜b˜T“?×%Ñ%Ð %rx)rÓrBr5rB)r$rdÚ rolling_map)r}r2rŽr­r‰r¨rËs ` rurÖÚExpr.rolling_mapO!s;ø€ðv Ñ Ø%ˆK÷ &ôØ L‰L× $Ñ $ U¸ÈvÓ Vó ð rxcóH•[URR55$)ua Compute absolute values. Same as `abs(expr)`. Examples -------- >>> df = pl.DataFrame( ... { ... "A": [-1.0, 0.0, 1.0, 2.0], ... } ... ) >>> df.select(pl.col("A").abs()) shape: (4, 1) ┌─────┠│ A │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•¡ │ 1.0 │ │ 0.0 │ │ 1.0 │ │ 2.0 │ └─────┘ )r$rdr–r|s rur–ÚExpr.abs˜!rYrx)rÝrmcóL•[URRXU55$)uˆ Assign ranks to data, dealing with ties appropriately. Parameters ---------- method : {'average', 'min', 'max', 'dense', 'ordinal', 'random'} The method used to assign ranks to tied elements. The following methods are available (default is 'average'): - 'average' : The average of the ranks that would have been assigned to all the tied values is assigned to each value. - 'min' : The minimum of the ranks that would have been assigned to all the tied values is assigned to each value. (This is also referred to as "competition" ranking.) - 'max' : The maximum of the ranks that would have been assigned to all the tied values is assigned to each value. - 'dense' : Like 'min', but the rank of the next highest element is assigned the rank immediately after those assigned to the tied elements. - 'ordinal' : All values are given a distinct rank, corresponding to the order that the values occur in the Series. - 'random' : Like 'ordinal', but the rank for ties is not dependent on the order that the values occur in the Series. descending Rank in descending order. seed If `method="random"`, use this as seed. Examples -------- The 'average' method: >>> df = pl.DataFrame({"a": [3, 6, 1, 1, 6]}) >>> df.select(pl.col("a").rank()) shape: (5, 1) ┌─────┠│ a │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•¡ │ 3.0 │ │ 4.5 │ │ 1.5 │ │ 1.5 │ │ 4.5 │ └─────┘ The 'ordinal' method: >>> df = pl.DataFrame({"a": [3, 6, 1, 1, 6]}) >>> df.select(pl.col("a").rank("ordinal")) shape: (5, 1) ┌─────┠│ a │ │ --- │ │ u32 │ â•žâ•â•â•â•â•â•¡ │ 3 │ │ 4 │ │ 1 │ │ 2 │ │ 5 │ └─────┘ Use 'rank' with 'over' to rank within groups: >>> df = pl.DataFrame({"a": [1, 1, 2, 2, 2], "b": [6, 7, 5, 14, 11]}) >>> df.with_columns(pl.col("b").rank().over("a").alias("rank")) shape: (5, 3) ┌─────┬─────┬──────┠│ a ┆ b ┆ rank │ │ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•¡ │ 1 ┆ 6 ┆ 1.0 │ │ 1 ┆ 7 ┆ 2.0 │ │ 2 ┆ 5 ┆ 1.0 │ │ 2 ┆ 14 ┆ 3.0 │ │ 2 ┆ 11 ┆ 2.0 │ └─────┴─────┴──────┘ Divide by the length or number of non-null values to compute the percentile rank. >>> df = pl.DataFrame({"a": [6, 7, None, 14, 11]}) >>> df.with_columns( ... pct=pl.col("a").rank() / pl.len(), ... pct_valid=pl.col("a").rank() / pl.count("a"), ... ) shape: (5, 3) ┌──────┬──────┬───────────┠│ a ┆ pct ┆ pct_valid │ │ --- ┆ --- ┆ --- │ │ i64 ┆ f64 ┆ f64 │ â•žâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•¡ │ 6 ┆ 0.2 ┆ 0.25 │ │ 7 ┆ 0.4 ┆ 0.5 │ │ null ┆ null ┆ null │ │ 14 ┆ 0.8 ┆ 1.0 │ │ 11 ┆ 0.6 ┆ 0.75 │ └──────┴──────┴───────────┘ )r$rdÚrank)r}r>rÝrms rurÛÚ Expr.rank´!s!€ô\˜Ÿ™×*Ñ*¨6¸tÓDÓEÐErxcó`•[U5n[URRX255$)u  Calculate the first discrete difference between shifted items. Parameters ---------- n Number of slots to shift. null_behavior : {'ignore', 'drop'} How to handle null values. Examples -------- >>> df = pl.DataFrame({"int": [20, 10, 30, 25, 35]}) >>> df.with_columns(change=pl.col("int").diff()) shape: (5, 2) ┌─────┬────────┠│ int ┆ change │ │ --- ┆ --- │ │ i64 ┆ i64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•¡ │ 20 ┆ null │ │ 10 ┆ -10 │ │ 30 ┆ 20 │ │ 25 ┆ -5 │ │ 35 ┆ 10 │ └─────┴────────┘ >>> df.with_columns(change=pl.col("int").diff(n=2)) shape: (5, 2) ┌─────┬────────┠│ int ┆ change │ │ --- ┆ --- │ │ i64 ┆ i64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•¡ │ 20 ┆ null │ │ 10 ┆ null │ │ 30 ┆ 10 │ │ 25 ┆ 15 │ │ 35 ┆ 5 │ └─────┴────────┘ >>> df.select(pl.col("int").diff(n=2, null_behavior="drop").alias("diff")) shape: (3, 1) ┌──────┠│ diff │ │ --- │ │ i64 │ â•žâ•â•â•â•â•â•â•¡ │ 10 │ │ 15 │ │ 5 │ └──────┘ )rr$rdÚdiff)r}r$Ú null_behaviorr&s rurÞÚ Expr.diff$"s)€ôp)¨Ó+ˆÜ˜Ÿ™×*Ñ*¨8ÓCÓDÐDrxcó`•[U5n[URRU55$)u— Computes percentage change between values. Percentage change (as fraction) between current element and most-recent non-null element at least `n` period(s) before the current element. Computes the change from the previous row by default. Parameters ---------- n periods to shift for forming percent change. Examples -------- >>> df = pl.DataFrame( ... { ... "a": [10, 11, 12, None, 12], ... } ... ) >>> df.with_columns(pl.col("a").pct_change().alias("pct_change")) shape: (5, 2) ┌──────┬────────────┠│ a ┆ pct_change │ │ --- ┆ --- │ │ i64 ┆ f64 │ â•žâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 10 ┆ null │ │ 11 ┆ 0.1 │ │ 12 ┆ 0.090909 │ │ null ┆ 0.0 │ │ 12 ┆ 0.0 │ └──────┴────────────┘ )rr$rdÚ pct_change)r}r$r&s rurâÚExpr.pct_change_"s)€ôF)¨Ó+ˆÜ˜Ÿ™×0Ñ0°Ó:Ó;Ð;rx)rÈcóJ•[URRU55$)uO Compute the sample skewness of a data set. For normally distributed data, the skewness should be about zero. For unimodal continuous distributions, a skewness value greater than zero means that there is more weight in the right tail of the distribution. The function `skewtest` can be used to determine if the skewness value is close enough to zero, statistically speaking. See scipy.stats for more information. Parameters ---------- bias : bool, optional If False, the calculations are corrected for statistical bias. Notes ----- The sample skewness is computed as the Fisher-Pearson coefficient of skewness, i.e. .. math:: g_1=\frac{m_3}{m_2^{3/2}} where .. math:: m_i=\frac{1}{N}\sum_{n=1}^N(x[n]-\bar{x})^i is the biased sample :math:`i\texttt{th}` central moment, and :math:`\bar{x}` is the sample mean. If `bias` is False, the calculations are corrected for bias and the value computed is the adjusted Fisher-Pearson standardized moment coefficient, i.e. .. math:: G_1 = \frac{k_3}{k_2^{3/2}} = \frac{\sqrt{N(N-1)}}{N-2}\frac{m_3}{m_2^{3/2}} Examples -------- >>> df = pl.DataFrame({"a": [1, 2, 3, 2, 1]}) >>> df.select(pl.col("a").skew()) shape: (1, 1) ┌──────────┠│ a │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•â•â•â•â•â•¡ │ 0.343622 │ └──────────┘ )r$rdÚskew)r}rÈs ruråÚ Expr.skew…"s€ôf˜Ÿ™×*Ñ*¨4Ó0Ó1Ð1rx)rÌrÈcóJ•[URRX55$)uË Compute the kurtosis (Fisher or Pearson) of a dataset. Kurtosis is the fourth central moment divided by the square of the variance. If Fisher's definition is used, then 3.0 is subtracted from the result to give 0.0 for a normal distribution. If bias is False then the kurtosis is calculated using k statistics to eliminate bias coming from biased moment estimators. See scipy.stats for more information Parameters ---------- fisher : bool, optional If True, Fisher's definition is used (normal ==> 0.0). If False, Pearson's definition is used (normal ==> 3.0). bias : bool, optional If False, the calculations are corrected for statistical bias. Examples -------- >>> df = pl.DataFrame({"a": [1, 2, 3, 2, 1]}) >>> df.select(pl.col("a").kurtosis()) shape: (1, 1) ┌───────────┠│ a │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•â•â•â•â•â•â•¡ │ -1.153061 │ └───────────┘ )r$rdÚkurtosis)r}rÌrÈs rurèÚ Expr.kurtosisº"s€ôB˜Ÿ™×.Ñ.¨vÓ<Ó=Ð=rxcóŽ•Ub [U5nOSnUb [U5nOSn[URRX455$)u\ Set values outside the given boundaries to the boundary value. Parameters ---------- lower_bound Lower bound. Accepts expression input. Non-expression inputs are parsed as literals. Strings are parsed as column names. upper_bound Upper bound. Accepts expression input. Non-expression inputs are parsed as literals. Strings are parsed as column names. See Also -------- when Notes ----- This method only works for numeric and temporal columns. To clip other data types, consider writing a `when-then-otherwise` expression. See :func:`when`. Examples -------- Specifying both a lower and upper bound: >>> df = pl.DataFrame({"a": [-50, 5, 50, None]}) >>> df.with_columns(clip=pl.col("a").clip(1, 10)) shape: (4, 2) ┌──────┬──────┠│ a ┆ clip │ │ --- ┆ --- │ │ i64 ┆ i64 │ â•žâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•¡ │ -50 ┆ 1 │ │ 5 ┆ 5 │ │ 50 ┆ 10 │ │ null ┆ null │ └──────┴──────┘ Specifying only a single bound: >>> df.with_columns(clip=pl.col("a").clip(upper_bound=10)) shape: (4, 2) ┌──────┬──────┠│ a ┆ clip │ │ --- ┆ --- │ │ i64 ┆ i64 │ â•žâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•¡ │ -50 ┆ -50 │ │ 5 ┆ 5 │ │ 50 ┆ 10 │ │ null ┆ null │ └──────┴──────┘ Using columns as bounds: >>> df = pl.DataFrame( ... {"a": [-50, 5, 50, None], "low": [10, 1, 0, 0], "up": [20, 4, 3, 2]} ... ) >>> df.with_columns(clip=pl.col("a").clip("low", "up")) shape: (4, 4) ┌──────┬─────┬─────┬──────┠│ a ┆ low ┆ up ┆ clip │ │ --- ┆ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ i64 ┆ i64 │ â•žâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•¡ │ -50 ┆ 10 ┆ 20 ┆ 10 │ │ 5 ┆ 1 ┆ 4 ┆ 4 │ │ 50 ┆ 0 ┆ 3 ┆ 3 │ │ null ┆ 0 ┆ 2 ┆ null │ └──────┴─────┴─────┴──────┘ N)rr$rdÚclip)r}r_r`rarbs rurëÚ Expr.clipÝ"sN€ðZ Ñ "Ü!6°{Ó!CÑ à!%Ð Ø Ñ "Ü!6°{Ó!CÑ à!%РܘŸ™×*Ñ*Ð+=ÓRÓSÐSrxcóH•[URR55$)u; Calculate the lower bound. Returns a unit Series with the lowest value possible for the dtype of this expression. Examples -------- >>> df = pl.DataFrame({"a": [1, 2, 3, 2, 1]}) >>> df.select(pl.col("a").lower_bound()) shape: (1, 1) ┌──────────────────────┠│ a │ │ --- │ │ i64 │ â•žâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ -9223372036854775808 │ └──────────────────────┘ )r$rdr_r|s rur_ÚExpr.lower_bound4#ó€ô(˜Ÿ™×1Ñ1Ó3Ó4Ð4rxcóH•[URR55$)u/ Calculate the upper bound. Returns a unit Series with the highest value possible for the dtype of this expression. Examples -------- >>> df = pl.DataFrame({"a": [1, 2, 3, 2, 1]}) >>> df.select(pl.col("a").upper_bound()) shape: (1, 1) ┌─────────────────────┠│ a │ │ --- │ │ i64 │ â•žâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 9223372036854775807 │ └─────────────────────┘ )r$rdr`r|s rur`ÚExpr.upper_boundJ#rïrxcóH•[URR55$)uY Compute the element-wise sign function on numeric types. The returned value is computed as follows: * -1 if x < 0. * 1 if x > 0. * x otherwise (typically 0, but could be NaN if the input is). Null values are preserved as-is, and the dtype of the input is preserved. Examples -------- >>> df = pl.DataFrame({"a": [-9.0, -0.0, 0.0, 4.0, float("nan"), None]}) >>> df.select(pl.col.a.sign()) shape: (6, 1) ┌──────┠│ a │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•â•¡ │ -1.0 │ │ -0.0 │ │ 0.0 │ │ 1.0 │ │ NaN │ │ null │ └──────┘ )r$rdÚsignr|s ruróÚ Expr.sign`#s€ô<˜Ÿ™×*Ñ*Ó,Ó-Ð-rxcóH•[URR55$)uJ Compute the element-wise value for the sine. Returns ------- Expr Expression of data type :class:`Float64`. Examples -------- >>> df = pl.DataFrame({"a": [0.0]}) >>> df.select(pl.col("a").sin()) shape: (1, 1) ┌─────┠│ a │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•¡ │ 0.0 │ └─────┘ )r$rdÚsinr|s ruröÚExpr.sin€#ó€ô,˜Ÿ™×)Ñ)Ó+Ó,Ð,rxcóH•[URR55$)uL Compute the element-wise value for the cosine. Returns ------- Expr Expression of data type :class:`Float64`. Examples -------- >>> df = pl.DataFrame({"a": [0.0]}) >>> df.select(pl.col("a").cos()) shape: (1, 1) ┌─────┠│ a │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•¡ │ 1.0 │ └─────┘ )r$rdÚcosr|s rurúÚExpr.cos˜#rørxcóH•[URR55$)uc Compute the element-wise value for the tangent. Returns ------- Expr Expression of data type :class:`Float64`. Examples -------- >>> df = pl.DataFrame({"a": [1.0]}) >>> df.select(pl.col("a").tan().round(2)) shape: (1, 1) ┌──────┠│ a │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•â•¡ │ 1.56 │ └──────┘ )r$rdÚtanr|s rurýÚExpr.tan°#rørxcóH•[URR55$)ue Compute the element-wise value for the cotangent. Returns ------- Expr Expression of data type :class:`Float64`. Examples -------- >>> df = pl.DataFrame({"a": [1.0]}) >>> df.select(pl.col("a").cot().round(2)) shape: (1, 1) ┌──────┠│ a │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•â•¡ │ 0.64 │ └──────┘ )r$rdÚcotr|s rurÚExpr.cotÈ#rørxcóH•[URR55$)u– Compute the element-wise value for the inverse sine. Returns ------- Expr Expression of data type :class:`Float64`. Examples -------- >>> df = pl.DataFrame({"a": [1.0]}) >>> df.select(pl.col("a").arcsin()) shape: (1, 1) ┌──────────┠│ a │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•â•â•â•â•â•¡ │ 1.570796 │ └──────────┘ )r$rdÚarcsinr|s rurÚ Expr.arcsinà#ó€ô,˜Ÿ™×,Ñ,Ó.Ó/Ð/rxcóH•[URR55$)u˜ Compute the element-wise value for the inverse cosine. Returns ------- Expr Expression of data type :class:`Float64`. Examples -------- >>> df = pl.DataFrame({"a": [0.0]}) >>> df.select(pl.col("a").arccos()) shape: (1, 1) ┌──────────┠│ a │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•â•â•â•â•â•¡ │ 1.570796 │ └──────────┘ )r$rdÚarccosr|s rurÚ Expr.arccosø#rrxcóH•[URR55$)u™ Compute the element-wise value for the inverse tangent. Returns ------- Expr Expression of data type :class:`Float64`. Examples -------- >>> df = pl.DataFrame({"a": [1.0]}) >>> df.select(pl.col("a").arctan()) shape: (1, 1) ┌──────────┠│ a │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•â•â•â•â•â•¡ │ 0.785398 │ └──────────┘ )r$rdÚarctanr|s rur Ú Expr.arctan$rrxcóH•[URR55$)u— Compute the element-wise value for the hyperbolic sine. Returns ------- Expr Expression of data type :class:`Float64`. Examples -------- >>> df = pl.DataFrame({"a": [1.0]}) >>> df.select(pl.col("a").sinh()) shape: (1, 1) ┌──────────┠│ a │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•â•â•â•â•â•¡ │ 1.175201 │ └──────────┘ )r$rdÚsinhr|s rur Ú Expr.sinh($rÆrxcóH•[URR55$)u™ Compute the element-wise value for the hyperbolic cosine. Returns ------- Expr Expression of data type :class:`Float64`. Examples -------- >>> df = pl.DataFrame({"a": [1.0]}) >>> df.select(pl.col("a").cosh()) shape: (1, 1) ┌──────────┠│ a │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•â•â•â•â•â•¡ │ 1.543081 │ └──────────┘ )r$rdÚcoshr|s rurÚ Expr.cosh@$rÆrxcóH•[URR55$)uš Compute the element-wise value for the hyperbolic tangent. Returns ------- Expr Expression of data type :class:`Float64`. Examples -------- >>> df = pl.DataFrame({"a": [1.0]}) >>> df.select(pl.col("a").tanh()) shape: (1, 1) ┌──────────┠│ a │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•â•â•â•â•â•¡ │ 0.761594 │ └──────────┘ )r$rdÚtanhr|s rurÚ Expr.tanhX$rÆrxcóH•[URR55$)u¢ Compute the element-wise value for the inverse hyperbolic sine. Returns ------- Expr Expression of data type :class:`Float64`. Examples -------- >>> df = pl.DataFrame({"a": [1.0]}) >>> df.select(pl.col("a").arcsinh()) shape: (1, 1) ┌──────────┠│ a │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•â•â•â•â•â•¡ │ 0.881374 │ └──────────┘ )r$rdÚarcsinhr|s rurÚ Expr.arcsinhp$r rxcóH•[URR55$)uc Compute the element-wise value for the inverse hyperbolic cosine. Returns ------- Expr Expression of data type :class:`Float64`. Examples -------- >>> df = pl.DataFrame({"a": [1.0]}) >>> df.select(pl.col("a").arccosh()) shape: (1, 1) ┌─────┠│ a │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•¡ │ 0.0 │ └─────┘ )r$rdÚarccoshr|s rurÚ Expr.arccoshˆ$r rxcóH•[URR55$)ud Compute the element-wise value for the inverse hyperbolic tangent. Returns ------- Expr Expression of data type :class:`Float64`. Examples -------- >>> df = pl.DataFrame({"a": [1.0]}) >>> df.select(pl.col("a").arctanh()) shape: (1, 1) ┌─────┠│ a │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•¡ │ inf │ └─────┘ )r$rdÚarctanhr|s rurÚ Expr.arctanh $r rxcóH•[URR55$)u Convert from radians to degrees. Returns ------- Expr Expression of data type :class:`Float64`. Examples -------- >>> import math >>> df = pl.DataFrame({"a": [x * math.pi for x in range(-4, 5)]}) >>> df.select(pl.col("a").degrees()) shape: (9, 1) ┌────────┠│ a │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•â•â•â•¡ │ -720.0 │ │ -540.0 │ │ -360.0 │ │ -180.0 │ │ 0.0 │ │ 180.0 │ │ 360.0 │ │ 540.0 │ │ 720.0 │ └────────┘ )r$rdÚdegreesr|s rurÚ Expr.degrees¸$s€ô>˜Ÿ™×-Ñ-Ó/Ó0Ð0rxcóH•[URR55$)u_ Convert from degrees to radians. Returns ------- Expr Expression of data type :class:`Float64`. Examples -------- >>> df = pl.DataFrame({"a": [-720, -540, -360, -180, 0, 180, 360, 540, 720]}) >>> df.select(pl.col("a").radians()) shape: (9, 1) ┌────────────┠│ a │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ -12.566371 │ │ -9.424778 │ │ -6.283185 │ │ -3.141593 │ │ 0.0 │ │ 3.141593 │ │ 6.283185 │ │ 9.424778 │ │ 12.566371 │ └────────────┘ )r$rdÚradiansr|s rur"Ú Expr.radiansÙ$s€ô<˜Ÿ™×-Ñ-Ó/Ó0Ð0rxcóJ•[URRU55$)u½ Reshape this Expr to a flat column or an Array column. Parameters ---------- dimensions Tuple of the dimension sizes. If a -1 is used in any of the dimensions, that dimension is inferred. Returns ------- Expr If a single dimension is given, results in an expression of the original data type. If a multiple dimensions are given, results in an expression of data type :class:`Array` with shape `dimensions`. Examples -------- >>> df = pl.DataFrame({"foo": [1, 2, 3, 4, 5, 6, 7, 8, 9]}) >>> square = df.select(pl.col("foo").reshape((3, 3))) >>> square shape: (3, 1) ┌───────────────┠│ foo │ │ --- │ │ array[i64, 3] │ â•žâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ [1, 2, 3] │ │ [4, 5, 6] │ │ [7, 8, 9] │ └───────────────┘ >>> square.select(pl.col("foo").reshape((9,))) shape: (9, 1) ┌─────┠│ foo │ │ --- │ │ i64 │ â•žâ•â•â•â•â•â•¡ │ 1 │ │ 2 │ │ 3 │ │ 4 │ │ 5 │ │ 6 │ │ 7 │ │ 8 │ │ 9 │ └─────┘ See Also -------- Expr.list.explode : Explode a list column. )r$rdÚreshape)r}Ú dimensionss rur%Ú Expr.reshapeù$s€ôn˜Ÿ™×-Ñ-¨jÓ9Ó:Ð:rxcóJ•[URRU55$)uR Shuffle the contents of this expression. Note this is shuffled independently of any other column or Expression. If you want each row to stay the same use df.sample(shuffle=True) Parameters ---------- seed Seed for the random number generator. If set to None (default), a random seed is generated each time the shuffle is called. Examples -------- >>> df = pl.DataFrame({"a": [1, 2, 3]}) >>> df.select(pl.col("a").shuffle(seed=1)) shape: (3, 1) ┌─────┠│ a │ │ --- │ │ i64 │ â•žâ•â•â•â•â•â•¡ │ 2 │ │ 3 │ │ 1 │ └─────┘ )r$rdÚshuffle)r}rms rur)Ú Expr.shuffle2%s€ô8˜Ÿ™×-Ñ-¨dÓ3Ó4Ð4rx)ÚfractionÚwith_replacementr)rmcóø•UbUb Sn[U5eUb0[U5n[URR XsXE55$UcSn[U5n[URR XƒXE55$)uý Sample from this expression. Parameters ---------- n Number of items to return. Cannot be used with `fraction`. Defaults to 1 if `fraction` is None. fraction Fraction of items to return. Cannot be used with `n`. with_replacement Allow values to be sampled more than once. shuffle Shuffle the order of sampled data points. seed Seed for the random number generator. If set to None (default), a random seed is generated for each sample operation. Examples -------- >>> df = pl.DataFrame({"a": [1, 2, 3]}) >>> df.select(pl.col("a").sample(fraction=1.0, with_replacement=True, seed=1)) shape: (3, 1) ┌─────┠│ a │ │ --- │ │ i64 │ â•žâ•â•â•â•â•â•¡ │ 3 │ │ 3 │ │ 1 │ └─────┘ z&cannot specify both `n` and `fraction`r)rRrr$rdÚ sample_fracÚsample_n) r}r$r+r,r)rmr’Úfraction_pyexprr&s ruÚsampleÚ Expr.sampleP%s‰€ðT ‰=˜XÑ1Ø:ˆCܘS“/Ð !à Ñ Ü3°HÓ=ˆOÜØ— ‘ ×(Ñ(Ø#°wóóð ð ‰9؈AÜ(¨Ó+ˆÜØ L‰L× !Ñ ! (¸gÓ Ló ð rx)ÚcomÚspanÚ half_lifeÚalphaÚadjustr‰rZcód•[XX45n[URRXEXg55$)u¼ Compute exponentially-weighted moving average. .. versionchanged:: 1.21.0 The `min_periods` parameter was renamed `min_samples`. Parameters ---------- com Specify decay in terms of center of mass, :math:`\gamma`, with .. math:: \alpha = \frac{1}{1 + \gamma} \; \forall \; \gamma \geq 0 span Specify decay in terms of span, :math:`\theta`, with .. math:: \alpha = \frac{2}{\theta + 1} \; \forall \; \theta \geq 1 half_life Specify decay in terms of half-life, :math:`\tau`, with .. math:: \alpha = 1 - \exp \left\{ \frac{ -\ln(2) }{ \tau } \right\} \; \forall \; \tau > 0 alpha Specify smoothing factor alpha directly, :math:`0 < \alpha \leq 1`. adjust Divide by decaying adjustment factor in beginning periods to account for imbalance in relative weightings - When `adjust=True` (the default) the EW function is calculated using weights :math:`w_i = (1 - \alpha)^i` - When `adjust=False` the EW function is calculated recursively by .. math:: y_0 &= x_0 \\ y_t &= (1 - \alpha)y_{t - 1} + \alpha x_t min_samples Minimum number of observations in window required to have a value (otherwise result is null). ignore_nulls Ignore missing values when calculating weights. - When `ignore_nulls=False` (default), weights are based on absolute positions. For example, the weights of :math:`x_0` and :math:`x_2` used in calculating the final weighted average of [:math:`x_0`, None, :math:`x_2`] are :math:`(1-\alpha)^2` and :math:`1` if `adjust=True`, and :math:`(1-\alpha)^2` and :math:`\alpha` if `adjust=False`. - When `ignore_nulls=True`, weights are based on relative positions. For example, the weights of :math:`x_0` and :math:`x_2` used in calculating the final weighted average of [:math:`x_0`, None, :math:`x_2`] are :math:`1-\alpha` and :math:`1` if `adjust=True`, and :math:`1-\alpha` and :math:`\alpha` if `adjust=False`. Examples -------- >>> df = pl.DataFrame({"a": [1, 2, 3]}) >>> df.select(pl.col("a").ewm_mean(com=1, ignore_nulls=False)) shape: (3, 1) ┌──────────┠│ a │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•â•â•â•â•â•¡ │ 1.0 │ │ 1.666667 │ │ 2.428571 │ └──────────┘ )Ú_prepare_alphar$rdÚewm_mean)r}r3r4r5r6r7r‰rZs rur:Ú Expr.ewm_mean%s2€ôl˜s¨)Ó;ˆÜØ L‰L× !Ñ ! %°Ó Kó ð rxcóv•[U5n[U5n[URR X255$)uë Compute time-based exponentially weighted moving average. Given observations :math:`x_0, x_1, \ldots, x_{n-1}` at times :math:`t_0, t_1, \ldots, t_{n-1}`, the EWMA is calculated as .. math:: y_0 &= x_0 \alpha_i &= 1 - \exp \left\{ \frac{ -\ln(2)(t_i-t_{i-1}) } { \tau } \right\} y_i &= \alpha_i x_i + (1 - \alpha_i) y_{i-1}; \quad i > 0 where :math:`\tau` is the `half_life`. Parameters ---------- by Times to calculate average by. Should be ``DateTime``, ``Date``, ``UInt64``, ``UInt32``, ``Int64``, or ``Int32`` data type. half_life Unit over which observation decays to half its value. Can be created either from a timedelta, or by using the following string language: - 1ns (1 nanosecond) - 1us (1 microsecond) - 1ms (1 millisecond) - 1s (1 second) - 1m (1 minute) - 1h (1 hour) - 1d (1 day) - 1w (1 week) - 1i (1 index count) Or combine them: "3d12h4m25s" # 3 days, 12 hours, 4 minutes, and 25 seconds Note that `half_life` is treated as a constant duration - calendar durations such as months (or even days in the time-zone-aware case) are not supported, please express your duration in an approximately equivalent number of hours (e.g. '370h' instead of '1mo'). Returns ------- Expr Float32 if input is Float32, otherwise Float64. Examples -------- >>> from datetime import date, timedelta >>> df = pl.DataFrame( ... { ... "values": [0, 1, 2, None, 4], ... "times": [ ... date(2020, 1, 1), ... date(2020, 1, 3), ... date(2020, 1, 10), ... date(2020, 1, 15), ... date(2020, 1, 17), ... ], ... } ... ).sort("times") >>> df.with_columns( ... result=pl.col("values").ewm_mean_by("times", half_life="4d"), ... ) shape: (5, 3) ┌────────┬────────────┬──────────┠│ values ┆ times ┆ result │ │ --- ┆ --- ┆ --- │ │ i64 ┆ date ┆ f64 │ â•žâ•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•¡ │ 0 ┆ 2020-01-01 ┆ 0.0 │ │ 1 ┆ 2020-01-03 ┆ 0.292893 │ │ 2 ┆ 2020-01-10 ┆ 1.492474 │ │ null ┆ 2020-01-15 ┆ null │ │ 4 ┆ 2020-01-17 ┆ 3.254508 │ └────────┴────────────┴──────────┘ )rrr$rdÚ ewm_mean_by)r}rîr5røs rur=ÚExpr.ewm_mean_byè%s3€ôp*¨"Ó-ˆ Ü,¨YÓ7ˆ ܘŸ™×1Ñ1°)ÓGÓHÐHrx)r3r4r5r6r7rÈr‰rZc óf•[XX45n[URRXEXgU55$)u/ Compute exponentially-weighted moving standard deviation. .. versionchanged:: 1.21.0 The `min_periods` parameter was renamed `min_samples`. Parameters ---------- com Specify decay in terms of center of mass, :math:`\gamma`, with .. math:: \alpha = \frac{1}{1 + \gamma} \; \forall \; \gamma \geq 0 span Specify decay in terms of span, :math:`\theta`, with .. math:: \alpha = \frac{2}{\theta + 1} \; \forall \; \theta \geq 1 half_life Specify decay in terms of half-life, :math:`\lambda`, with .. math:: \alpha = 1 - \exp \left\{ \frac{ -\ln(2) }{ \lambda } \right\} \; \forall \; \lambda > 0 alpha Specify smoothing factor alpha directly, :math:`0 < \alpha \leq 1`. adjust Divide by decaying adjustment factor in beginning periods to account for imbalance in relative weightings - When `adjust=True` (the default) the EW function is calculated using weights :math:`w_i = (1 - \alpha)^i` - When `adjust=False` the EW function is calculated recursively by .. math:: y_0 &= x_0 \\ y_t &= (1 - \alpha)y_{t - 1} + \alpha x_t bias When `bias=False`, apply a correction to make the estimate statistically unbiased. min_samples Minimum number of observations in window required to have a value (otherwise result is null). ignore_nulls Ignore missing values when calculating weights. - When `ignore_nulls=False` (default), weights are based on absolute positions. For example, the weights of :math:`x_0` and :math:`x_2` used in calculating the final weighted average of [:math:`x_0`, None, :math:`x_2`] are :math:`(1-\alpha)^2` and :math:`1` if `adjust=True`, and :math:`(1-\alpha)^2` and :math:`\alpha` if `adjust=False`. - When `ignore_nulls=True`, weights are based on relative positions. For example, the weights of :math:`x_0` and :math:`x_2` used in calculating the final weighted average of [:math:`x_0`, None, :math:`x_2`] are :math:`1-\alpha` and :math:`1` if `adjust=True`, and :math:`1-\alpha` and :math:`\alpha` if `adjust=False`. Examples -------- >>> df = pl.DataFrame({"a": [1, 2, 3]}) >>> df.select(pl.col("a").ewm_std(com=1, ignore_nulls=False)) shape: (3, 1) ┌──────────┠│ a │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•â•â•â•â•â•¡ │ 0.0 │ │ 0.707107 │ │ 0.963624 │ └──────────┘ )r9r$rdÚewm_std© r}r3r4r5r6r7rÈr‰rZs rur@Ú Expr.ewm_stdD&ó4€ôt˜s¨)Ó;ˆÜØ L‰L× Ñ  °À<Ó Pó ð rxc óf•[XX45n[URRXEXgU55$)u% Compute exponentially-weighted moving variance. .. versionchanged:: 1.21.0 The `min_periods` parameter was renamed `min_samples`. Parameters ---------- com Specify decay in terms of center of mass, :math:`\gamma`, with .. math:: \alpha = \frac{1}{1 + \gamma} \; \forall \; \gamma \geq 0 span Specify decay in terms of span, :math:`\theta`, with .. math:: \alpha = \frac{2}{\theta + 1} \; \forall \; \theta \geq 1 half_life Specify decay in terms of half-life, :math:`\lambda`, with .. math:: \alpha = 1 - \exp \left\{ \frac{ -\ln(2) }{ \lambda } \right\} \; \forall \; \lambda > 0 alpha Specify smoothing factor alpha directly, :math:`0 < \alpha \leq 1`. adjust Divide by decaying adjustment factor in beginning periods to account for imbalance in relative weightings - When `adjust=True` (the default) the EW function is calculated using weights :math:`w_i = (1 - \alpha)^i` - When `adjust=False` the EW function is calculated recursively by .. math:: y_0 &= x_0 \\ y_t &= (1 - \alpha)y_{t - 1} + \alpha x_t bias When `bias=False`, apply a correction to make the estimate statistically unbiased. min_samples Minimum number of observations in window required to have a value (otherwise result is null). ignore_nulls Ignore missing values when calculating weights. - When `ignore_nulls=False` (default), weights are based on absolute positions. For example, the weights of :math:`x_0` and :math:`x_2` used in calculating the final weighted average of [:math:`x_0`, None, :math:`x_2`] are :math:`(1-\alpha)^2` and :math:`1` if `adjust=True`, and :math:`(1-\alpha)^2` and :math:`\alpha` if `adjust=False`. - When `ignore_nulls=True`, weights are based on relative positions. For example, the weights of :math:`x_0` and :math:`x_2` used in calculating the final weighted average of [:math:`x_0`, None, :math:`x_2`] are :math:`1-\alpha` and :math:`1` if `adjust=True`, and :math:`1-\alpha` and :math:`\alpha` if `adjust=False`. Examples -------- >>> df = pl.DataFrame({"a": [1, 2, 3]}) >>> df.select(pl.col("a").ewm_var(com=1, ignore_nulls=False)) shape: (3, 1) ┌──────────┠│ a │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•â•â•â•â•â•¡ │ 0.0 │ │ 0.5 │ │ 0.928571 │ └──────────┘ )r9r$rdÚewm_varrAs rurEÚ Expr.ewm_var£&rCrxcót•[USS9n[U5n[URRX455$)u’ Extremely fast method for extending the Series with 'n' copies of a value. Parameters ---------- value A constant literal value or a unit expression with which to extend the expression result Series; can pass None to extend with nulls. n The number of additional values that will be added. Examples -------- >>> df = pl.DataFrame({"values": [1, 2, 3]}) >>> df.select((pl.col("values") - 1).extend_constant(99, n=2)) shape: (5, 1) ┌────────┠│ values │ │ --- │ │ i64 │ â•žâ•â•â•â•â•â•â•â•â•¡ │ 0 │ │ 1 │ │ 2 │ │ 99 │ │ 99 │ └────────┘ Tr›)rr$rdÚextend_constant)r}r-r$r0r&s rurHÚExpr.extend_constant's4€ô:-¨U¸tÑDˆ Ü(¨Ó+ˆÜ˜Ÿ™×5Ñ5°lÓMÓNÐNrx)râÚparallelrlÚ normalizecót•U=(d U(aSOSn[URRXX455$)u„ Count the occurrence of unique values. Parameters ---------- sort Sort the output by count, in descending order. If set to `False` (default), the order is non-deterministic. parallel Execute the computation in parallel. .. note:: This option should likely *not* be enabled in a `group_by` context, as the computation will already be parallelized per group. name Give the resulting count column a specific name; if `normalize` is True this defaults to "proportion", otherwise defaults to "count". normalize If True, the count is returned as the relative frequency of unique values normalized to 1.0. Returns ------- Expr Expression of type :class:`Struct`, mapping unique values to their count (or proportion). Examples -------- >>> df = pl.DataFrame( ... {"color": ["red", "blue", "red", "green", "blue", "blue"]} ... ) >>> df_count = df.select(pl.col("color").value_counts()) >>> df_count # doctest: +IGNORE_RESULT shape: (3, 1) ┌─────────────┠│ color │ │ --- │ │ struct[2] │ â•žâ•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ {"green",1} │ │ {"blue",3} │ │ {"red",2} │ └─────────────┘ >>> df_count.unnest("color") # doctest: +IGNORE_RESULT shape: (3, 2) ┌───────┬───────┠│ color ┆ count │ │ --- ┆ --- │ │ str ┆ u32 │ â•žâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•¡ │ green ┆ 1 │ │ blue ┆ 3 │ │ red ┆ 2 │ └───────┴───────┘ Sort the output by (descending) count, customize the field name, and normalize the count to its relative proportion (of 1.0). >>> df_count = df.select( ... pl.col("color").value_counts( ... name="fraction", ... normalize=True, ... sort=True, ... ) ... ) >>> df_count shape: (3, 1) ┌────────────────────┠│ color │ │ --- │ │ struct[2] │ â•žâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ {"blue",0.5} │ │ {"red",0.333333} │ │ {"green",0.166667} │ └────────────────────┘ >>> df_count.unnest("color") shape: (3, 2) ┌───────┬──────────┠│ color ┆ fraction │ │ --- ┆ --- │ │ str ┆ f64 │ â•žâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•¡ │ blue ┆ 0.5 │ │ red ┆ 0.333333 │ │ green ┆ 0.166667 │ └───────┴──────────┘ Ú proportionr™)r$rdÚ value_counts)r}rârJrlrKs rurNÚExpr.value_counts#'s/€ðF×?® ™ °wˆÜ˜Ÿ™×2Ñ2°4À4ÓSÓTÐTrxcóH•[URR55$)u Return a count of the unique values in the order of appearance. This method differs from `value_counts` in that it does not return the values, only the counts and might be faster Examples -------- >>> df = pl.DataFrame( ... { ... "id": ["a", "b", "b", "c", "c", "c"], ... } ... ) >>> df.select( ... [ ... pl.col("id").unique_counts(), ... ] ... ) shape: (3, 1) ┌─────┠│ id │ │ --- │ │ u32 │ â•žâ•â•â•â•â•â•¡ │ 1 │ │ 2 │ │ 3 │ └─────┘ )r$rdÚ unique_countsr|s rurQÚExpr.unique_counts‰'s€ô<˜Ÿ™×3Ñ3Ó5Ó6Ð6rxcó`•[U5n[URRU55$)u© Compute the logarithm to a given base. Parameters ---------- base Given base, defaults to `e` Examples -------- >>> df = pl.DataFrame({"a": [1, 2, 3]}) >>> df.select(pl.col("a").log(base=2)) shape: (3, 1) ┌──────────┠│ a │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•â•â•â•â•â•¡ │ 0.0 │ │ 1.0 │ │ 1.584963 │ └──────────┘ )rr$rdrnrøs rurnÚExpr.log©'s(€ô0,¨DÓ1ˆ ܘŸ™×)Ñ)¨+Ó6Ó7Ð7rxcóH•[URR55$)uÌ Compute the natural logarithm of each element plus one. This computes `log(1 + x)` but is more numerically stable for `x` close to zero. Examples -------- >>> df = pl.DataFrame({"a": [1, 2, 3]}) >>> df.select(pl.col("a").log1p()) shape: (3, 1) ┌──────────┠│ a │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•â•â•â•â•â•¡ │ 0.693147 │ │ 1.098612 │ │ 1.386294 │ └──────────┘ )r$rdÚlog1pr|s rurVÚ Expr.log1pÄ's€ô*˜Ÿ™×+Ñ+Ó-Ó.Ð.rx)rKcóJ•[URRX55$)u Computes the entropy. Uses the formula `-sum(pk * log(pk))` where `pk` are discrete probabilities. Parameters ---------- base Given base, defaults to `e` normalize Normalize pk if it doesn't sum to 1. Examples -------- >>> df = pl.DataFrame({"a": [1, 2, 3]}) >>> df.select(pl.col("a").entropy(base=2)) shape: (1, 1) ┌──────────┠│ a │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•â•â•â•â•â•¡ │ 1.459148 │ └──────────┘ >>> df.select(pl.col("a").entropy(base=2, normalize=False)) shape: (1, 1) ┌───────────┠│ a │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•â•â•â•â•â•â•¡ │ -6.754888 │ └───────────┘ )r$rdÚentropy)r}rùrKs rurYÚ Expr.entropyÛ's€ôF˜Ÿ™×-Ñ-¨dÓ>Ó?Ð?rx)r‰có`•[URRURU55$)uY Run an expression over a sliding window that increases `1` slot every iteration. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. .. versionchanged:: 1.21.0 The `min_periods` parameter was renamed `min_samples`. Parameters ---------- expr Expression to evaluate min_samples Number of valid values there should be in the window before the expression is evaluated. valid values = `length - null_count` Warnings -------- This can be really slow as it can have `O(n^2)` complexity. Don't use this for operations that visit all elements. Examples -------- >>> df = pl.DataFrame({"values": [1, 2, 3, 4, 5]}) >>> df.select( ... [ ... pl.col("values").cumulative_eval( ... pl.element().first() - pl.element().last() ** 2 ... ) ... ] ... ) shape: (5, 1) ┌────────┠│ values │ │ --- │ │ i64 │ â•žâ•â•â•â•â•â•â•â•â•¡ │ 0 │ │ -3 │ │ -8 │ │ -15 │ │ -24 │ └────────┘ )r$rdÚcumulative_eval)r}rtr‰s rur\ÚExpr.cumulative_eval(s%€ôb˜Ÿ™×5Ñ5°d·l±lÀKÓPÓQÐQrxcóJ•[URRU55$)u- Flags the expression as 'sorted'. Enables downstream code to user fast paths for sorted arrays. Parameters ---------- descending Whether the `Series` order is descending. Warnings -------- This can lead to incorrect results if the data is NOT sorted!! Use with care! Examples -------- >>> df = pl.DataFrame({"values": [1, 2, 3]}) >>> df.select(pl.col("values").set_sorted().max()) shape: (1, 1) ┌────────┠│ values │ │ --- │ │ i64 │ â•žâ•â•â•â•â•â•â•â•â•¡ │ 3 │ └────────┘ )r$rdÚset_sorted_flag)r}rÝs ruÚ set_sortedÚExpr.set_sorted3(s€ô:˜Ÿ™×5Ñ5°jÓAÓBÐBrxzT`Expr.shrink_dtype` is deprecated and is a no-op; use `Series.shrink_dtype` instead.có•U$)u¬ Shrink numeric columns to the minimal required datatype. Shrink to the dtype needed to fit the extrema of this [`Series`]. This can be used to reduce memory pressure. .. versionchanged:: 1.33.0 Deprecated and turned into a no-op. The operation does not match the Polars data-model during lazy execution since the output datatype cannot be known without inspecting the data. Use `Series.shrink_dtype` instead. Examples -------- >>> pl.DataFrame( ... { ... "a": [1, 2, 3], ... "b": [1, 2, 2 << 32], ... "c": [-1, 2, 1 << 30], ... "d": [-112, 2, 112], ... "e": [-112, 2, 129], ... "f": ["a", "b", "c"], ... "g": [0.1, 1.32, 0.12], ... "h": [True, None, False], ... } ... ).select(pl.all().shrink_dtype()) # doctest: +SKIP shape: (3, 8) ┌─────┬────────────┬────────────┬──────┬──────┬─────┬──────┬───────┠│ a ┆ b ┆ c ┆ d ┆ e ┆ f ┆ g ┆ h │ │ --- ┆ --- ┆ --- ┆ --- ┆ --- ┆ --- ┆ --- ┆ --- │ │ i8 ┆ i64 ┆ i32 ┆ i8 ┆ i16 ┆ str ┆ f32 ┆ bool │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•¡ │ 1 ┆ 1 ┆ -1 ┆ -112 ┆ -112 ┆ a ┆ 0.1 ┆ true │ │ 2 ┆ 2 ┆ 2 ┆ 2 ┆ 2 ┆ b ┆ 1.32 ┆ null │ │ 3 ┆ 8589934592 ┆ 1073741824 ┆ 112 ┆ 129 ┆ c ┆ 0.12 ┆ false │ └─────┴────────────┴────────────┴──────┴──────┴─────┴──────┴───────┘ rîr|s ruÚ shrink_dtypeÚExpr.shrink_dtypeR(s €ðTˆ rx)Ú bin_countÚinclude_categoryÚinclude_breakpointcóÄ•Ub7[U[5(a[R"U5n[ U5nOSn[ UR RXRX455$)uU Bin values into buckets and count their occurrences. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. Parameters ---------- bins Bin edges. If None given, we determine the edges based on the data. bin_count If `bins` is not provided, `bin_count` uniform bins are created that fully encompass the data. include_breakpoint Include a column that indicates the upper breakpoint. include_category Include a column that shows the intervals as categories. Returns ------- DataFrame Examples -------- >>> df = pl.DataFrame({"a": [1, 3, 8, 8, 2, 1, 3]}) >>> df.select(pl.col("a").hist(bins=[1, 2, 3])) shape: (2, 1) ┌─────┠│ a │ │ --- │ │ u32 │ â•žâ•â•â•â•â•â•¡ │ 3 │ │ 2 │ └─────┘ >>> df.select( ... pl.col("a").hist( ... bins=[1, 2, 3], include_breakpoint=True, include_category=True ... ) ... ) shape: (2, 1) ┌──────────────────────┠│ a │ │ --- │ │ struct[3] │ â•žâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ {2.0,"[1.0, 2.0]",3} │ │ {3.0,"(2.0, 3.0]",2} │ └──────────────────────┘ N)r!rjrrGrr$rdÚhist)r}ÚbinsrerfrgÚ bins_pyexprs ruriÚ Expr.hist~(sY€ðx Ñ Ü˜$¤×%Ñ%Ü—y’y “Ü/°Ó5‰KàˆKÜØ L‰L× Ñ ØÐ(8ó ó ð rx©ÚdefaultrÏcóú•Ub [SSS9 U[La[SSS9 URXX4S9$U[LaU[U[5(d Sn[ U5e[ UR55n[ UR55nO [U[5(a;[U[[R45(d[R"U5n[U[5(a;[U[[R45(d[R"U5n[USS9n[USS9n[URR!Xg55nUbUR#U5nU$) uê Replace the given values by different values of the same data type. Parameters ---------- old Value or sequence of values to replace. Accepts expression input. Sequences are parsed as Series, other non-expression inputs are parsed as literals. Also accepts a mapping of values to their replacement as syntactic sugar for `replace(old=Series(mapping.keys()), new=Series(mapping.values()))`. new Value or sequence of values to replace by. Accepts expression input. Sequences are parsed as Series, other non-expression inputs are parsed as literals. Length must match the length of `old` or have length 1. default Set values that were not replaced to this value. Defaults to keeping the original value. Accepts expression input. Non-expression inputs are parsed as literals. .. deprecated:: 1.0.0 Use :meth:`replace_strict` instead to set a default while replacing values. return_dtype The data type of the resulting expression. If set to `None` (default), the data type of the original column is preserved. .. deprecated:: 1.0.0 Use :meth:`replace_strict` instead to set a return data type while replacing values, or explicitly call :meth:`cast` on the output. See Also -------- replace_strict str.replace Notes ----- The global string cache must be enabled when replacing categorical values. Examples -------- Replace a single value by another value. Values that were not replaced remain unchanged. >>> df = pl.DataFrame({"a": [1, 2, 2, 3]}) >>> df.with_columns(replaced=pl.col("a").replace(2, 100)) shape: (4, 2) ┌─────┬──────────┠│ a ┆ replaced │ │ --- ┆ --- │ │ i64 ┆ i64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•¡ │ 1 ┆ 1 │ │ 2 ┆ 100 │ │ 2 ┆ 100 │ │ 3 ┆ 3 │ └─────┴──────────┘ Replace multiple values by passing sequences to the `old` and `new` parameters. >>> df.with_columns(replaced=pl.col("a").replace([2, 3], [100, 200])) shape: (4, 2) ┌─────┬──────────┠│ a ┆ replaced │ │ --- ┆ --- │ │ i64 ┆ i64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•¡ │ 1 ┆ 1 │ │ 2 ┆ 100 │ │ 2 ┆ 100 │ │ 3 ┆ 200 │ └─────┴──────────┘ Passing a mapping with replacements is also supported as syntactic sugar. >>> mapping = {2: 100, 3: 200} >>> df.with_columns(replaced=pl.col("a").replace(mapping)) shape: (4, 2) ┌─────┬──────────┠│ a ┆ replaced │ │ --- ┆ --- │ │ i64 ┆ i64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•¡ │ 1 ┆ 1 │ │ 2 ┆ 100 │ │ 2 ┆ 100 │ │ 3 ┆ 200 │ └─────┴──────────┘ The original data type is preserved when replacing by values of a different data type. Use :meth:`replace_strict` to replace and change the return data type. >>> df = pl.DataFrame({"a": ["x", "y", "z"]}) >>> mapping = {"x": 1, "y": 2, "z": 3} >>> df.with_columns(replaced=pl.col("a").replace(mapping)) shape: (3, 2) ┌─────┬──────────┠│ a ┆ replaced │ │ --- ┆ --- │ │ str ┆ str │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•¡ │ x ┆ 1 │ │ y ┆ 2 │ │ z ┆ 3 │ └─────┴──────────┘ Expression input is supported. >>> df = pl.DataFrame({"a": [1, 2, 2, 3], "b": [1.5, 2.5, 5.0, 1.0]}) >>> df.with_columns( ... replaced=pl.col("a").replace( ... old=pl.col("a").max(), ... new=pl.col("b").sum(), ... ) ... ) shape: (4, 3) ┌─────┬─────┬──────────┠│ a ┆ b ┆ replaced │ │ --- ┆ --- ┆ --- │ │ i64 ┆ f64 ┆ i64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•¡ │ 1 ┆ 1.5 ┆ 1 │ │ 2 ┆ 2.5 ┆ 2 │ │ 2 ┆ 5.0 ┆ 2 │ │ 3 ┆ 1.0 ┆ 10 │ └─────┴─────┴──────────┘ zˆthe `return_dtype` parameter for `replace` is deprecated. Use `replace_strict` instead to set a return data type while replacing values.rêrëzzthe `default` parameter for `replace` is deprecated. Use `replace_strict` instead to set a default while replacing values.rmúB`new` argument is required if `old` argument is not a Mapping typeTr›)rr Úreplace_strictr!rr‘rjÚvaluesÚkeysrrirrGrr$rdÚreplacerÙ) r}ÚoldÚnewrnrÏr’Ú old_pyexprÚ new_pyexprÚresults rurtÚ Expr.replaceÆ(sI€ðX Ñ #Ü %ðbàò ð œ*Ò $Ü %ðYàò ð ×&Ñ&Ø 'ð'ðð ð ”*Ò Ü˜c¤7×+Ñ+àXðô  “nÐ$Üs—z‘z“|Ó$ˆCÜs—x‘x“zÓ"‰Cä˜#œx×(Ñ(´¸CÄ#ÄrÇyÁyÐAQ×1RÑ1RÜ—i’i “nܘ#œx×(Ñ(´¸CÄ#ÄrÇyÁyÐAQ×1RÑ1RÜ—i’i “nä*¨3¸4Ñ@ˆ Ü*¨3¸4Ñ@ˆ ä˜4Ÿ<™<×/Ñ/° ÓGÓHˆà Ñ #Ø—[‘[ Ó.ˆFàˆ rxcó’•U[LaT[U[5(d Sn[U5e[ UR 55n[ UR 55n[USS9n[USS9nSnUb[U5RnOSnU[LaSO [USS9n [URRXgX˜55$)u§ Replace all values by different values. Parameters ---------- old Value or sequence of values to replace. Accepts expression input. Sequences are parsed as Series, other non-expression inputs are parsed as literals. Also accepts a mapping of values to their replacement as syntactic sugar for `replace_strict(old=Series(mapping.keys()), new=Series(mapping.values()))`. new Value or sequence of values to replace by. Accepts expression input. Sequences are parsed as Series, other non-expression inputs are parsed as literals. Length must match the length of `old` or have length 1. default Set values that were not replaced to this value. If no default is specified, (default), an error is raised if any values were not replaced. Accepts expression input. Non-expression inputs are parsed as literals. return_dtype The data type of the resulting expression. If set to `None` (default), the data type is determined automatically based on the other inputs. Raises ------ InvalidOperationError If any non-null values in the original column were not replaced, and no `default` was specified. See Also -------- replace str.replace Notes ----- The global string cache must be enabled when replacing categorical values. Examples -------- Replace values by passing sequences to the `old` and `new` parameters. >>> df = pl.DataFrame({"a": [1, 2, 2, 3]}) >>> df.with_columns( ... replaced=pl.col("a").replace_strict([1, 2, 3], [100, 200, 300]) ... ) shape: (4, 2) ┌─────┬──────────┠│ a ┆ replaced │ │ --- ┆ --- │ │ i64 ┆ i64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•¡ │ 1 ┆ 100 │ │ 2 ┆ 200 │ │ 2 ┆ 200 │ │ 3 ┆ 300 │ └─────┴──────────┘ Passing a mapping with replacements is also supported as syntactic sugar. >>> mapping = {1: 100, 2: 200, 3: 300} >>> df.with_columns(replaced=pl.col("a").replace_strict(mapping)) shape: (4, 2) ┌─────┬──────────┠│ a ┆ replaced │ │ --- ┆ --- │ │ i64 ┆ i64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•¡ │ 1 ┆ 100 │ │ 2 ┆ 200 │ │ 2 ┆ 200 │ │ 3 ┆ 300 │ └─────┴──────────┘ By default, an error is raised if any non-null values were not replaced. Specify a default to set all values that were not matched. >>> mapping = {2: 200, 3: 300} >>> df.with_columns( ... replaced=pl.col("a").replace_strict(mapping) ... ) # doctest: +SKIP Traceback (most recent call last): ... polars.exceptions.InvalidOperationError: incomplete mapping specified for `replace_strict` >>> df.with_columns(replaced=pl.col("a").replace_strict(mapping, default=-1)) shape: (4, 2) ┌─────┬──────────┠│ a ┆ replaced │ │ --- ┆ --- │ │ i64 ┆ i64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•¡ │ 1 ┆ -1 │ │ 2 ┆ 200 │ │ 2 ┆ 200 │ │ 3 ┆ 300 │ └─────┴──────────┘ Replacing by values of a different data type sets the return type based on a combination of the `new` data type and the `default` data type. >>> df = pl.DataFrame({"a": ["x", "y", "z"]}) >>> mapping = {"x": 1, "y": 2, "z": 3} >>> df.with_columns(replaced=pl.col("a").replace_strict(mapping)) shape: (3, 2) ┌─────┬──────────┠│ a ┆ replaced │ │ --- ┆ --- │ │ str ┆ i64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•¡ │ x ┆ 1 │ │ y ┆ 2 │ │ z ┆ 3 │ └─────┴──────────┘ >>> df.with_columns(replaced=pl.col("a").replace_strict(mapping, default="x")) shape: (3, 2) ┌─────┬──────────┠│ a ┆ replaced │ │ --- ┆ --- │ │ str ┆ str │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•¡ │ x ┆ 1 │ │ y ┆ 2 │ │ z ┆ 3 │ └─────┴──────────┘ Set the `return_dtype` parameter to control the resulting data type directly. >>> df.with_columns( ... replaced=pl.col("a").replace_strict(mapping, return_dtype=pl.UInt8) ... ) shape: (3, 2) ┌─────┬──────────┠│ a ┆ replaced │ │ --- ┆ --- │ │ str ┆ u8 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•¡ │ x ┆ 1 │ │ y ┆ 2 │ │ z ┆ 3 │ └─────┴──────────┘ Expression input is supported for all parameters. >>> df = pl.DataFrame({"a": [1, 2, 2, 3], "b": [1.5, 2.5, 5.0, 1.0]}) >>> df.with_columns( ... replaced=pl.col("a").replace_strict( ... old=pl.col("a").max(), ... new=pl.col("b").sum(), ... default=pl.col("b"), ... ) ... ) shape: (4, 3) ┌─────┬─────┬──────────┠│ a ┆ b ┆ replaced │ │ --- ┆ --- ┆ --- │ │ i64 ┆ f64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•¡ │ 1 ┆ 1.5 ┆ 1.5 │ │ 2 ┆ 2.5 ┆ 2.5 │ │ 2 ┆ 5.0 ┆ 5.0 │ │ 3 ┆ 1.0 ┆ 10.0 │ └─────┴─────┴──────────┘ rpTr›N) r r!rr‘rjrrrsrr'rÚr$rdrq) r}rurvrnrÏr’rwrxÚ dtype_pyexprÚdefault_pyexprs rurqÚExpr.replace_strictz)sÊ€ðX ”*Ò Ü˜c¤7×+Ñ+àXðô  “nÐ$Üs—z‘z“|Ó$ˆCÜs—x‘x“zÓ"ˆCä*¨3¸4Ñ@ˆ Ü*¨3¸4Ñ@ˆ à26ˆ Ø Ñ #Ü3°LÓA×RÑR‰LàˆLðœ*Ò$ñ ä& w¸4Ñ@ð ô Ø L‰L× 'Ñ 'بó ó ð rxcóH•[URR55$)z Evaluate the number of set bits.)r$rdÚbitwise_count_onesr|s rur€ÚExpr.bitwise_count_onesD*s€ä˜Ÿ™×8Ñ8Ó:Ó;Ð;rxcóH•[URR55$)z"Evaluate the number of unset bits.)r$rdÚbitwise_count_zerosr|s rurƒÚExpr.bitwise_count_zerosH*s€ä˜Ÿ™×9Ñ9Ó;Ó<ÐÐ>rxcóH•[URR55$)zJEvaluate the number least-significant set bits before seeing an unset bit.)r$rdÚbitwise_trailing_onesr|s rurÚExpr.bitwise_trailing_onesT*r‹rxcóH•[URR55$)zIEvaluate the number least-significant unset bits before seeing a set bit.)r$rdÚbitwise_trailing_zerosr|s rurÚExpr.bitwise_trailing_zerosX*s€ä˜Ÿ™×<Ñ<Ó>Ó?Ð?rxcóH•[URR55$)uâPerform an aggregation of bitwise ANDs. Examples -------- >>> df = pl.DataFrame({"n": [-1, 0, 1]}) >>> df.select(pl.col("n").bitwise_and()) shape: (1, 1) ┌─────┠│ n │ │ --- │ │ i64 │ â•žâ•â•â•â•â•â•¡ │ 0 │ └─────┘ >>> df = pl.DataFrame( ... {"grouper": ["a", "a", "a", "b", "b"], "n": [-1, 0, 1, -1, 1]} ... ) >>> df.group_by("grouper", maintain_order=True).agg(pl.col("n").bitwise_and()) shape: (2, 2) ┌─────────┬─────┠│ grouper ┆ n │ │ --- ┆ --- │ │ str ┆ i64 │ â•žâ•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ a ┆ 0 │ │ b ┆ 1 │ └─────────┴─────┘ )r$rdÚ bitwise_andr|s rur“ÚExpr.bitwise_and\*ó€ô:˜Ÿ™×1Ñ1Ó3Ó4Ð4rxcóH•[URR55$)ußPerform an aggregation of bitwise ORs. Examples -------- >>> df = pl.DataFrame({"n": [-1, 0, 1]}) >>> df.select(pl.col("n").bitwise_or()) shape: (1, 1) ┌─────┠│ n │ │ --- │ │ i64 │ â•žâ•â•â•â•â•â•¡ │ -1 │ └─────┘ >>> df = pl.DataFrame( ... {"grouper": ["a", "a", "a", "b", "b"], "n": [-1, 0, 1, -1, 1]} ... ) >>> df.group_by("grouper", maintain_order=True).agg(pl.col("n").bitwise_or()) shape: (2, 2) ┌─────────┬─────┠│ grouper ┆ n │ │ --- ┆ --- │ │ str ┆ i64 │ â•žâ•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ a ┆ -1 │ │ b ┆ -1 │ └─────────┴─────┘ )r$rdÚ bitwise_orr|s rur—ÚExpr.bitwise_or{*s€ô:˜Ÿ™×0Ñ0Ó2Ó3Ð3rxcóH•[URR55$)uâPerform an aggregation of bitwise XORs. Examples -------- >>> df = pl.DataFrame({"n": [-1, 0, 1]}) >>> df.select(pl.col("n").bitwise_xor()) shape: (1, 1) ┌─────┠│ n │ │ --- │ │ i64 │ â•žâ•â•â•â•â•â•¡ │ -2 │ └─────┘ >>> df = pl.DataFrame( ... {"grouper": ["a", "a", "a", "b", "b"], "n": [-1, 0, 1, -1, 1]} ... ) >>> df.group_by("grouper", maintain_order=True).agg(pl.col("n").bitwise_xor()) shape: (2, 2) ┌─────────┬─────┠│ grouper ┆ n │ │ --- ┆ --- │ │ str ┆ i64 │ â•žâ•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ a ┆ -2 │ │ b ┆ -2 │ └─────────┴─────┘ )r$rdÚ bitwise_xorr|s ruršÚExpr.bitwise_xorš*r•rxzW`register_plugin` is deprecated; use `polars.plugins.register_plugin_function` instead.)r,r/rÚinput_wildcard_expansionrÇÚcast_to_supertypesÚpass_name_to_applyÚchanges_lengthc óV•SSKJn UcU/nOU/[U5QnU "UUUUUU UUUU S9 $)a~ Register a plugin function. .. deprecated:: 0.20.16 Use :func:`polars.plugins.register_plugin_function` instead. See the `user guide `_ for more information about plugins. Warnings -------- This method is deprecated. Use the new `polars.plugins.register_plugin_function` function instead. This is highly unsafe as this will call the C function loaded by `lib::symbol`. The parameters you set dictate how Polars will handle the function. Make sure they are correct! Parameters ---------- lib Library to load. symbol Function to load. args Arguments (other than self) passed to this function. These arguments have to be of type Expression. kwargs Non-expression arguments. They must be JSON serializable. is_elementwise If the function only operates on scalars this will trigger fast paths. input_wildcard_expansion Expand expressions as input of this function. returns_scalar Automatically explode on unit length if it ran as final aggregation. this is the case for aggregations like `sum`, `min`, `covariance` etc. cast_to_supertypes Cast the input datatypes to their supertype. pass_name_to_apply if set, then the `Series` passed to the function in the group_by operation will ensure the name is set. This is an extra heap allocation per group. changes_length For example a `unique` or a `slice` r)Úregister_plugin_function) Ú plugin_pathÚ function_namer,r/rrŸrÇÚcast_to_supertyperœrž)Úpolars.pluginsr¡rj) r}ÚlibÚsymbolr,r/rrœrÇrržrŸr¡s ruÚregister_pluginÚExpr.register_plugin¹*sP€õB <à ‰<Ø6‰DàÐ&œ4 ›:Ð&ˆDá'ØØ ØØØ)Ø)Ø)Ø0Ø%=Ø1ñ  ð rx©Ú unorderedrÝrÞcóN•[R"U/UUcSOU/UcSS9$U/S9$)Nrª)rÚ _row_encode)r}r«rÝrÞs rur­ÚExpr._row_encode+sC€ô}Š}Ø ˆFØØ)Ñ1‘t¸ °|Ø)Ñ1tñ  ð ð9C°|ñ  ð rxcóþ•UVs/sHn[U5RPM nnU(a&UbeUbeURRX5nOURR XXE5n[ U5$s snfrp)r'rÚrdÚrow_decode_unorderedÚrow_decode_orderedr$) r}ÚnamesÚdtypesr«rÝrÞrÛÚdtypes_pyexprsrys ruÚ _row_decodeÚExpr._row_decode+sŠ€ñKQó ÚJPÀÔ $ UÓ +× <Ô <É&ð ð ö ØÑ%Ð %Ð%ØÑ%Ð %Ð%à—\‘\×6Ñ6°uÓM‰Fà—\‘\×4Ñ4Ø zóˆFô˜Ó Ð ùò s…A:cóH•[SSS9 UR[U5SS9$)aj Read an expression from a JSON encoded string to construct an Expression. .. deprecated:: 0.20.11 This method has been renamed to :meth:`deserialize`. Note that the new method operates on file-like inputs rather than strings. Enclose your input in `io.StringIO` to keep the same behavior. Parameters ---------- value JSON encoded string value zÔ`Expr.from_json` is deprecated. It has been renamed to `Expr.deserialize`. Note that the new method operates on file-like inputs rather than strings. Enclose your input in `io.StringIO` to keep the same behavior.z0.20.11rërLrI)rrUr )rrr-s ruÚ from_jsonÚExpr.from_json5+s0€ô "ð Nðò  𠉜x¨›°vˆÐ>Ð>rxcó•[U5$)zm Create an object namespace of all binary related methods. See the individual method pages for full details r/r|s rurgÚExpr.binL+s€ô# 4Ó(Ð(rxcó•[U5$)uÚ Create an object namespace of all categorical related methods. See the individual method pages for full details Examples -------- >>> df = pl.DataFrame({"values": ["a", "b"]}).select( ... pl.col("values").cast(pl.Categorical) ... ) >>> df.select(pl.col("values").cat.get_categories()) shape: (2, 1) ┌────────┠│ values │ │ --- │ │ str │ â•žâ•â•â•â•â•â•â•â•â•¡ │ a │ │ b │ └────────┘ r1r|s rurhÚExpr.catU+s€ô.  Ó%Ð%rxcó•[U5$)z;Create an object namespace of all datetime related methods.r3r|s rureÚExpr.dtn+s€ô% TÓ*Ð*rxcó•[U5$)zl Create an object namespace of all list related methods. See the individual method pages for full details. r5r|s rurjÚ Expr.listv+ó€ô! Ó&Ð&rxcó•[U5$)zm Create an object namespace of all array related methods. See the individual method pages for full details. r-r|s rurfÚExpr.arr+s€ô" $Ó'Ð'rxcó•[U5$)zƒ Create an object namespace of all meta related expression methods. This can be used to modify and traverse existing expressions. r7r|s rurkÚ Expr.metaˆ+rÂrxcó•[U5$)z€ Create an object namespace of all expressions that modify expression names. See the individual method pages for full details. r9r|s rurlÚ Expr.name‘+rÂrxcó•[U5$)u¨ Create an object namespace of all string related methods. See the individual method pages for full details. Examples -------- >>> df = pl.DataFrame({"letters": ["a", "b"]}) >>> df.select(pl.col("letters").str.to_uppercase()) shape: (2, 1) ┌─────────┠│ letters │ │ --- │ │ str │ â•žâ•â•â•â•â•â•â•â•â•â•¡ │ A │ │ B │ └─────────┘ r;r|s ruriÚExpr.strš+s€ô*# 4Ó(Ð(rxcó•[U5$)uT Create an object namespace of all struct related methods. See the individual method pages for full details. Examples -------- >>> df = ( ... pl.DataFrame( ... { ... "int": [1, 2], ... "str": ["a", "b"], ... "bool": [True, None], ... "list": [[1, 2], [3]], ... } ... ) ... .to_struct("my_struct") ... .to_frame() ... ) >>> df.select(pl.col("my_struct").struct.field("str")) shape: (2, 1) ┌─────┠│ str │ │ --- │ │ str │ â•žâ•â•â•â•â•â•¡ │ a │ │ b │ └─────┘ r=r|s rurmÚ Expr.struct±+s€ô@# 4Ó(Ð(rxcóV•URRU5nUcg[U5$rp)rdÚskip_batch_predicater$)r}Úschemarys ruÚ_skip_batch_predicateÚExpr._skip_batch_predicateÓ+s)€Ø—‘×2Ñ2°6Ó:ˆØ ‰>ØÜ˜Ó Ð rx)rd)rsrAr5rb)r5ri)r5r)r5rb)rŸrKr5rb)rŸzIntoExprColumn | int | boolr5rb)róúIntoExprColumn | int | floatr5rb)rùrÒr5rb)r5rO)rrOr5ÚNone) r1zCallable[..., Any]r>rir?r r/r r5rb)rSzstr | Path | IOBase | bytesrJrVr5rb)rZÚboolr5rb)rlrir5rb)rzzCstr | PolarsDataType | Collection[str] | Collection[PolarsDataType]r{zstr | PolarsDataTyper5rb)r2z!Callable[Concatenate[Expr, P], T]r,zP.argsr/zP.kwargsr5r_rp)rŸú int | Exprr zint | Expr | Noner5rb)rŸrKr¢rÔr5rb)r¯rÔr5rb)rÚ half_to_even)rÉr²rÊrSr5rb)rÎr²r5rb)rŸz Expr | strr5rb)rÛz,PolarsDataType | pl.DataTypeExpr | type[Any]rÖrÔr×rÔr5rb)rÝrÔrÞrÔr5rb)é)rçúint | IntoExprColumnr5rb)rîúIntoExpr | Iterable[IntoExpr]rçrØr¯úbool | Sequence[bool]r5rb)rrKr5rb)r\)rzIntoExpr | np.ndarray[Any, Any]r rUrÝrÔr5rb)rîrÙrrKrÝrÚrÞrÚrrÔrrÔr5rb)rz>int | Sequence[int] | IntoExpr | Series | np.ndarray[Any, Any]r5rb)rErÕr5rb)r)r$rØr!úIntoExpr | Noner5rb)NNN)r-zAny | Expr | Noner.zFillNullStrategy | Noner/ú int | Noner5rb)r-zint | float | Expr | Noner5rb)r/rÜr5rb)rCr²r5rb)rrÔr5rb)r„ú$IntoExpr | Iterable[IntoExpr] | Noner…rKr~rÝrÝrÔrÞrÔrrXr5rb) rrirŽústr | timedeltarŸzstr | timedelta | NonerŠrHr5rb)r£)r¥z float | Exprr¦rQr5rb) r®zSequence[float]r©úSequence[str] | NonerªrÔr«rÔr5rb) rµzSequence[float] | intr©rßrªrÔr°rÔr«rÔr5rb)r¿z)IntoExprColumn | Iterable[IntoExprColumn]rÀr r5rb)rÁrbr5rb) r2z Callable[[Series], Series | Any]rÏú'PolarsDataType | pl.DataTypeExpr | NonerÆrÔrrÔrÇrÔr5rb)r2zCallable[[Any], Any]rÏràrÒrÔrÓrÔr.rMrÇrÔr5rb)r)r$r²rŸr²r5rb)é )r$rÕr5rb)rr r5rb)rŸr r5rb)rŸzExpr | Collection[Any] | SeriesrUrÔr5rb)rîzpl.Series | Expr | str | intr5rb)Úboth)r_rKr`rKrŠrHr5rb) rŸrKreÚfloatrfrãrgrÔr5rb)rNNN) rmr²rnrÜrorÜrprÜr5rb)rvrÔr5rb)z{})r}rir5rb)Úlinear)r>rJr5rb)rîrKr5rb) rîrKrŽútimedelta | strr‰r²rŠrHr5rb) rîrKrŽrår‰r²rŠrHrCr²r5rb)rîrKrŽrår¥rãr¦rQr‰r²rŠrHr5rb) rŽr²r­úlist[float] | Noner‰rÜr¨rÔr5rb) rŽr²r­rær‰rÜr¨rÔrCr²r5rb)r£éN)r¥rãr¦rQrŽr²r­rær‰rÜr¨rÔr5rb) rŽr²rÈrÔr‰rÜr¨rÔr5rb) rŽr²rÌrÔrÈrÔr‰rÜr¨rÔr5rb) r2zCallable[[Series], Any]rŽr²r­rær‰rÜr¨rÔr5rb)Úaverage)r>rRrÝrÔrmrÜr5rb)rrÝ)r$zint | IntoExprrßrNr5rb)r$rØr5rb)rÈrÔr5rb)rÌrÔrÈrÔr5rb)NN)r_ú8NumericLiteral | TemporalLiteral | IntoExprColumn | Noner`rér5rb)r&ztuple[int, ...]r5rb)rmrÜr5rb) r$zint | IntoExprColumn | Noner+zfloat | IntoExprColumn | Noner,rÔr)rÔrmrÜr5rb)r3ú float | Noner4rêr5rêr6rêr7rÔr‰r²rZrÔr5rb)rîzstr | IntoExprr5rÞr5rb)r3rêr4rêr5rêr6rêr7rÔrÈrÔr‰r²rZrÔr5rb)r-rKr$rØr5rb) rârÔrJrÔrlz str | NonerKrÔr5rb)rùzfloat | IntoExprr5rb)rùrãrKrÔr5rb)rtrbr‰r²r5rb)rÝrÔr5rb) rjrÛrerÜrfrÔrgrÔr5rb) ruú,IntoExpr | Sequence[Any] | Mapping[Any, Any]rvú$IntoExpr | Sequence[Any] | NoDefaultrnúIntoExpr | NoDefaultrÏzPolarsDataType | Noner5rb) rurërvrìrnrírÏràr5rb)r¦rir§rir,zlist[IntoExpr] | Noner/zdict[Any, Any] | NonerrÔrœrÔrÇrÔrrÔržrÔrŸrÔr5rb)r«rÔrÝú bool | NonerÞrîr5rb) r²z Sequence[str]r³z*Sequence[pl.DataTypeExpr | PolarsDataType]r«rÔrÝúSequence[bool] | NonerÞrïr5rb)r-rir5rb)r5r0)r5r2)r5r4)r5r6)r5r.)r5r8)r5r:)r5r<)r5r>)rÏrTr5z Expr | None( rˆÚ __module__Ú __qualname__Ú__firstlineno__Ú__doc__rdÚ__annotations__rnÚ classmethodrvr~r‹rŽr“r—r¡r¤r¨r®r³r·rºr¾rÃrÇrËrÏrÒrÖrÚrÝrárärèrërïrõrûrþrrrr rrrrFrUrXr\r`rdrgrkrorrr=rxr~rÆrƒr†rŠrrr“r–r™r†ržr*r¦rªr­r±rµr¸r»r¾rÁrÄrÈrÍrÑrÊrÙrârårrðrôr÷rûrþrrr rrrr#r+r3r9r<r¯rArGrJrNrQrUr;r[r_rbrerhrkrnrqrurxr{rƒrŒr‘r”r—ršrr¡r¥rr­r´r¸r»r¾rrÄr:rârrrÎrrrr/r§rçr²r'r*rÂr/rÎr4r8r;r>rArDrHrKrNròrSrWrZr^rirlrxr~rƒr†rŒr‘r•r˜r›r r£r¦r«r°r´r·r»rÀrÃrÆrÊrÎrÖr–rÛrÞrârårèrër_r`rórörúrýrrrr r rrrrrrr"r%r)r1r:r=r@rErHrNrQÚmathÚernrVrYr\r`rcrir rtrqr€rƒr†r‰rrr“r—ršr¨r­rµr¸ÚpropertyrgrhrerjrfrkrlrirmrÐÚ__static_attributes__rîrxrurbrb~sz‡Ù;ð€GˆVÓò &€JÐ"ó ðôóðõ %õOõ %õ õõ6õ6õ:õ8õ8õ 7õ7õ;õ 8õ õ;õ 8õ 6õ6õ6õ6õ9õ (õ9õ7õõ<õ.õ6õ6õ6õ6õ:õ8õ+õ)ð?SØ'ð?SØ14ð?SØ?Bð?SØNQð?Sà õ?SðBð '/ñ ;6à+ð;6ð$ð ;6ð õ ;6óð;6õz.5ð`+/÷69ð69ðp+/÷:9ð:9õx5õ<.õ*.õ*õ*-õ*:3ðxSQàTðSQð,ðSQð õ SQðj1/à3ð1/ðð1/ðð 1/ð õ 1/õf#.õJ1õ85õ<3õ<5õ<0õB4õB 4õD/õ8-÷<#Mð#MðJ9=÷!Dð!DõF1õ64õ@3ð@*/÷<8ð<8ð|+0÷!9ð!9ðF*/÷8ð8ð:*/÷78ð78ðr,1÷:ð:õ</õ0.÷0==ð==õ~>õ49õ<.ð<Ø$ñ / à;ð/ ðð / ð ð / ð ö / ðb*/À5÷MIðMI÷^.7ð.7ñ`! ¨yÀ'ÑJð#$ñ}Yð */ñ }Yà )ð}Yð ð}Yð 'ð }Yð ö }YóKð}Y÷~0:ð0:ñd! ¨yÀ'ÑJð#$ñ} ð */ñ } à )ð} ð ð} ð 'ð } ð ö } óKð} ð~.3Àu÷7Hð7Hõr1õ.1õ.@ðD"'ñ2Wð !ñ 2Wà0ð2Wðð2Wð ð 2Wð ÷ 2Wðp-2Ø,1Ø"Ø$ñL à )ðL ððL ð*ð L ð *ð L ð ð L ððL ð öL ð\6BØUð6Bà õ6Bõp)=ðX)*ñLJØLPñLJØ%ðLJØ:IðLJà ÷LJð`$(Ø,0Ø ñ pTà ðpTð*ðpTðð pTð ö pTõd'C÷R?ð?÷&@ð@õ&!1÷F1ð1÷41ð1õ4-õ&-õ&1õ,1õ,-õ8.õ&0õ&1õ42õ4 9õD4õ2%õ2"4ðH05÷#0ð#0õJ/õ&.ð*>Bñy ð:>Ø Ø Ø2Añy à:ðy ððy ð7ð y ð ð y ð ð y ð0ðy ð ÷y ð@*.Ø!(ñ gUàðgUð ð gUð 'ð gUð ð gUð ögUõR3õ*;õ8:õ87õ42õ.2ð4)2ñAPàðAPð&ðAPð ö APñFƒZð (,Ø!Ø$ñ NXàðNXð%ð NXð ð NXð ð NXð õNXóðNXñ`ƒZð (,Ø!Ø!&Ø$ñr!à(ðr!ð%ð r!ð ð r!ð ð r!ððr!ð õr!óðr!õh#-õJ.0ð`I9à>ðI9ððI9ð õ I9ñVÐ>Ó?ô&&ó@ð&&ðVAEñV ð Ø$Ø$ñV à2ðV ð>ðV ð ð V ð ð V ððV ð ÷V ðvAEñV"ð  ØØ(6Ø$ñV"à&ðV"ð>ðV"ð ð V"ð ð V"ð&ðV"ððV"ð ÷V"õp1õ6'1õR1÷0&?ð&?÷P ð ÷4%ð%÷Bðõ4)6õV(6õT "õD&@õP "õD "õD "õD "õD "õD&AõP,#õ\U(õn#õ8#õ>#õ>õ,*'õX3&õj;#ðB"ñ *Hà.ð*Hðð *Hð ö *HõX(<ð\"(ñ p àðp ððp ðð p ð ö p ðlØØ ñ 8 àð8 ðð 8 ð ð 8 ð ð 8 ð ö8 ðxØ!Ø!Ø!ñ 5<àð5<ðð5<ðð 5<ð ð 5<ð ö 5<ðn-1÷!;ð!;÷FHðH÷BM;ðM;õ^#AñJƒZÙ  ° ÀxÑPð Ø!(ñ | à ð| ð%ð| ð ð | ð ð | ð õ| óQóð| ñ|ƒZÙ  ° ÀxÑPð Ø!(ñ V à ðV ð%ðV ð ð V ð ð V ð õV óQóðV ñpƒZÙ  ° ÀxÑPð Ø!(ñ ] à ð] ð%ð] ð ð ] ð ð ] ð õ] óQóð] ñ~ƒZÙ  ° ÀxÑPð Ø!(ñ V à ðV ð%ðV ð ð V ð ð V ð õV óQóðV ñpƒZÙ  ° ÀxÑPð Ø!(Øñ_ à ð_ ð%ð_ ð ð _ ð ð _ ðð_ ð õ_ óQóð_ ñBƒZÙ  ° ÀxÑPð Ø!(Øñ_ à ð_ ð%ð_ ð ð _ ð ð _ ðð_ ð õ_ óQóð_ ñBƒZÙ  ° ÀxÑPð Ø!(ñ ~ à ð~ ð%ð~ ð ð ~ ð ð ~ ð õ~ óQóð~ ñ@ƒZÙ  ° ÀxÑPð)2ØØ!(ñK à ðK ð%ðK ð ð K ð &ð K ððK ððK ð õK óQóðK ñZ! ° ÀxÑPð'+ñk ð #'Øñ k àðk ð$ðk ð  ð k ð ð k ð ök óQðk ñZ! ° ÀxÑPð'+ñk ð #'Øñ k àðk ð$ðk ð  ð k ð ð k ð ök óQðk ñZ! ° ÀxÑPð'+ñm ð #'Øñ m àðm ð$ðm ð  ð m ð ð m ð öm óQðm ñ^! ° ÀxÑPð'+ñk ð #'Øñ k àðk ð$ðk ð  ð k ð ð k ð ök óQðk ñZ! ° ÀxÑPð'+ñq ð #'ØØñq àðq ð$ðq ð  ð q ð ð q ððq ð öq óQðq ñf! ° ÀxÑPð'+ñq ð #'ØØñq àðq ð$ðq ð  ð q ð ð q ððq ð öq óQðq ñf! ° ÀxÑPð'+ñk ð #'Øñ k àðk ð$ðk ð  ð k ð ð k ð ök óQðk ñZ! ° ÀxÑPð)2ØØ&*ñ O ð#'ØñO àðO ð&ðO ðð O ð $ð O ð ðO ððO ð öO óQðO ñbƒZð Ø"&Øñ < àð< ðð < ð  ð < ð ð < ð õ< óð< ñ|ƒZð ØØ"&Øñ> àð> ðð > ð ð > ð  ð > ðð> ð õ> óð> ñ@ƒZÙ  ° ÀxÑPð '+ñ E ð #'ØñE à)ðE ððE ð$ð E ð  ð E ððE ð öE óQóðE õN-ð<'ñnFð!Øñ nFàðnFðð nFð ð nFð ÷ nFðbDLñ9EØð9EØ4@ð9Eà ö9E÷v$<ð$<ðL$(÷32ð32ðj*.¸D÷!>ð!>ðJQUØPTñUTàMðUTðNðUTð ö UTõn5õ,5õ,.õ@-õ0-õ0-õ0-õ00ö00ö00ö0.ö0.ö0.ö01ö01ö01ö01öB1ö@7;÷r5ñ5ð@*.ñ; ð37Ø!&ØØò; à &ð; ð0ð ; ð ð ; ð ð ; ðð; ð ÷; ð; ñz! ° ÀxÑPð!Ø!Ø"&Ø"ØØØ"òX ððX ðð X ð  ð X ð ð X ððX ððX ððX ð öX óQðX ðtZIà ðZIð#ð ZIð ö ZIñx! ° ÀxÑPð!Ø!Ø"&Ø"ØØØØ"ò\ ðð\ ðð \ ð  ð \ ð ð \ ðð\ ðð\ ðð\ ðð\ ð ö\ óQð\ ñ|! ° ÀxÑPð!Ø!Ø"&Ø"ØØØØ"ò\ ðð\ ðð \ ð  ð \ ð ð \ ðð\ ðð\ ðð\ ðð\ ð ö\ óQð\ ö|OðHØØØò dUððdUðð dUð ð dUð ð dUð ÷dUöL7ð@,0¯6ª6÷8ð8ö6/ð.%)§F¢Fð#@À÷#@ó#@ñJƒZÙ  ° ÀxÑPØ@A÷/Rñ/RóQóð/Rðb05÷CñCñ>Ù^óõ'óð'ñRƒZð!%ñE ð!%Ø!&Ø#(ò E àðE ðð E ð ð E ð !ð E ð ÷E óðE ðT5?ðrð )3Ø.2ò rà 9ðrð2ðrð &ð rð ,ð rð ÷rðrðn5?ðH ð )3Ø@Dò H à 9ðH ð2ðH ð &ð H ð >ð H ð ÷H ðH öT<ö=ö>ö?ö?ö@ö5ö>4ö>5ñ>ñ Aóð'+Ø(,Ø$Ø).Ø$Ø#(Ø#(Ø$òO ððO ðð O ð $ð O ð &ð O ððO ð#'ðO ððO ð!ðO ð!ðO ððO ð öO ó ðO ðh Ø"&Ø"&ò  ðð  ð ð  ð  ð  ð ÷  ð& Ø,0Ø,0ò!àð!ð;ð!ð ð !ð *ð !ð*ð!ð ÷!ð2õ?óñ?ñ,õ)óñ)ñõ&óñ&ñ0õ+óñ+ñõ'óñ'ñõ(óñ(ñõ'óñ'ñõ'óñ'ñõ)óñ)ñ,õ)óñ)÷B!ô!rxrbcóâ•[SXX#455S:”a Sn[U5eUb"US:aSU<S3n[U5eSSU-- nU$Ub"US:aSU<S3n[U5eS US-- nU$UbKUS::aS U<S3n[U5eS[R"[R"S 5*U- 5- nU$Uc S n[U5eS Us=:aS::dO S U<S3n[U5eU$)zGNormalise EWM decay specification in terms of smoothing factor 'alpha'.c3ó(# •UHoSLv• M g7frprî)r"Úparams rur$Ú!_prepare_alpha..á+sé€Ð JÒ,I 5˜Õ Ò,Iùs‚rzIparameters `com`, `span`, `half_life`, and `alpha` are mutually exclusiverdzrequire `com` >= 0 (found Ú)gð?zrequire `span` >= 1 (found g@zrequire `half_life` > 0 (found z9one of `com`, `span`, `half_life`, or `alpha` must be setrz require 0 < `alpha` <= 1 (found )r;rRrörrrn)r3r4r5r6r’s rur9r9Ú+s4€ô Ñ J¨S¸ Ñ,IÓ JÓJÈQÓNà Wð ô˜‹oÐØ Ø ‹9Ø.¨s©g°QÐ7ˆCܘS“/Ð !Øs˜S‘yÑ!ˆð, €Lð) Ñ Ø #‹:Ø/°©x°qÐ9ˆCܘS“/Ð !Øt˜c‘zÑ"ˆð €Lð Ñ Ø ˜Ó Ø3°I±=ÀÐBˆCܘS“/Ð !Ø”d—h’h¤§¢¨£ ˜~° Ñ9Ó:Ñ:ˆð €Lð ‰ØIˆÜ˜‹oÐà%n˜1nØ0°± ¸Ð;ˆÜ˜‹oÐà €LrxcóF•[U[5(a [U5nU$rp)r!rr)rŽs rur‹r‹,s€Ü+œy×)Ñ)Ü.¨{Ó;ˆ Ø Ðrx)NNNN) r3úfloat | int | Noner4rr5rr6rr5rã)rŽrår5ri)‡Ú __future__rÚ contextlibrörÚsysr8Úcollections.abcrrrÚdatetimerÚ functoolsrÚior r Úpathlibr Útypingr r rrrrÚpolars._reexportÚ _reexportrÚpolarsrrÚpolars._utils.convertrrÚpolars._utils.deprecationrrrÚpolars._utils.parserrrÚpolars._utils.unstablerrÚpolars._utils.variousrrrr r!r"r#Úpolars._utils.wrapr$r%Úpolars.datatypesr&r'Úpolars.dependenciesr(r)rÚpolars.exceptionsr*r+r,Úpolars.expr.arrayr.Úpolars.expr.binaryr0Úpolars.expr.categoricalr2Úpolars.expr.datetimer4Úpolars.expr.listr6Úpolars.expr.metar8Úpolars.expr.namer:Úpolars.expr.stringr<Úpolars.expr.structr>Ú polars.metar?ÚsuppressÚ ImportErrorÚ polars._plrr@rcrArBÚ_plrÚplrrCrDrErFrGÚpolars._typingrHrIrJrKrLrMrNrOrPrQrRrSrTrUrVrWrXrYÚ version_infor\r]Útyping_extensionsr_r`ÚmodulesrˆÚcurrent_modulerørbr9r‹rîrxruÚr*sðÝ"ãÛ ÛÛ Ûß9Ñ9ÝÝß Ý÷÷õÝ!ßR÷ñ÷ ñ÷ D÷÷ñ÷1÷õ1Ý+÷ñõ 1Ý2Ý4Ý6Ý.Ý.Ý.Ý2Ý2Ý(à×Ò˜Õ%Ý5÷&ð×Ò˜Õ%Ý"÷&öØ × Ò ˜[Õ )Ý(÷ *ð × Ò ˜[Õ )Ý!÷ *õ)Ýç3Ñ3÷÷÷÷õõ&0à ×ј7Ó"ß1Ð1ç<à ×ј7Ó"Þ'å0á‹ €AÙ#‹Aæð—[’[ Ñ*€NØ-€NÔ÷Ym!ñYm!ðzZ#Ø#Ø$(Ø $ð &Ø ð&à ð&ð"ð&ð ð &ð  õ &õR÷]&Ö%ú÷&Ö%ú÷ *Ö )ú÷ *Ö )ús0ÄIÄ&I#ÅI5Å/JÉ I É# I2É5 JÊ J