'h< HSSKJr SSKrSSKrSSKrSSKrSSKJrJr SSKJ r SSK J r J r J r J r SSKJr SSKJrJrJrJrJrJrJrJr SSKJr SSKJr SS K J!r!J"r"J#r#J$r$J%r%J&r&J'r' SS K(J)r)J*r*J+r+J,r, SS K-J.r.J/r/J0r0 SS K1J2r2 SS K3J4r4 SSK5J6r6J7r7J8r8J9r9J:r:J;r;Jr> SSK?J@r@JArA SSKBJCrCJDrDJErEJFrFJGrGJrJHrHJIrIJJrJJKrKJLrLJMrMJNrNJOrOJPrPJQrQJRrRJSrSJTrTJUrUJVrVJWrWJXrXJYrYJZrZJ[r[ SSK\J]r] SSK^J_r_J`r`JaraJbrbJcrcJdrdJereJfrfJgrg SSK^Jhri SSK^Jjrk SSK^Jlrm SSKnJoroJprpJqrq SSKrJsrs SSKtJuru SSKvJwrw SSKxJyry SSKzJ{r{ SSK|J}r} SSK~Jr SSKJr SSKJr SS KJrJr \GR"\5 SS!KJrJr SSS5 \(a\GR"\5 SSKJr SSS5 SS"KJrJrJr SSKrSSKJr SS#KJrJrJr SS$KJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJr SS%K5Jr \GR`S&:aSS'KJr OSS'KJr \GR`S(:aSS)KJ/r/ O%SS)KJ/r/ O\6(a\GRh\r\=\l\\\S*S+S,S-S.S/S0S14 r\"S2S*55rS4S3jrg!,(df  GN=f!,(df  N=f)5) annotationsN)IterableSequence) nullcontext)datedatetimetime timedelta)Decimal) TYPE_CHECKINGAnyCallableClassVarLiteralNoReturnUnionoverload) functions)arrow_to_pyseriesdataframe_to_pyseriesiterable_to_pyseriesnumpy_to_pyseriespandas_to_pyseriessequence_to_pyseriesseries_to_pyseries) date_to_intdatetime_to_int time_to_inttimedelta_to_int)deprecate_renamed_parameter deprecatedissue_deprecation_warningget_series_item_by_key)unstable) BUILDING_SPHINX_DOCS _is_generator no_default parse_versionqualified_type_namerequire_same_type scale_bytessphinx_accessorwarn_null_comparison)wrap_dfwrap_s)ArrayBoolean CategoricalDateDatetimer DurationEnumFloat32Float64Int32Int64ListNullObjectStringTimeUInt16UInt32UInt64Unknownis_polars_dtype maybe_castnumpy_char_code_to_dtypeparse_into_dtypesupported_numpy_char_code)dtype_to_init_repr) _ALTAIR_AVAILABLE_PYARROW_AVAILABLE_check_for_numpy_check_for_pandas_check_for_pyarrow_check_for_torchaltairimport_optionaltorch)numpy)pandas)pyarrow) ComputeErrorModuleUpgradeRequiredError ShapeError) CompatLevelArrayNameSpaceBinaryNameSpace CatNameSpaceDateTimeNameSpace ListNameSpace) SeriesPlotStringNameSpaceStructNameSpace) expr_dispatch get_ffi_func) PyDataFramePySeries) Collection GeneratorMapping) DataFrameDataTypeExpr)ArrowArrayExportableArrowStreamExportable BufferInfoClosedIntervalComparisonOperatorFillNullStrategyInterpolationMethodIntoExprIntoExprColumnMultiIndexSelectorNonNestedLiteral NullBehaviorNumericLiteralPolarsDataType PythonLiteralQuantileMethod RankMethod RoundModeSearchSortedSide SeriesBuffersSingleIndexSelectorSizeUnitTemporalLiteral) NoDefault) )Self)r )r!Seriespa.Arrayzpa.ChunkedArraynp.ndarray[Any, Any]pd.Series[Any]zpd.DatetimeIndexrtruc !\rSrSr%SrSrS\S'1SkrS\S'GSS S S .GSS jjjr\ GSSj5r \ \ "S5GSSj55r \ GSSj5r \ GSSj5rGSSjrGSSjrGSSjr\ GSSj5r\ GSGSSjj5r\GSSj5r\GSSj5r\GSSj5r\GSSj5r\GSSj5rGSSjrGSSjrGSSjrGSS jrGSS!jrGSS"jr \!GSS#j5r"\!GSS$j5r"GSS%jr"\!GSS&j5r#\!GSS'j5r#GSS(jr#\!GSS)j5r$\!GSS*j5r$GSS+jr$\!GSS,j5r%\!GSS-j5r%GSS.jr%\!GSS/j5r&\!GSS0j5r&GSS1jr&\!GSS2j5r'\!GSS3j5r'GSS4jr'GSS5jr(\!GSS6j5r)\!GSS7j5r)GSS8jr)\!GSS9j5r*\!GSS:j5r*GSS;jr*\!GSS<j5r+\!GSS=j5r+GSS>jr+\!GSS?j5r,\!GSS@j5r,GSSAjr,\!GSSBj5r-\!GSSCj5r-GSSDjr-\!GSSEj5r.\!GSSFj5r.GSSGjr.\!GSSHj5r/\!GSSIj5r/GSSJjr/\!GSSKj5r0\!GSSLj5r0GSSMjr0\!GSSNj5r1\!GSSOj5r1GSSPjr1\!GSSQj5r2\!GSSRj5r2GSSSjr2\!GSSTj5r3\!GSSUj5r3GSSVjr3\!GSSWj5r4\!GSSXj5r4GSSYjr4\!GSSZj5r5\!GSS[j5r5GSS\jr5\!GSS]j5r6\!GSS^j5r6GSS_jr6GSS`jr7\!GSSaj5r8\!GSSbj5r8\!GSScj5r8GSSdjr8\!GSSej5r9\!GSSfj5r9GSSgjr9GSShjr:\!GSSij5r;\!GSSjj5r;GSSkjr;\!GSSlj5r<\!GSSmj5r\!GSSqj5r>\!GSSrj5r>GSSsjr>\!GSStj5r?\!GSSuj5r?GSSvjr?GSSwjr@GSSxjrAGSSyjrBGSSzjrCGSS{jrDGSS|jrEGSS}jrFGSS~jrGGSSjrHGSSjrIGSSjrJGSSjrKGSSjrLGSSjrMGSGSSjjrNGSSjrOGSSjrP\!GSSj5rQ\!GSSj5rQGSSjrQGSSjrRGSGSSjjrSGSSjrTGSGSSjjrUGSSjrVGSGSSjjrWGSGSSjjrXGSSjrYGSSjrZ\!SS.GSSjj5r[\!GSSj5r[S S.GSSjjr[\!SS.GSSjj5r\\!GSSj5r\S S.GSSjjr\\]R4GSSjjr_GSSjr`GSSjraGSSjrbGSSjrcGSSjrdGSGSSjjreGSGSSjjrfGSSjrgGSSjrhGSSjriGSSjrjGSSjrkGSSjrlGSSjrmGSSjrnGSGSSjjroGSGSSjjrpGSSjrqGSGSSjjrrSS S S.GSSjjrs\t"5SS S S.GSSjj5ru\t"5SS S S S.GSSjj5rvGSSjrwGSSjrx\t"5GSSS S S.GSSjjj5ryS S SS S.GSSjjrzGSSjr{\]R4S S.GSSjjjr|\t"5\}"SSSS9SS S.GSSjj55r~GSSjrGSSjrGSSjrGSSjrS S.GSSjjrS S.GSSjjrS S.GSSjjrS S.GSSjjrS S.GSSjjrGSGSSjjrGSSjrGSSjrGSSjrGSGSSjjrGSGSSjjrGSGSSjjrGSGSSjjrS S S S S.GSSjjrGSGSSjjrGSS S.GSSjjjrGSGSSjjrGSS S.GSSjjjrS S S.GSSjjrGSSjrGSSjrGSSjr\!GSSS.GSSjjj5r\!GSSS.GSSjjj5rGSS S.GSSjjjrS S.GSSjjrGSSjrGSSjrGSSjr\ "S5GSSj5rGSSjrS S S.GSSjjrGSSjrGSSjrGSSjrGSSjrGSSjrGSSjrGSSjrS S.GSSjjrGSSjrGSSjrGSSjrGSSjrGSSjrGSGSjr\}"S GSGSS9S S S GS.GSGSjj5rS S GS.GSGSjjrGSGSjrGSGSjrS GS .GSGS jjrGSGS jrGSGSGS jjrGS GSS GS.GSGSjjrS S SSGS.GSGSjjr\t"5GSGSGSjj5r\t"5GSGSj5r\}"GSGSGSS9SGS.GSGSjj5rS GS.GSGSjjrGS GS GSjjrGSGSjrGSGSjrGS GSjrGS GS jrGS GS!jrGSGSGS"jjrGSGS#jrGSGS$jrGSGSGS%jjrGSGSGS&jjrGSGSGS'jjrGSGS(jrGSGS)jrGSGSGS*jjrGSGS+jrGSGS,jrGSGS-jrGSGS.jrGSGS/jrGSGS0jrGSGS1jrGSGS2jrGSGS3jrGSGS4jrGSGS5jrGSGS6jrGSGS7jrGSGS8jrGSGS9jrGSGS:jrGSGS;jrGSS GS<.GSGS=jjjrGSSGS>.GSGS?jjjrGSGS@jr\t"5SGSAGSB.GSGSCjj5r\}"SSSS9GSSS GSD.GSGSEjjj5r\t"5SGSAGSB.GSGSFjj5r\}"SSSS9GSSS GSD.GSGSGjjj5r\t"5SGSAGSB.GSGSHjj5r\}"SSSS9GSSS GSD.GSGSIjjj5r\t"5SGSAGSB.GSGSJjj5r\}"SSSS9GSSS GSD.GSGSKjjj5r\t"5SGSASGSL.GSGSMjj5r\}"SSSS9GSSS SGSN.GSGSOjjj5r\t"5SGSASGSL.GSGSPjj5r\}"SSSS9GSSS SGSN.GSGSQjjj5r\t"5\}"SSSS9GSSS GSD.GSGSRjjj55r\t"5SGSAGSB.GSGSSjj5r\t"5\}"SSSS9GSSS GSD.GSGSTjjj55r\t"5SSGSAGSU.GSGSVjj5r\t"5\}"SSSS9GSSS GSD.GSGSWjjj55r\t"5S SS GSX.GS GSYjj5r\t"5S S SS GSZ.GS!GS[jj5rGSSS S SGS\.GS"GS]jjjrGSGS^jrGSGS_jrGSGS`jrS GS .GS#GSajjrGS$GS%GSbjjrS GSc.GS&GSdjjrGS'GS(GSejjrGS)GSfjrGSGSgjrGS*S SGSh.GS+GSijjjrGS,GS-GSjjjrGSGS.GSkjjrS GSl.GS/GSmjjrS S GSn.GS0GSojjGrGSGS1GSpjjGrGSGSqjGrGSGSrjGrG\4G\SGSs.GS2GStjjjGrG\4G\SGSs.GS2GSujjjGrGS3GSvjGrGSGS4GSwjjGr\}"SSSS9SSSSS SS GSx.GS5GSyjj5Gr GS6GSzjGr \}"SSSS9SSSSS S SS GS{.GS7GS|jj5Gr \}"SSSS9SSSSS S SS GS{.GS7GS}jj5Gr GS8GS~jGr S S.GS9GSjjGrGS:GSjGrGSGSjGrGS;GSjGrGSGSjGrGSGSjGrGSGSjGrGSGSjGrGSGSjGrGSGSjGrGSGSjGrGSGSjGrGSGSjGrGSGSjGrGSGSjGrGSGSjGrGSGSjGrS SSGS.GSGSjGr!\GS?GSj5Gr"\GS@GSj5Gr#\GSAGSj5Gr$\GSBGSj5Gr%\GSCGSj5Gr&\GSDGSj5Gr'\GSEGSj5Gr(\\t"5GSFGSj55Gr)GSGr*g(Gra A Series represents a single column in a Polars DataFrame. Parameters ---------- name : str, default None Name of the Series. Will be used as a column name when used in a DataFrame. When not specified, name is set to an empty string. values : ArrayLike, default None One-dimensional data in various forms. Supported are: Sequence, Series, pyarrow Array, and numpy ndarray. dtype : DataType, default None Data type of the resulting Series. If set to `None` (default), the data type is inferred from the `values` input. The strategy for data type inference depends on the `strict` parameter: - If `strict` is set to True (default), the inferred data type is equal to the first non-null value, or `Null` if all values are null. - If `strict` is set to False, the inferred data type is the supertype of the values, or :class:`Object` if no supertype can be found. **WARNING**: A full pass over the values is required to determine the supertype. - If no values were passed, the resulting data type is :class:`Null`. strict : bool, default True Throw an error if any value does not exactly match the given or inferred data type. If set to `False`, values that do not match the data type are cast to that data type or, if casting is not possible, set to null instead. nan_to_null : bool, default False In case a numpy array is used to create this Series, indicate how to deal with np.nan values. (This parameter is a no-op on non-numpy data). Examples -------- Constructing a Series by specifying name and values positionally: >>> s = pl.Series("a", [1, 2, 3]) >>> s shape: (3,) Series: 'a' [i64] [ 1 2 3 ] Notice that the dtype is automatically inferred as a polars Int64: >>> s.dtype Int64 Constructing a Series with a specific dtype: >>> s2 = pl.Series("a", [1, 2, 3], dtype=pl.Float32) >>> s2 shape: (3,) Series: 'a' [f32] [ 1.0 2.0 3.0 ] It is possible to construct a Series with values as the first positional argument. This syntax considered an anti-pattern, but it can be useful in certain scenarios. You must specify any other arguments through keywords. >>> s3 = pl.Series([1, 2, 3]) >>> s3 shape: (3,) Series: '' [i64] [ 1 2 3 ] Nrm_s>dtarrbincatstrlistplotstructzClassVar[set[str]] _accessorsTFstrict nan_to_nullrcU[:XaSnOUb[U5(d [U5nSnUcSnO-[U[5(aUnOUcUnSnO Sn[ U5e[U[ 5(a[UUUUUS9UlgUc[U/US9Ulg[U5(Ga-[U[R5(Ga [XXES9UlURR[R[R 4;a[#SUR5n[#X2R5nUbuUR%USS9R%U5R'[R("[R*"U55R-5S5RUlgUbUR%X4S9RUlgg[/U5(a^[U[0R25(a?[XR5SS9XES9UlUbUR%X4S9RUlgg[7U5(a?[U[8R:[8R<45(a[?XX4S 9Ulg[AU5(aN[U[BRD[BRF[BRH45(a[KXX4S 9Ulg[MUS 5(d [OU5(a[QXX4S 9Ulg[U[D5(a[SXbX4S 9Ulg[U[TRV5(a[YXbX4S 9Ulg[MUS 5(a[ZR\"U5Ulg[MUS 5(a[ZR^"U5UlgS [U5R`<S 3n[ U5e)NzSeries name must be a string)dtyperrrrF)r)force)rr__arrow_c_stream____arrow_c_array__z0Series constructor called with unsupported type z for the `values` parameter)1rDrErH isinstancer TypeErrorrrrrMnpndarrayrrtype datetime64 timedelta64_resolve_temporal_dtypecastscatterargwhereisnatflattenrPrSTensorrTrOpar1 ChunkedArrayrrNpdrIndex DatetimeIndexrhasattrr'rrplrqrrmfrom_arrow_c_arrayfrom_arrow_c_stream__name__) selfnamevaluesrrr original_namemsg input_dtypes gC:\Users\julio\OneDrive\Documentos\Trabajo\Ideas Frescas\venv\Lib\site-packages\polars/series/series.py__init__Series.__init__sD G E  u'='=$U+E%) <D c " " M~4n$ fh ' '*' DG^*45ADG f % %*VRZZ*H*H'VDG||  R]]BNN$CC5dFLLI /||D$ +e <e RXXf-=!>!F!F!H$O G ))E)9<<!f % %*VU\\*J*J'lll/DG ))E)9<<!  ' 'J RXXr/- - (EQDG v & &: RYY"*:*:;, , )URDG!566=;P;P*4uTDG  ' '(UDG - -+UDGV0 1 111&9DG V1 2 2226:DGC4>> s = pl.Series("a", [1, 2, 3]) >>> s.dtype Int64 )rrrs rr Series.dtypeVsww}}rcURR5URR5S.nUR[:XaURR 5US'U$)z Get flags that are set on the Series. Examples -------- >>> s = pl.Series("a", [1, 2, 3]) >>> s.flags {'SORTED_ASC': False, 'SORTED_DESC': False} ) SORTED_ASC SORTED_DESC FAST_EXPLODE)ris_sorted_ascending_flagis_sorted_descending_flagrr<can_fast_explode_flag)routs rflags Series.flagscsU''::<77<<>  :: "&''"?"?"AC  rc6URR5$)zb Get the name of this Series. Examples -------- >>> s = pl.Series("a", [1, 2, 3]) >>> s.name 'a' )rrrs rr Series.namevsww||~rc8URR54$)z] Shape of this Series. Examples -------- >>> s = pl.Series("a", [1, 2, 3]) >>> s.shape (3,) rlenrs rshape Series.shapes rcSn[U5e)Nathe truth value of a Series is ambiguous Here are some things you might want to try: - instead of `if s`, use `if not s.is_empty()` - instead of `s1 and s2`, use `s1 & s2` - instead of `s1 or s2`, use `s1 | s2` - instead of `s in [y, z]`, use `s.is_in([y, z])` )rrrs r__bool__Series.__bool__s B nrc6URR5$r)r __getstate__rs rrSeries.__getstate__sww##%%rcl[5RUlURRU5 gr)rr __setstate__)rstates rr!Series.__setstate__s!(++ U#rcURR5nURSURRS5$)Nr)ras_strreplace __class__r)rs_reprs r__str__Series.__str__s2ggnn&~~h4>>+B+B*CaHHrc"UR5$r)r*rs r__repr__Series.__repr__s||~rc"UR5$rrrs r__len__Series.__len__xxzrcgrrrothers r__and__Series.__and__,/rcgrrr5s rr7r8-0rc[U[R5(a[R"U5U-$[U[ 5(d [ U/5nUR URRUR55$r) rrrsFlitrrrbitandr5s rr7r8` eRWW % %55;& &%((E7OE""477>>%((#;<rr5s rrBrCF eRWW % %155;& &%((E7OE|rcgrrr5s r__or__ Series.__or__+.rcgrrr5s rrJrKr9rc[U[R5(a[R"U5U-$[U[ 5(d [ U/5nUR URRUR55$r) rrrsr=r>rrrbitorr5s rrJrKs` eRWW % %55;& &%((E7OE""477==#:;;rcgrrr5s r__ror__Series.__ror__r9rcgrrr5s rrQrRr;rc[U[R5(aU[R"U5-$[U[ 5(d [ U/5nX-$rrGr5s rrQrRrHrcgrrr5s r__xor__Series.__xor__r9rcgrrr5s rrVrWr;rc[U[R5(a[R"U5U- $[U[ 5(d [ U/5nUR URRUR55$r) rrrsr=r>rrrbitxorr5s rrVrWr@rcgrrr5s r__rxor__Series.__rxor__r;rcgrrr5s rr\r]rErc[U[R5(aU[R"U5- $[U[ 5(d [ U/5nX- $rrGr5s rr\r]rHrc UR[:Xa\[U[5(aGUS;aAUSLaUS:Xd USLaUS:XaUR 5$USLaUS:Xd USLa US:XaU)$GOG[U[ 5(anURR 5(aOUR[5n[US-[UR5nUceURU"U55$[U[5(GaUR[:XaUR[S55nSnOUR[:XanURRn[!UR"5[!U5:waSUR"<S U<3n[%U5eURR&nOS UR3n[)U5e[+X5n[US-[,UR5nUceURU"U55$[U[.5(aYUR[0:XaE[3U5n[US-[,UR5nUceURU"U55$[U[45(aoUR[6:Xa[URR&n[9X5n [US-[,UR5nUceURU"U 55$UR[:[<4;a"[U[>5(d [?U/5nOn[U[@5(aYUR[:XaE[CU5n[US-[DUR5nUceURU"U55$[U[F5(am[U[ 5(dXUR[H[J4;aU/n[?S U5nUR[L:XaURUR5 [U[>5(a5UR[OURU5"UR55$[US-URUR5nUcS URS US3n[QU5eUb[SXR5nURU"U55$![Pa SnN^f=f)N)eqneqTraFrbz_<>uszdatetime time zone z does not match Series timezone z3cannot compare datetime.datetime to Series of type rSeries of type z does not have z operator)*rr2rboolclonefloat is_integerrr9rkrrrr4r5 time_zonertzinfor time_unit ValueErrorrr;r r@rr r6rr3r7rrrr:rr<r1r=getattrNotImplementedErrorrF) rr6opfrkrirtsdtds r_comp Series._comps :: Zt%<%<}AT "*%5.R5[zz|#5.R4ZUd]rU{u u % %$***?*?*A*A99W%DR%Z$'':A= =&&qx0 0 x ( (zzT!yy$0 x' JJ00 u||$I6/ /??_`i_lmC#C.( JJ00 KDJJ<X o% 2BR%Z8A= =&&qu- - t $ $t);E"AR%Z8A= =&&qt, , y ) )djjH.D ,,I!%3BR%Z8A= =&&qu- - ZZK. .z%7P7PE7OE t $ $t);E"AR%Z8A= =&&qt, , eX & &z%/E/EzzdE]*2u%E{{d" 4::& eV $ $&&wtww';EHH'EF F R%ZTWW=A 9#DJJ<rd)LC%c* *  ujj1E""1U8,,# A s$S99 TTcgrrr5s r__eq__ Series.__eq__IrLrcgrrr5s rrwrxL/2rc[U5 [U[R5(a%[R "U5R U5$URUS5$)Nra)r.rrrsr=r>rwrtr5s rrwrxOEU# eRWW % %55;%%e, ,zz%&&rcgrrr5s r__ne__ Series.__ne__UrLrcgrrr5s rr~rXrzrc[U5 [U[R5(a%[R "U5R U5$URUS5$)Nrb)r.rrrsr=r>r~rtr5s rr~r[sEU# eRWW % %55;%%e, ,zz%''rcgrrr5s r__gt__ Series.__gt__arLrcgrrr5s rrrdr9rc[U5 [U[R5(a%[R "U5R U5$URUS5$)Ngt)r.rrrsr=r>rrtr5s rrrgr|rcgrrr5s r__lt__ Series.__lt__mrLrcgrrr5s rrrpr9rc[U5 [U[R5(a%[R "U5R U5$URUS5$)Nlt)r.rrrsr=r>rrtr5s rrrsr|rcgrrr5s r__ge__ Series.__ge__yrLrcgrrr5s rrr|r9rc[U5 [U[R5(a%[R "U5R U5$URUS5$)Ngt_eq)r.rrrsr=r>rrtr5s rrrEU# eRWW % %55;%%e, ,zz%))rcgrrr5s r__le__ Series.__le__rLrcgrrr5s rrrr9rc[U5 [U[R5(a%[R "U5R U5$URUS5$)Nlt_eq)r.rrrsr=r>rrtr5s rrrrrcgrrr5s rle Series.le'*rcgrrr5s rrr(+rc$URU5$)z;Method equivalent of operator expression `series <= other`.)rr5s rrr{{5!!rcgrrr5s rr Series.ltrrcgrrr5s rrrrrc$URU5$)z:Method equivalent of operator expression `series < other`.)rr5s rrrrrcgrrr5s rra Series.eqrrcgrrr5s rrarrrc$URU5$)z;Method equivalent of operator expression `series == other`.)rwr5s rrarrrcgrrr5s r eq_missingSeries.eq_missingrzrcgrrr5s rrr03rc>[U[R5(a%[R"U5R U5$UR 5R[R"UR5R U55R5$)a Method equivalent of equality operator `series == other` where `None == None`. This differs from the standard `eq` where null values are propagated. Parameters ---------- other A literal or expression value to compare with. See Also -------- ne_missing eq Examples -------- >>> s1 = pl.Series("a", [333, 200, None]) >>> s2 = pl.Series("a", [100, 200, None]) >>> s1.eq(s2) shape: (3,) Series: 'a' [bool] [ false true null ] >>> s1.eq_missing(s2) shape: (3,) Series: 'a' [bool] [ false true true ] ) rrrsr=r>rto_frameselectcolr to_seriesr5s rrrgJ eRWW % %55;))%0 0}}%%aeeDII&6&A&A%&HISSUUrcgrrr5s rne Series.nerrcgrrr5s rrrrrc$URU5$)z;Method equivalent of operator expression `series != other`.)r~r5s rrrrrcgrrr5s r ne_missingSeries.ne_missingrzrcgrrr5s rrrrrc>[U[R5(a%[R"U5R U5$UR 5R[R"UR5R U55R5$)a Method equivalent of equality operator `series != other` where `None == None`. This differs from the standard `ne` where null values are propagated. Parameters ---------- other A literal or expression value to compare with. See Also -------- eq_missing ne Examples -------- >>> s1 = pl.Series("a", [333, 200, None]) >>> s2 = pl.Series("a", [100, 200, None]) >>> s1.ne(s2) shape: (3,) Series: 'a' [bool] [ true false null ] >>> s1.ne_missing(s2) shape: (3,) Series: 'a' [bool] [ true false false ] ) rrrsr=r>rrrrrrr5s rrrrrcgrrr5s rge Series.gerrcgrrr5s rrrrrc$URU5$)z;Method equivalent of operator expression `series >= other`.)rr5s rrrrrcgrrr5s rr Series.gt!rrcgrrr5s rrr$rrc$URU5$)z:Method equivalent of operator expression `series > other`.)rr5s rrr'rrc[U[R5(a.UR5R U5R 5nOUc[R "SS/5n[U[ 5(a5UR[URU5"UR55$[U5(a][U[R5(a>UR[URU5"[ U5R55$[U[[[[ ["45(aUR$R'5(dr[)UR*U/5nSU;a*UR[XB5"UR55$UR[URU5"U55$UR$R-5(a[U[.[045(a[U[05(aI[)UR*U/5nURU5R3[5SS95RnO[)UR*U/[4S9nSU;a*UR[XB5"UR55$UR[URU5"U55$[7XR$5n[9X0R$UR5nUc2SUR$<S[;U5R<<3n[?U5eURU"U55$)Nrrhsr)scalerz+cannot do arithmetic with Series of dtype: z and argument of type: ) rrrsr select_seqrrrrmrrMrrrgrrr rris_floatrr is_decimal PyDecimalintrr rFrkrrr)rr6op_sop_ffirrrprs r _arithmeticSeries._arithmetic+s| eRWW % %MMO..u5??AE ]IIb4&)E eV $ $&&wtww'=ehh'GH H e $ $E2::)F)F&&wtww'=fUm>N>N'OP P uudHiE F FJJ''))%dii%9B**72+)rrrrrqrsr=r>rrrgrrrrrrrr5s rrr_s eS ! !2w'E r|| , ,<  rww ' '55;& & :: " "z%%'F'F==?))!%% *:U*BCMMO Ouh77rcgrrr5s r__sub__Series.__sub__jr9rcgrrr5s rrrmrLrc[U[R5(a[R"U5U- $UR R 5(ai[U[[45(aNUR5R[R"UR5U- 5R5$URUSS5$)Nsubzsub_<>)rrrsr=r>rrrgrrrrrrrr5s rrrps eRWW % %55;& & :: " "z%%'F'F==?))!%% *:U*BCMMO Ouh77rcZ^^SUU4SjjmURT"UR55$)zt Convert leaf dtype the to given primitive datatype. This is equivalent to logic in DataType::cast_leaf() in Rust. c>[U[5(a$[T"UR5URS9$[U[5(a[ T"UR55$T$)N)r)rr1innerrr<)rconvert_to_primitive leaf_dtypes rr=Series._recursive_cast_to_dtype..convert_to_primitive~sS%''1%++>ekkRR%&&0=>> r)rrreturnr)rr)rrrs `@r_recursive_cast_to_dtypeSeries._recursive_cast_to_dtypews(  yy-djj9::rcgrrr5s r __truediv__Series.__truediv__rrcgrrr5s rrr14rc[U[R5(a[R"U5U- $UR R 5(a,[UR [5(d Sn[U5e[U[[45(aUR R5(d[UR [5(aNUR5R[R"UR5U- 5R!5$UR R#5(dUR R5(dd[UR [$[&[45(d:[U[(5(a'[UR [$[&45(aUOUR+[-55nUR/USS5$)N5first cast to integer before dividing datelike dtypesdivzdiv_<>)rrrsr=r>r is_temporalr6rrrgrrrrrrrr<r1rrr9rrr6rs rrrsS eRWW % %55;& & :: ! ! # #Jtzz8,L,LICC. ec5\ * * JJ ! ! # #z$**h'G'G==?))!%% *:U*BCMMO O  ##%%::((**djj4*ABBuf--*U[[4QV-2X2X ..wy9 uh77rcgrrr5s r __floordiv__Series.__floordiv__rrcgrrr5s rrrs25rc[U[R5(a[R"U5U-$UR R 5(a Sn[U5eUR R5(ai[U[[45(aNUR5R[R"UR5U-5R5$[U[R5(d[R"U5nUR5R![R"UR5U-5R5$Nr)rrrsr=r>rrrrrgrrrrrrrrs rrrs eRWW % %55;%' ' :: ! ! # #ICC. :: " "z%%'F'F==?))!%% *:e*CDNNP P%))EE%LE}}))!%% *:e*CDNNPPrc"UR5$r)not_rs r __invert__Series.__invert__syy{rcgrrr5s r__mul__Series.__mul__r9rcgrrr5s rrrrrcgrrr5s rrrr;rc[U[R5(a[R"U5U-$UR R 5(a,[UR [5(d Sn[U5e[U[[45(aUR R5(d[UR [5(aNUR5R[R"UR5U-5R!5$[U[R"5(aX-$UR%USS5$Nz8first cast to integer before multiplying datelike dtypesmulzmul_<>)rrrsr=r>rrr6rrrgrrrrrrrqrrs rrrs eRWW % %55;& & :: ! ! # #Jtzz8,L,LLCC. ec5\ * * JJ ! ! # #z$**h'G'G==?))!%% *:U*BCMMO O r|| , ,< ##E5(; ;rcgrrr5s r__mod__Series.__mod__r9rcgrrr5s rr r r;rc[U[R5(a%[R"U5R U5$UR R5(a Sn[U5eUR R5(ai[U[[45(aNUR5R[R"UR5U-5R!5$UR#USS5$)N?first cast to integer before applying modulo on datelike dtypesremzrem_<>)rrrsr=r>r rrrrrgrrrrrrrrs rr r s eRWW % %55;&&u- - :: ! ! # #SCC. :: " "z%%'F'F==?))!%% *:U*BCMMO Ouh77rcURR5(a Sn[U5eURUSS5$)Nr rz rem_<>_rhsrrrrrs r__rmod__Series.__rmod__s9 :: ! ! # #SCC. ul;;rcb[U[5(d:[U[[45(amURR 5(aNUR 5RU[R"UR5-5R5$URUSS5$)Nrz add_<>_rhs) rrrrgrrrrr=rrrrr5s r__radd__Series.__radd__sy eS ! ! usEl + + 0E0E0G0G==?))%!%% 2B*BCMMO Oul;;rc8[U[[45(amURR 5(aNUR 5R U[R"UR5- 5R5$URUSS5$)Nrz sub_<>_rhs) rrrgrrrrr=rrrrr5s r__rsub__Series.__rsub__sl ec5\ * *tzz/D/D/F/F==?))%!%% 2B*BCMMO Oul;;rcRURR5(a Sn[U5eURR5(aUR U5 [ U[ [45(amURR5(aNUR5RU[R"UR5- 5R5$[ U[ 5(a [U5nUR[ 5R U5$r)rrrr __rfloordiv__rrrgrrrr=rrrrr9rs r __rtruediv__Series.__rtruediv__s :: ! ! # #ICC. ::     u % ec5\ * *tzz/D/D/F/F==?))%!%% 2B*BCMMO O eS ! !%LEyy!//66rcURR5(a Sn[U5eURUSS5$)Nrrz div_<>_rhsrrs rrSeries.__rfloordiv__s9 :: ! ! # #ICC. ul;;rc URR5(a,[UR[5(d Sn[ U5e[U[ [ 45(aURR5(d[UR[5(aNUR5RU[R"UR5-5R5$URUSS5$r)rrrr6rrrgrrrr=rrrrrs r__rmul__Series.__rmul__ s :: ! ! # #Jtzz8,L,LLCC. ec5\ * * JJ ! ! # #z$**h'G'G==?))%!%% 2B*BCMMO Ouh77rc$URU5$r)powrexponents r__pow__Series.__pow__sxx!!rcUR5RU[R"UR5-R UR55R 5$r)rrr=rraliasrr5s r__rpow__Series.__rpow__sB MMO Z!%% "2299$))D E Y[ rc[U[5(d/[U5(a*[U[R5(a [ U5nUR U5$rrrrMrrrdotr5s r __matmul__Series.__matmul__sC eX & & U # # 5"**(E(E5MExxrc[U[5(d/[U5(a*[U[R5(a [ U5nUR U5$rr-r5s r __rmatmul__Series.__rmatmul__'sA eX & & U # # 5"**(E(E5MEyyrcUR5R[R"UR5*5R 5$r)rrr=rrrrs r__neg__Series.__neg__.s2}}))155+;*;<FFHHrcU$rrrs r__pos__Series.__pos__1s rc"UR5$r)absrs r__abs__Series.__abs__4r3rc"UR5$rrfrs r__copy__Series.__copy__7zz|rc"UR5$rr?)rmemos r __deepcopy__Series.__deepcopy__:rBrcUcUR5$UR5RRU5R 5$r) has_nullsimplodercontainsitem)rrKs r __contains__Series.__contains__=s: <>># #||~""++D16688rc#\# UR[[4;aAURRn[ UR 55H nU"U5v M gSn[ SUR 5U5H*nURXC5R5ShvN M, gN 7f)Niar) rr<r1r get_indexrangersliceto_list)rrOidx buffer_sizeoffsets r__iter__Series.__iter__Bs ::$ &))ITXXZ(n$)!K488:{;::f:BBDDD<DsBB, B*! B,cgrrrkeys r __getitem__Series.__getitem__OsArc[X5$)a Get part of the Series as a new Series or scalar. Parameters ---------- key Row(s) to select. Returns ------- Series or scalar, depending on `key`. Examples -------- >>> s = pl.Series("a", [1, 4, 2]) >>> s[0] 1 >>> s[0:2] shape: (2,) Series: 'a' [i64] [ 1 4 ] r#rYs rr[r\Us8&d00rc [U[5(a'[U[5(dURX5 g[U[5(a[U[ 5(dlUR R5(dUR R5(aURX5 gSUR <S3n[U5e[U[5(aUR [:Xa!URX5RUl gUR [:Xa5URUR[ 5U5RUl gUR [ :Xa!URX5RUl gg[#U5(a[U[$R&5(aUR [$R(:Xa=UR[$R*"U5SS2S4U5RUl gUR-[.R0"S[$R2"U[$R45SS95nUR7XB5 g[U[8[:45(a0UR-[=SU[ S95nUR7XB5 gSU<S 3n[U5e) Nzcannot set Series of dtype: z- with list/tuple as value; use a scalar valuerrT)_strictrz cannot use "z" for indexing)rrrerrrr is_numericrrrr2setrrCrrBrMrrbool_rrrmnew_u32arrayuint32 __setitem__rtupler)rrZvaluerrs rrgSeries.__setitem__ss  c3   3(=(= LL $ x ( (E31G1Gzz$$&&$***@*@*B*B S(.tzzn=&& C. c6 " "yyG#((3.11f$,,sxx'7?BBf$,,s255%c " "z#rzz'B'ByyBHH$,,r{{3'71'=uEHH''$$R#ryy)A4P  * dE] + +##$8S$OPA   Q & ~6CC. rcUc?UR5(d*UR[:Xa[R"S5nUcSup4O%USLaSup4OUSLaSup4OSU<3n[ U5eUR X4S9nUbCXR:wa4USLaS URS US 3n[ U5eURU5nU$) aW Return a NumPy ndarray with the given data type. This method ensures a Polars Series can be treated as a NumPy ndarray. It enables `np.asarray` and NumPy universal functions. See the NumPy documentation for more information: https://numpy.org/doc/stable/user/basics.interoperability.html#the-array-method See Also -------- __array_ufunc__ U)FTT)TTF)FFzinvalid input for `copy`: writable allow_copyzcopy not allowed: cast from z to z prohibited)rHrr?rrto_numpy RuntimeError __array__)rrcopyrnrorrs rrrSeries.__array__s& =!1!1djjF6JHHSME <#. Hj T\#- Hj U]#/ Hj.th7CC. mmXmE  ))!3u}4SYYKtE7+V"3''--&C rc\^^^^URR5S:aURRSS9 URnUS:XGaHTRS:wa Sn[ U5e/mUHn[ U[ [[R45(aTRU5 M@[ U[5(arUR5nURR5S:aURRSS9 TRURR55 MS[U5<SU<3n[U5e [R "T6R"n TR$V s/sHn ['U S5(dMU SPM n n U H"n [R("X5(dM U n O S T;a/[R*"TR-S 55R"OU m[/TR05n U (acUR35(a S n[5U5eTR0ceTR0R7S 5upUS :Xa T"TS T0TD6$X:HnOSn[9S [;T5U5nUcS[;T5S3n[ U5eU"UUUU4SjU5nUR=U5nU (aU$UR?5nUH-n[ U[5(dMUUR?5-nM/ URA5RC[DRF"U5RI[DRJ"URL555ROS5$SU<S3n[ U5es sn f)zNumpy universal functions.r%Tin_place__call__z2only ufuncs that return one 1D array are supportedzunsupported type z for rzcan't pass a Series with missing data to a generalized ufunc, as it might give unexpected results. See https://docs.pola.rs/user-guide/expressions/missing-data/ for suggestions on how to remove or fill in missing data.z->z()zapply_ufunc_<>zcould not find `apply_ufunc_`c>T"TUTS.TD6$)N)rrr)rargs dtype_charkwargsufuncs r(Series.__array_ufunc__..#sE4S MfMrrzBonly `__call__` is implemented for numpy ufuncs on a Series, got `)(rn_chunksrechunknoutrnrrrgrrappendr to_physical to_numpy_viewr*r result_typechartypesrIcan_castrpopre signaturerHrWsplitrkrGr is_not_nullrrr=whenthenrrr)rrmethodinputsr~rrargphys_argdtype_char_minimuminput_output_type dtypes_ufunc dtype_ufuncis_generalized_ufunc ufunc_input ufunc_outputallocate_outputrprresult validity_maskr|r}s ` ` @@r__array_ufunc__Series.__array_ufunc__sT 77    ! GGOOTO * GG Z zzQJ)#..=?DcC #;<<KK$V,,"0H{{++-1 ++T+:KK 9 9 ;<-.A#.F-IsgVC#C.(')nnd&;&@&@ */)4%,->r-BC&!"%)4  , ;;1??)4& ,f$G,-22' $(#8 #>>##wC&s++ 222,1OO,A,A$,G) 4'!$CjCFCC&1&AO"&-/G /SUVWAy$$>> s1 = pl.Series("a", [1]) >>> s1.item() 1 >>> s2 = pl.Series("a", [9, 8, 7]) >>> s2.cum_sum().item(-1) 24 r%zlcan only call '.item()' if the Series is of length 1, or an explicit index is provided (Series is of length )r)rrlrrOget_index_signed)rindexrs rrK Series.itemKsh =4yA~NNQRVi[XY[!o%77$$Q' 'ww''..rcLURR5n[X!5$)aK Return an estimation of the total (heap) allocated size of the Series. Estimated size is given in the specified unit (bytes by default). This estimation is the sum of the size of its buffers, validity, including nested arrays. Multiple arrays may share buffers and bitmaps. Therefore, the size of 2 arrays is not the sum of the sizes computed from this function. In particular, [`StructArray`]'s size is an upper bound. When an array is sliced, its allocated size remains constant because the buffer unchanged. However, this function will yield a smaller number. This is because this function returns the visible size of the buffer, not its total capacity. FFI buffers are included in this estimation. Notes ----- For data with Object dtype, the estimated size only reports the pointer size, which is a huge underestimation. Parameters ---------- unit : {'b', 'kb', 'mb', 'gb', 'tb'} Scale the returned size to the given unit. Examples -------- >>> s = pl.Series("values", list(range(1_000_000)), dtype=pl.UInt32) >>> s.estimated_size() 4000000 >>> s.estimated_size("mb") 3.814697265625 )restimated_sizer,)runitszs rrSeries.estimated_sizefs"FWW # # %2$$rcg)a Compute the square root of the elements. Syntactic sugar for >>> pl.Series([1, 2]) ** 0.5 shape: (2,) Series: '' [f64] [ 1.0 1.414214 ] Examples -------- >>> s = pl.Series([1, 2, 3]) >>> s.sqrt() shape: (3,) Series: '' [f64] [ 1.0 1.414214 1.732051 ] Nrrs rsqrt Series.sqrtrcg)a Compute the cube root of the elements. Optimization for >>> pl.Series([1, 2]) ** (1.0 / 3) shape: (2,) Series: '' [f64] [ 1.0 1.259921 ] Examples -------- >>> s = pl.Series([1, 2, 3]) >>> s.cbrt() shape: (3,) Series: '' [f64] [ 1.0 1.259921 1.44225 ] Nrrs rcbrt Series.cbrtrr. ignore_nullscgrrrrs rany Series.anyADrcgrrrs rrr9>> pl.Series([True, False]).any() True >>> pl.Series([False, False]).any() False >>> pl.Series([None, False]).any() False Enable Kleene logic by setting `ignore_nulls=False`. >>> pl.Series([None, False]).any(ignore_nulls=False) # Returns None r)rrrs rrrFww{{ {55rcgrrrs rall Series.allrrcgrrrs rrrrrc4URRUS9$)a Return whether all 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 `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 `None`. .. _Kleene logic: https://en.wikipedia.org/wiki/Three-valued_logic Returns ------- bool or None Examples -------- >>> pl.Series([True, True]).all() True >>> pl.Series([False, True]).all() False >>> pl.Series([None, True]).all() True Enable Kleene logic by setting `ignore_nulls=False`. >>> pl.Series([None, True]).all(ignore_nulls=False) # Returns None r)rrrs rrrrrcg)z Compute the logarithm to a given base. Examples -------- >>> s = pl.Series([1, 2, 3]) >>> s.log() shape: (3,) Series: '' [f64] [ 0.0 0.693147 1.098612 ] Nr)rbases rlog Series.logrrcg)z Compute the natural logarithm of the input array plus one, element-wise. Examples -------- >>> s = pl.Series([1, 2, 3]) >>> s.log1p() shape: (3,) Series: '' [f64] [ 0.693147 1.098612 1.386294 ] Nrrs rlog1p Series.log1p)rrcg)z Compute the base 10 logarithm of the input array, element-wise. Examples -------- >>> s = pl.Series([10, 100, 1000]) >>> s.log10() shape: (3,) Series: '' [f64] [ 1.0 2.0 3.0 ] Nrrs rlog10 Series.log10:rrcg)z Compute the exponential, element-wise. Examples -------- >>> s = pl.Series([1, 2, 3]) >>> s.exp() shape: (3,) Series: '' [f64] [ 2.718282 7.389056 20.085537 ] Nrrs rexp Series.expKrrcg)ar 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 -------- >>> s = pl.Series([1.0, None, 3.0, float("nan")]) >>> s.drop_nulls() shape: (3,) Series: '' [f64] [ 1.0 3.0 NaN ] Nrrs r drop_nullsSeries.drop_nulls\rrcg)a 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 -------- >>> s = pl.Series([1.0, None, 3.0, float("nan")]) >>> s.drop_nans() shape: (3,) Series: '' [f64] [ 1.0 null 3.0 ] Nrrs r drop_nansSeries.drop_nansxrrc[U[5(a.[[UR U5R /55$[[UR /55$)u Cast this Series to a DataFrame. Parameters ---------- name optionally name/rename the Series column in the new DataFrame. Examples -------- >>> s = pl.Series("a", [123, 456]) >>> df = s.to_frame() >>> df shape: (2, 1) ┌─────┐ │ a │ │ --- │ │ i64 │ ╞═════╡ │ 123 │ │ 456 │ └─────┘ >>> df = s.to_frame("xyz") >>> df shape: (2, 1) ┌─────┐ │ xyz │ │ --- │ │ i64 │ ╞═════╡ │ 123 │ │ 456 │ └─────┘ )rrr/rlrenamerrrs rrSeries.to_framesJH dC ; D(9(<(<'=>? ?{DGG9-..rnearestcUR5RUUS9nSS/UlUR[R "S5R 55$)u@ Quick summary statistics of a Series. Series with mixed datatypes will return summary statistics for the datatype of the first value. Parameters ---------- percentiles One or more percentiles to include in the summary statistics (if the Series has a numeric dtype). All values must be in the range `[0, 1]`. interpolation : {'nearest', 'higher', 'lower', 'midpoint', 'linear', 'equiprobable'} Interpolation method used when calculating percentiles. Notes ----- The median is included by default as the 50% percentile. Returns ------- DataFrame Mapping with summary statistics of a Series. Examples -------- >>> s = pl.Series([1, 2, 3, 4, 5]) >>> s.describe() shape: (9, 2) ┌────────────┬──────────┐ │ statistic ┆ value │ │ --- ┆ --- │ │ str ┆ f64 │ ╞════════════╪══════════╡ │ count ┆ 5.0 │ │ null_count ┆ 0.0 │ │ mean ┆ 3.0 │ │ std ┆ 1.581139 │ │ min ┆ 1.0 │ │ 25% ┆ 2.0 │ │ 50% ┆ 3.0 │ │ 75% ┆ 4.0 │ │ max ┆ 5.0 │ └────────────┴──────────┘ Non-numeric data types may not have all statistics available. >>> s = pl.Series(["aa", "aa", None, "bb", "cc"]) >>> s.describe() shape: (4, 2) ┌────────────┬───────┐ │ statistic ┆ value │ │ --- ┆ --- │ │ str ┆ str │ ╞════════════╪═══════╡ │ count ┆ 4 │ │ null_count ┆ 1 │ │ min ┆ aa │ │ max ┆ cc │ └────────────┴───────┘ ) percentiles interpolation statisticri)rdescribecolumnsfilterr=rr)rrrstatss rrSeries.describesTB ((#') %g. ||AEE'N66899rc6URR5$)a Reduce this Series to the 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 `s.sum() if s.count() else None` instead of `s.sum()`. Examples -------- >>> s = pl.Series("a", [1, 2, 3]) >>> s.sum() 6 )rsumrs rr Series.sums&ww{{}rc6URR5$)zm Reduce this Series to the mean value. Examples -------- >>> s = pl.Series("a", [1, 2, 3]) >>> s.mean() 2.0 )rmeanrs rr Series.meansww||~rc6URR5$)a7 Reduce this Series to the product value. 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 `s.product() if s.count() else None` instead of `s.product()`. Examples -------- >>> s = pl.Series("a", [1, 2, 3]) >>> s.product() 6 )rproductrs rrSeries.product%s"ww  rc*[U5(a*[U[R5(a [ U5nUR 5R [R"UR5RU55R5$)ax Raise to the power of the given exponent. If the exponent is float, the result follows the dtype of exponent. Otherwise, it follows dtype of base. Parameters ---------- exponent The exponent. Accepts Series input. Examples -------- Raising integers to positive integers results in integers: >>> s = pl.Series("foo", [1, 2, 3, 4]) >>> s.pow(3) shape: (4,) Series: 'foo' [i64] [ 1 8 27 64 ] In order to raise integers to negative integers, you can cast either the base or the exponent to float: >>> s.pow(-3.0) shape: (4,) Series: 'foo' [f64] [ 1.0 0.125 0.037037 0.015625 ] ) rMrrrrrrr=rrr#rr$s rr# Series.pow8sbP H % %*Xrzz*J*Jh'H}}))!%% *:*>*>x*HISSUUrc6URR5$)zj Get the minimal value in this Series. Examples -------- >>> s = pl.Series("a", [1, 2, 3]) >>> s.min() 1 )rminrs rr Series.mindww{{}rc6URR5$)zj Get the maximum value in this Series. Examples -------- >>> s = pl.Series("a", [1, 2, 3]) >>> s.max() 3 )rmaxrs rr Series.maxprrcUR5R[R"UR5R 55R 5$)aI 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 -------- >>> s = pl.Series("a", [1, 3, 4]) >>> s.nan_max() 4 >>> s = pl.Series("a", [1.0, float("nan"), 4.0]) >>> s.nan_max() nan )rrr=rrnan_maxrKrs rrSeries.nan_max|:"}}))!%% *:*B*B*DEJJLLrcUR5R[R"UR5R 55R 5$)aI 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 -------- >>> s = pl.Series("a", [1, 3, 4]) >>> s.nan_min() 1 >>> s = pl.Series("a", [1.0, float("nan"), 4.0]) >>> s.nan_min() nan )rrr=rrnan_minrKrs rrSeries.nan_minrrr%c8URRU5$)u+ Get the standard deviation of this Series. 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 -------- >>> s = pl.Series("a", [1, 2, 3]) >>> s.std() 1.0 )rstdrddofs rr Series.std"ww{{4  rc8URRU5$)u Get variance of this Series. 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 -------- >>> s = pl.Series("a", [1, 2, 3]) >>> s.var() 1.0 )rvarrs rr  Series.varr rc6URR5$)zh Get the median of this Series. Examples -------- >>> s = pl.Series("a", [1, 2, 3]) >>> s.median() 2.0 )rmedianrs rr Series.mediansww~~rc8URRX5$)a& Get the quantile value of this Series. Parameters ---------- quantile Quantile between 0.0 and 1.0. interpolation : {'nearest', 'higher', 'lower', 'midpoint', 'linear', 'equiprobable'} Interpolation method. Examples -------- >>> s = pl.Series("a", [1, 2, 3]) >>> s.quantile(0.5) 2.0 )rquantile)rrrs rrSeries.quantiles&ww88r_) separator drop_firstrcL[URRXU55$)u Get dummy/indicator variables. Parameters ---------- separator Separator/delimiter used when generating column names. drop_first Remove the first category from the variable being encoded. drop_nulls If there are `None` values in the series, a `null` column is not generated Examples -------- >>> s = pl.Series("a", [1, 2, 3]) >>> s.to_dummies() shape: (3, 3) ┌─────┬─────┬─────┐ │ a_1 ┆ a_2 ┆ a_3 │ │ --- ┆ --- ┆ --- │ │ u8 ┆ u8 ┆ u8 │ ╞═════╪═════╪═════╡ │ 1 ┆ 0 ┆ 0 │ │ 0 ┆ 1 ┆ 0 │ │ 0 ┆ 0 ┆ 1 │ └─────┴─────┴─────┘ >>> s.to_dummies(drop_first=True) shape: (3, 2) ┌─────┬─────┐ │ a_2 ┆ a_3 │ │ --- ┆ --- │ │ u8 ┆ u8 │ ╞═════╪═════╡ │ 0 ┆ 0 │ │ 1 ┆ 0 │ │ 0 ┆ 1 │ └─────┴─────┘ )r/r to_dummies)rrrrs rrSeries.to_dummiess!\tww)))LMMr)labels left_closedinclude_breakscg)u{ 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 ------- Series Series of data type :class:`Categorical` if `include_breaks` is set to `False` (default), otherwise a Series of data type :class:`Struct`. See Also -------- qcut Examples -------- Divide the column into three categories. >>> s = pl.Series("foo", [-2, -1, 0, 1, 2]) >>> s.cut([-1, 1], labels=["a", "b", "c"]) shape: (5,) Series: 'foo' [cat] [ "a" "a" "b" "b" "c" ] Create a DataFrame with the breakpoint and category for each value. >>> cut = s.cut([-1, 1], include_breaks=True).alias("cut") >>> s.to_frame().with_columns(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] │ └─────┴────────────┴────────────┘ Nr)rbreaksrrrs rcut Series.cut rr)rrallow_duplicatesrcg)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 cut points plus one. 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 ------- Series Series of data type :class:`Categorical` if `include_breaks` is set to `False` (default), otherwise a Series of data type :class:`Struct`. See Also -------- cut Examples -------- Divide a column into three categories according to pre-defined quantile probabilities. >>> s = pl.Series("foo", [-2, -1, 0, 1, 2]) >>> s.qcut([0.25, 0.75], labels=["a", "b", "c"]) shape: (5,) Series: 'foo' [cat] [ "a" "a" "b" "b" "c" ] Divide a column into two categories using uniform quantile probabilities. >>> s.qcut(2, labels=["low", "high"], left_closed=True) shape: (5,) Series: 'foo' [cat] [ "low" "low" "high" "high" "high" ] Create a DataFrame with the breakpoint and category for each value. >>> cut = s.qcut([0.25, 0.75], include_breaks=True).alias("cut") >>> s.to_frame().with_columns(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] │ └─────┴────────────┴────────────┘ Nr)r quantilesrrr rs rqcut Series.qcutc rrcg)u Compress the Series 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 ------- Series Series of data type `Struct` with fields `len` of data type `UInt32` and `value` of the original data type. Examples -------- >>> s = pl.Series("s", [1, 1, 2, 1, None, 1, 3, 3]) >>> s.rle().struct.unnest() shape: (6, 2) ┌─────┬───────┐ │ len ┆ value │ │ --- ┆ --- │ │ u32 ┆ i64 │ ╞═════╪═══════╡ │ 2 ┆ 1 │ │ 1 ┆ 2 │ │ 1 ┆ 1 │ │ 1 ┆ null │ │ 1 ┆ 1 │ │ 2 ┆ 3 │ └─────┴───────┘ Nrrs rrle Series.rle rrcg)a6 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 ------- Series Series 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 -------- >>> s = pl.Series("s", [1, 1, 2, 1, None, 1, 3, 3]) >>> s.rle_id() shape: (8,) Series: 's' [u32] [ 0 0 1 2 3 4 5 5 ] Nrrs rrle_id Series.rle_id rr) bin_countinclude_categoryinclude_breakpointc (UR5R[R"UR5R UUUUS95R 5nU(dU(dUR5$URR5$)u= 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 -------- >>> a = pl.Series("a", [1, 3, 8, 8, 2, 1, 3]) >>> a.hist(bin_count=4) shape: (4, 3) ┌────────────┬─────────────┬───────┐ │ breakpoint ┆ category ┆ count │ │ --- ┆ --- ┆ --- │ │ f64 ┆ cat ┆ u32 │ ╞════════════╪═════════════╪═══════╡ │ 2.75 ┆ [1.0, 2.75] ┆ 3 │ │ 4.5 ┆ (2.75, 4.5] ┆ 2 │ │ 6.25 ┆ (4.5, 6.25] ┆ 0 │ │ 8.0 ┆ (6.25, 8.0] ┆ 2 │ └────────────┴─────────────┴───────┘ )binsr+r,r-) rrr=rrhistrrunnest)rr/r+r,r-rs rr0 Series.hist syb MMO Zdii %%'%5'9 &Y[ "*:<<> !::$$& &rsortparallelr normalizec U=(d U(aSOSn[RRURR XX4S95$)u Count the occurrences 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 ------- DataFrame Columns map the unique values to their count (or proportion). Examples -------- >>> s = pl.Series("color", ["red", "blue", "red", "green", "blue", "blue"]) >>> s.value_counts() # doctest: +IGNORE_RESULT shape: (3, 2) ┌───────┬───────┐ │ color ┆ count │ │ --- ┆ --- │ │ str ┆ u32 │ ╞═══════╪═══════╡ │ red ┆ 2 │ │ green ┆ 1 │ │ blue ┆ 3 │ └───────┴───────┘ Sort the output by count and customize the count column name. >>> s.value_counts(sort=True, name="n") shape: (3, 2) ┌───────┬─────┐ │ color ┆ n │ │ --- ┆ --- │ │ str ┆ u32 │ ╞═══════╪═════╡ │ blue ┆ 3 │ │ red ┆ 2 │ │ green ┆ 1 │ └───────┴─────┘ Return the count as a relative frequency, normalized to 1.0: >>> s.value_counts(sort=True, normalize=True, name="fraction") shape: (3, 2) ┌───────┬──────────┐ │ color ┆ fraction │ │ --- ┆ --- │ │ str ┆ f64 │ ╞═══════╪══════════╡ │ blue ┆ 0.5 │ │ red ┆ 0.333333 │ │ green ┆ 0.166667 │ └───────┴──────────┘ proportioncountr3)rrq _from_pydfr value_counts)rr4r5rr6s rr;Series.value_countsI sFZ? w||&& GG 4 !   rcg)z Return a count of the unique values in the order of appearance. Examples -------- >>> s = pl.Series("id", ["a", "b", "b", "c", "c", "c"]) >>> s.unique_counts() shape: (3,) Series: 'id' [u32] [ 1 2 3 ] Nrrs r unique_countsSeries.unique_counts rrr6cUR5R[R"UR5R XS95R 5R5$)a 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 -------- >>> a = pl.Series([0.99, 0.005, 0.005]) >>> a.entropy(normalize=True) 0.06293300616044681 >>> b = pl.Series([0.65, 0.10, 0.25]) >>> b.entropy(normalize=True) 0.8568409950394724 r@)rrr=rrentropyrrK)rrr6s rrBSeries.entropy sE. MMO Zdii(000K L Y[ TV  r min_periods min_samplesz1.21.0version)rEr5cg)a 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` parallel Run in parallel. Don't do this in a group by or another operation that already has much parallelization. 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 -------- >>> s = pl.Series("values", [1, 2, 3, 4, 5]) >>> s.cumulative_eval(pl.element().first() - pl.element().last() ** 2) shape: (5,) Series: 'values' [i64] [ 0 -3 -8 -15 -24 ] Nr)rexprrEr5s rcumulative_evalSeries.cumulative_eval rrc\UR5nURRU5 U$)z Rename the series. Parameters ---------- name The new name. Examples -------- >>> s = pl.Series("a", [1, 2, 3]) >>> s.alias("b") shape: (3,) Series: 'b' [i64] [ 1 2 3 ] )rfrr)rrrs rr) Series.alias s$* JJL  Drc$URU5$)z Rename this Series. Alias for :func:`Series.alias`. Parameters ---------- name New name. Examples -------- >>> s = pl.Series("a", [1, 2, 3]) >>> s.rename("b") shape: (3,) Series: 'b' [i64] [ 1 2 3 ] )r)rs rr Series.rename s.zz$rc6URR5$)aK Get the length of each individual chunk. Examples -------- >>> s = pl.Series("a", [1, 2, 3]) >>> s2 = pl.Series("a", [4, 5, 6]) Concatenate Series with rechunk = True >>> pl.concat([s, s2], rechunk=True).chunk_lengths() [6] Concatenate Series with rechunk = False >>> pl.concat([s, s2], rechunk=False).chunk_lengths() [3, 3] )r chunk_lengthsrs rrQSeries.chunk_lengths+ s&ww$$&&rc6URR5$)aX Get the number of chunks that this Series contains. Examples -------- >>> s = pl.Series("a", [1, 2, 3]) >>> s.n_chunks() 1 >>> s2 = pl.Series("a", [4, 5, 6]) Concatenate Series with rechunk = True >>> pl.concat([s, s2], rechunk=True).n_chunks() 1 Concatenate Series with rechunk = False >>> pl.concat([s, s2], rechunk=False).n_chunks() 2 )rrrs rrSeries.n_chunks@ s*ww!!r)reversecg)z Get an array with the cumulative max computed at every element. Parameters ---------- reverse reverse the operation. Examples -------- >>> s = pl.Series("s", [3, 5, 1]) >>> s.cum_max() shape: (3,) Series: 's' [i64] [ 3 5 5 ] NrrrUs rcum_maxSeries.cum_maxW rrcg)z Get an array with the cumulative min computed at every element. Parameters ---------- reverse reverse the operation. Examples -------- >>> s = pl.Series("s", [1, 2, 3]) >>> s.cum_min() shape: (3,) Series: 's' [i64] [ 1 1 1 ] NrrWs rcum_minSeries.cum_minm rrcg)aj 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 -------- >>> s = pl.Series("a", [1, 2, 3]) >>> s.cum_prod() shape: (3,) Series: 'a' [i64] [ 1 2 6 ] NrrWs rcum_prodSeries.cum_prod rrcg)ae 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 -------- >>> s = pl.Series("a", [1, 2, 3]) >>> s.cum_sum() shape: (3,) Series: 'a' [i64] [ 1 3 6 ] NrrWs rcum_sumSeries.cum_sum rrcg)a Return the cumulative count of the non-null values in the column. Parameters ---------- reverse Reverse the operation. Examples -------- >>> s = pl.Series(["x", "k", None, "d"]) >>> s.cum_count() shape: (4,) Series: '' [u32] [ 1 2 2 3 ] NrrWs r cum_countSeries.cum_count rrcRURURRXS95$)aT Get a slice of this Series. 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 -------- >>> s = pl.Series("a", [1, 2, 3, 4]) >>> s.slice(1, 2) shape: (2,) Series: 'a' [i64] [ 2 3 ] )rUlength)rrrQ)rrUrgs rrQ Series.slice s$.""477===#NOOrcf[X5 URRUR5 U$)a Append a Series to this one. The resulting series will consist of multiple chunks. Parameters ---------- other Series to append. Warnings -------- This method modifies the series in-place. The series is returned for convenience only. See Also -------- extend Examples -------- >>> a = pl.Series("a", [1, 2, 3]) >>> b = pl.Series("b", [4, 5]) >>> a.append(b) shape: (5,) Series: 'a' [i64] [ 1 2 3 4 5 ] The resulting series will consist of multiple chunks. >>> a.n_chunks() 2 )r+rrr5s rr Series.append s&P $& uxx  rcf[X5 URRUR5 U$)a  Extend the memory backed by this Series with the values from another. Different from `append`, which adds the chunks from `other` to the chunks of this series, `extend` appends the data from `other` to the underlying memory locations and thus may cause a reallocation (which is expensive). If this does `not` cause a reallocation, the resulting data structure will not have any extra chunks and thus will yield faster queries. Prefer `extend` over `append` when you want to do a query after a single append. For instance, during online operations where you add `n` rows and rerun a query. Prefer `append` over `extend` when you want to append many times before doing a query. For instance, when you read in multiple files and want to store them in a single `Series`. In the latter case, finish the sequence of `append` operations with a `rechunk`. Parameters ---------- other Series to extend the series with. Warnings -------- This method modifies the series in-place. The series is returned for convenience only. See Also -------- append Examples -------- >>> a = pl.Series("a", [1, 2, 3]) >>> b = pl.Series("b", [4, 5]) >>> a.extend(b) shape: (5,) Series: 'a' [i64] [ 1 2 3 4 5 ] The resulting series will consist of a single chunk. >>> a.n_chunks() 1 )r+rextendr5s rrl Series.extend s&l $& uxx  rc[U[5(d [SU5nURURR UR55$)a Filter elements by a boolean mask. The original order of the remaining elements is preserved. Elements where the filter does not evaluate to True are discarded, including nulls. Parameters ---------- predicate Boolean mask. Examples -------- >>> s = pl.Series("a", [1, 2, 3]) >>> mask = pl.Series("", [True, False, True]) >>> s.filter(mask) shape: (2,) Series: 'a' [i64] [ 1 3 ] r)rrrrr)r predicates rr Series.filterO s?4)V,,r9-I""477>>),,#?@@rcUS:a[SUR5U-5nURURR U55$)a Get the first `n` elements. Parameters ---------- n Number of elements to return. If a negative value is passed, return all elements except the last `abs(n)`. See Also -------- tail, slice Examples -------- >>> s = pl.Series("a", [1, 2, 3, 4, 5]) >>> s.head(3) shape: (3,) Series: 'a' [i64] [ 1 2 3 ] Pass a negative value to get all rows `except` the last `abs(n)`. >>> s.head(-3) shape: (2,) Series: 'a' [i64] [ 1 2 ] r)rrrrheadrns rrr Series.headm ?H q5AtxxzA~&A""477<<?33rcUS:a[SUR5U-5nURURR U55$)a Get the last `n` elements. Parameters ---------- n Number of elements to return. If a negative value is passed, return all elements except the first `abs(n)`. See Also -------- head, slice Examples -------- >>> s = pl.Series("a", [1, 2, 3, 4, 5]) >>> s.tail(3) shape: (3,) Series: 'a' [i64] [ 3 4 5 ] Pass a negative value to get all rows `except` the first `abs(n)`. >>> s.tail(-3) shape: (2,) Series: 'a' [i64] [ 4 5 ] r)rrrrtailrss rrx Series.tail rvrc$URU5$)a Get the first `n` elements. Alias for :func:`Series.head`. Parameters ---------- n Number of elements to return. If a negative value is passed, return all elements except the last `abs(n)`. See Also -------- head Examples -------- >>> s = pl.Series("a", [1, 2, 3, 4, 5]) >>> s.limit(3) shape: (3,) Series: 'a' [i64] [ 1 2 3 ] Pass a negative value to get all rows `except` the last `abs(n)`. >>> s.limit(-3) shape: (2,) Series: 'a' [i64] [ 1 2 ] )rrrss rlimit Series.limit sLyy|rcg)am Take every nth value in the Series and return as new Series. Parameters ---------- n Gather every *n*-th row. offset Start the row index at this offset. Examples -------- >>> s = pl.Series("a", [1, 2, 3, 4]) >>> s.gather_every(2) shape: (2,) Series: 'a' [i64] [ 1 3 ] >>> s.gather_every(2, offset=1) shape: (2,) Series: 'a' [i64] [ 2 4 ] Nr)rrtrUs r gather_everySeries.gather_every rr) descending nulls_last multithreadedrwcU(a#URRXU5UlU$URURRXU55$)a Sort this Series. Parameters ---------- descending Sort in descending order. nulls_last Place null values last instead of first. multithreaded Sort using multiple threads. in_place Sort in-place. Examples -------- >>> s = pl.Series("a", [1, 3, 4, 2]) >>> s.sort() shape: (4,) Series: 'a' [i64] [ 1 2 3 4 ] >>> s.sort(descending=True) shape: (4,) Series: 'a' [i64] [ 4 3 2 1 ] )rr4r)rrrrrws rr4 Series.sort sHX ggll:=IDGK&& Z]C rcg)a 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 -------- >>> s = pl.Series("a", [2, 5, 1, 4, 3]) >>> s.top_k(3) shape: (3,) Series: 'a' [i64] [ 5 4 3 ] Nrrrs rtop_k Series.top_k7 rrcg)ad Return the `k` largest elements of the `by` column. 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}) Parameters ---------- by Column 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 (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 -------- >>> s = pl.Series("a", [2, 5, 1, 4, 3]) >>> s.top_k_by("a", 3) shape: (3,) Series: 'a' [i64] [ 5 4 3 ] NrrbyrrUs rtop_k_bySeries.top_k_by[ rrcg)a 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 -------- >>> s = pl.Series("a", [2, 5, 1, 4, 3]) >>> s.bottom_k(3) shape: (3,) Series: 'a' [i64] [ 1 2 3 ] Nrrs rbottom_kSeries.bottom_k rrcg)ag Return the `k` smallest elements of the `by` column. 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}) Parameters ---------- by Column 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( (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 -------- >>> s = pl.Series("a", [2, 5, 1, 4, 3]) >>> s.bottom_k_by("a", 3) shape: (3,) Series: 'a' [i64] [ 1 2 3 ] Nrrs r bottom_k_bySeries.bottom_k_by rr)rrcg)a Get the index values that would sort this Series. Parameters ---------- descending Sort in descending order. nulls_last Place null values last instead of first. See Also -------- Series.gather: Take values by index. Series.rank : Get the rank of each row. Examples -------- >>> s = pl.Series("a", [5, 3, 4, 1, 2]) >>> s.arg_sort() shape: (5,) Series: 'a' [u32] [ 3 4 1 2 0 ] Nrrrrs rarg_sortSeries.arg_sort rrcg)z Get unique index as Series. Returns ------- Series Examples -------- >>> s = pl.Series("a", [1, 2, 2, 3]) >>> s.arg_unique() shape: (3,) Series: 'a' [u32] [ 0 1 3 ] Nrrs r arg_uniqueSeries.arg_uniquerrc6URR5$)z Get the index of the minimal value. Returns ------- int Examples -------- >>> s = pl.Series("a", [3, 2, 1]) >>> s.arg_min() 2 )rarg_minrs rrSeries.arg_minww  rc6URR5$)z Get the index of the maximal value. Returns ------- int Examples -------- >>> s = pl.Series("a", [3, 2, 1]) >>> s.arg_max() 0 )rarg_maxrs rrSeries.arg_max'rrrcgrrrelementsiders r search_sortedSeries.search_sorted7srcgrrrs rrr@src[R"[R"U5RXUS95n[ U[ [ [R45(aUR5$[U5(a/[ U[R5(aUR5$UR5$)a 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 -------- >>> s = pl.Series("set", [1, 2, 3, 4, 4, 5, 6, 7]) >>> s.search_sorted(4) 3 >>> s.search_sorted(4, "left") 3 >>> s.search_sorted(4, "right") 5 >>> s.search_sorted([1, 4, 5]) shape: (3,) Series: 'set' [u32] [ 0 3 5 ] >>> s.search_sorted([1, 4, 5], "left") shape: (3,) Series: 'set' [u32] [ 0 3 5 ] >>> s.search_sorted([1, 4, 5], "right") shape: (3,) Series: 'set' [u32] [ 1 5 6 ] r)r=rr>rrrrrrsrrMrrrK)rrrrdfs rrrIstXXaeeDk//*/U V gfbgg6 7 7<<> ! g & &:grzz+J+J<<> !779 r)maintain_ordercg)z Get unique elements in series. Parameters ---------- maintain_order Maintain order of data. This requires more work. Examples -------- >>> s = pl.Series("a", [1, 2, 2, 3]) >>> s.unique().sort() shape: (3,) Series: 'a' [i64] [ 1 2 3 ] Nr)rrs runique Series.uniquerrcg)z Take values by index. Parameters ---------- indices Index location used for selection. Examples -------- >>> s = pl.Series("a", [1, 2, 3, 4]) >>> s.gather([1, 3]) shape: (2,) Series: 'a' [i64] [ 2 4 ] Nr)rindicess rgather Series.gatherrrc6URR5$)zr Count the null values in this Series. Examples -------- >>> s = pl.Series([1, None, None]) >>> s.null_count() 2 )r null_countrs rrSeries.null_countsww!!##rc6URR5$)z Check whether the Series contains one or more null values. Examples -------- >>> s = pl.Series([1, 2, None]) >>> s.has_nulls() True >>> s[:2].has_nulls() False rrHrs rrHSeries.has_nullssww  ""rz_`has_validity` is deprecated; use `has_nulls` instead to check for the presence of null values.c6URR5$)z Check whether the Series contains one or more null values. .. deprecated:: 0.20.30 Use the :meth:`has_nulls` method instead. rrs r has_validitySeries.has_validitysww  ""rc(UR5S:H$)zu Check if the Series is empty. Examples -------- >>> s = pl.Series("a", [], dtype=pl.Float32) >>> s.is_empty() True rr0rs ris_emptySeries.is_emptysxxzQrc8URRX5$)aG Check if the Series is sorted. Parameters ---------- descending Check if the Series is sorted in descending order nulls_last Set nulls at the end of the Series in sorted check. Examples -------- >>> s = pl.Series([1, 3, 2]) >>> s.is_sorted() False >>> s = pl.Series([3, 2, 1]) >>> s.is_sorted(descending=True) True )r is_sortedrs rrSeries.is_sorteds*ww  88rcTURURR55$)z Negate a boolean Series. Returns ------- Series Series of data type :class:`Boolean`. Examples -------- >>> s = pl.Series("a", [True, False, False]) >>> s.not_() shape: (3,) Series: 'a' [bool] [ false true true ] )rrrrs rr Series.not_s*""477<<>22rcg)a Returns a boolean Series indicating which values are null. Returns ------- Series Series of data type :class:`Boolean`. Examples -------- >>> s = pl.Series("a", [1.0, 2.0, 3.0, None]) >>> s.is_null() shape: (4,) Series: 'a' [bool] [ false false false true ] Nrrs ris_nullSeries.is_nullrrcg)a Returns a boolean Series indicating which values are not null. Returns ------- Series Series of data type :class:`Boolean`. Examples -------- >>> s = pl.Series("a", [1.0, 2.0, 3.0, None]) >>> s.is_not_null() shape: (4,) Series: 'a' [bool] [ true true true false ] Nrrs rrSeries.is_not_null0rrcg)a2 Returns a boolean Series indicating which values are finite. Returns ------- Series Series of data type :class:`Boolean`. Examples -------- >>> import numpy as np >>> s = pl.Series("a", [1.0, 2.0, np.inf]) >>> s.is_finite() shape: (3,) Series: 'a' [bool] [ true true false ] Nrrs r is_finiteSeries.is_finiteGrrcg)a7 Returns a boolean Series indicating which values are infinite. Returns ------- Series Series of data type :class:`Boolean`. Examples -------- >>> import numpy as np >>> s = pl.Series("a", [1.0, 2.0, np.inf]) >>> s.is_infinite() shape: (3,) Series: 'a' [bool] [ false false true ] Nrrs r is_infiniteSeries.is_infinite^rrcg)a@ Returns a boolean Series indicating which values are NaN. Returns ------- Series Series of data type :class:`Boolean`. Examples -------- >>> import numpy as np >>> s = pl.Series("a", [1.0, 2.0, 3.0, np.nan]) >>> s.is_nan() shape: (4,) Series: 'a' [bool] [ false false false true ] Nrrs ris_nan Series.is_nanurrcg)aF Returns a boolean Series indicating which values are not NaN. Returns ------- Series Series of data type :class:`Boolean`. Examples -------- >>> import numpy as np >>> s = pl.Series("a", [1.0, 2.0, 3.0, np.nan]) >>> s.is_not_nan() shape: (4,) Series: 'a' [bool] [ true true true false ] Nrrs r is_not_nanSeries.is_not_nanrr) nulls_equalcg)aF Check if elements of this Series are in the other Series. Parameters ---------- nulls_equal : bool, default False If True, treat null as a distinct value. Null values will not propagate. Returns ------- Series Series of data type :class:`Boolean`. Examples -------- >>> s = pl.Series("a", [1, 2, 3]) >>> s2 = pl.Series("b", [2, 4, None]) >>> s2.is_in(s) shape: (3,) Series: 'b' [bool] [ true false null ] >>> # when nulls_equal=True, None is treated as a distinct value >>> s2.is_in(s, nulls_equal=True) shape: (3,) Series: 'b' [bool] [ true false false ] >>> # check if some values are a member of sublists >>> sets = pl.Series("sets", [[1, 2, 3], [1, 2], [9, 10]]) >>> optional_members = pl.Series("optional_members", [1, 2, 3]) >>> print(sets) shape: (3,) Series: 'sets' [list[i64]] [ [1, 2, 3] [1, 2] [9, 10] ] >>> print(optional_members) shape: (3,) Series: 'optional_members' [i64] [ 1 2 3 ] >>> optional_members.is_in(sets) shape: (3,) Series: 'optional_members' [bool] [ true true false ] Nr)rr6rs ris_in Series.is_inrrc,[R"USS9$)z Get index values where Boolean Series evaluate True. Returns ------- Series Series of data type :class:`UInt32`. Examples -------- >>> s = pl.Series("a", [1, 2, 3]) >>> (s == 2).arg_true() shape: (1,) Series: 'a' [u32] [ 1 ] T)eager)r= arg_wherers rarg_trueSeries.arg_trues&{{4t,,rcg)a Get mask of all unique values. Returns ------- Series Series of data type :class:`Boolean`. Examples -------- >>> s = pl.Series("a", [1, 2, 2, 3]) >>> s.is_unique() shape: (4,) Series: 'a' [bool] [ true false false true ] Nrrs r is_uniqueSeries.is_uniquerrcg)aF Return a boolean mask indicating the first occurrence of each distinct value. Returns ------- Series Series of data type :class:`Boolean`. Examples -------- >>> s = pl.Series([1, 1, 2, 3, 2]) >>> s.is_first_distinct() shape: (5,) Series: '' [bool] [ true false true true false ] Nrrs ris_first_distinctSeries.is_first_distinctrrcg)aD Return a boolean mask indicating the last occurrence of each distinct value. Returns ------- Series Series of data type :class:`Boolean`. Examples -------- >>> s = pl.Series([1, 1, 2, 3, 2]) >>> s.is_last_distinct() shape: (5,) Series: '' [bool] [ false true false true true ] Nrrs ris_last_distinctSeries.is_last_distinct/rrcg)a  Get mask of all duplicated values. Returns ------- Series Series of data type :class:`Boolean`. Examples -------- >>> s = pl.Series("a", [1, 2, 2, 3]) >>> s.is_duplicated() shape: (4,) Series: 'a' [bool] [ false true true false ] Nrrs r is_duplicatedSeries.is_duplicatedGrrcg)a Explode a list Series. This means that every item is expanded to a new row. Returns ------- Series Series with the data type of the list elements. See Also -------- Series.list.explode : Explode a list column. Examples -------- >>> s = pl.Series("a", [[1, 2, 3], [4, 5, 6]]) >>> s shape: (2,) Series: 'a' [list[i64]] [ [1, 2, 3] [4, 5, 6] ] >>> s.explode() shape: (6,) Series: 'a' [i64] [ 1 2 3 4 5 6 ] Nrrs rexplodeSeries.explode^rr check_dtypesz0.20.31r check_names null_equalcd[X5 URRURUUUS9$)a Check whether the Series is equal to another Series. .. versionchanged:: 0.20.31 The `strict` parameter was renamed `check_dtypes`. Parameters ---------- other Series to compare with. check_dtypes Require data types to match. check_names Require names to match. null_equal Consider null values as equal. See Also -------- polars.testing.assert_series_equal Examples -------- >>> s1 = pl.Series("a", [1, 2, 3]) >>> s2 = pl.Series("b", [4, 5, 6]) >>> s1.equals(s1) True >>> s1.equals(s2) False r)r+requals)rr6rrrs rr Series.equalss7N $&ww~~ HH%#!   r)rwrap_numericalcn[U5nURURRXU55$)a Cast between data types. Parameters ---------- dtype DataType to cast to. strict If True invalid casts generate exceptions instead of `null`\s. wrap_numerical If True numeric casts wrap overflowing values instead of marking the cast as invalid. Examples -------- >>> s = pl.Series("a", [True, False, True]) >>> s shape: (3,) Series: 'a' [bool] [ true false true ] >>> s.cast(pl.UInt32) shape: (3,) Series: 'a' [u32] [ 1 0 1 ] )rHrrr)rrrrs rr Series.casts/T!'""477<<~#NOOrcg)a 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)` -> `Array(physical of inner)` - `Struct(fields)` -> `Struct(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.Series.factorize `_ method. >>> s = pl.Series("values", ["a", None, "x", "a"]) >>> s.cast(pl.Categorical).to_physical() shape: (4,) Series: 'values' [u32] [ 0 null 1 0 ] Nrrs rrSeries.to_physicalrrc6URR5$)z Convert this Series to a Python list. This operation copies data. Examples -------- >>> s = pl.Series("a", [1, 2, 3]) >>> s.to_list() [1, 2, 3] >>> type(s.to_list()) )rrRrs rrRSeries.to_listrrrvcvURRU5nU(aU$UceURU5$)a Create a single chunk of memory for this Series. Parameters ---------- in_place In place or not. Examples -------- >>> s1 = pl.Series("a", [1, 2, 3]) >>> s1.n_chunks() 1 >>> s2 = pl.Series("a", [4, 5, 6]) >>> s = pl.concat([s1, s2], rechunk=False) >>> s.n_chunks() 2 >>> s.rechunk(in_place=True) shape: (6,) Series: 'a' [i64] [ 1 2 3 4 5 6 ] >>> s.n_chunks() 1 )rrr)rrwopt_ss rrSeries.rechunks<@) K$ $$&&u- -rcg)z Return Series in reverse order. Examples -------- >>> s = pl.Series("a", [1, 2, 3], dtype=pl.Int8) >>> s.reverse() shape: (3,) Series: 'a' [i8] [ 3 2 1 ] Nrrs rrUSeries.reverse=rrc US:Xa X:X:-nO/US:Xa X:X:*-nOUS:Xa X:X:*-nOUS:Xa X:X:-n[W[R5(a$[R"U5R 5nU$)a Get a boolean mask of the values that are between the given lower/upper bounds. Parameters ---------- lower_bound Lower bound value. Accepts expression input. Non-expression inputs (including strings) are parsed as literals. upper_bound Upper bound value. Accepts expression input. Non-expression inputs (including strings) 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. Examples -------- >>> s = pl.Series("num", [1, 2, 3, 4, 5]) >>> s.is_between(2, 4) shape: (5,) Series: 'num' [bool] [ false true true true false ] Use the `closed` argument to include or exclude the values at the bounds: >>> s.is_between(2, 4, closed="left") shape: (5,) Series: 'num' [bool] [ false true true false false ] You can also use strings as well as numeric/temporal values: >>> s = pl.Series("s", ["a", "b", "c", "d", "e"]) >>> s.is_between("b", "d", closed="both") shape: (5,) Series: 's' [bool] [ false true true true false ] nonebothrightleft)rrrsr=rr)r lower_bound upper_boundclosedrs r is_betweenSeries.is_betweenNsD V %$*<=C v &4+>?C w %$*=>C v &4+=>C c277 # #((3-))+C rgg& .>abs_tolrel_tol nans_equalc [R"[R"U5RXX4S95R 5$)a Get a boolean mask of the values being close to the other values. 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 ------- Series Series 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 -------- >>> s = pl.Series("s", [1.0, 1.2, 1.4, 1.45, 1.6]) >>> s.is_close(1.4, abs_tol=0.1) shape: (5,) Series: 's' [bool] [ false false true true false ] r )r=rr>is_closer)rr6r r rs rrSeries.is_closes?hxx EE$K  !   )+  r)rnro use_pyarrowzero_copy_onlycUb[SSS9 U(+nUb [SSS9 OSnU(a[(aUR[[[ [ [4;a`U(d6UR5S:a"UR5(d Sn[U5eUR5RU(+US 9$URRXS 9$) a Convert this Series to a NumPy ndarray. This operation copies data only when necessary. The conversion is zero copy when all of the following hold: - The data type is an integer, float, `Datetime`, `Duration`, or `Array`. - The Series contains no null values. - The Series consists of a single chunk. - The `writable` parameter is set to `False` (default). Parameters ---------- writable Ensure the resulting array is writable. This will force a copy of the data if the array was created without copy as the underlying Arrow data is immutable. allow_copy Allow memory to be copied to perform the conversion. If set to `False`, causes conversions that are not zero-copy to fail. use_pyarrow First convert to PyArrow, then call `pyarrow.Array.to_numpy `_ to convert to NumPy. If set to `False`, Polars' own conversion logic is used. .. deprecated:: 0.20.28 Polars now uses its native engine by default for conversion to NumPy. To use PyArrow's engine, call `.to_arrow().to_numpy()` instead. zero_copy_only Raise an exception if the conversion to a NumPy would require copying the underlying data. Data copy occurs, for example, when the Series contains nulls or non-numeric types. .. deprecated:: 0.20.10 Use the `allow_copy` parameter instead, which is the inverse of this one. Examples -------- Numeric data without nulls can be converted without copying data. The resulting array will not be writable. >>> s = pl.Series([1, 2, 3], dtype=pl.Int8) >>> arr = s.to_numpy() >>> arr array([1, 2, 3], dtype=int8) >>> arr.flags.writeable False Set `writable=True` to force data copy to make the array writable. >>> s.to_numpy(writable=True).flags.writeable True Integer Series containing nulls will be cast to a float type with `nan` representing a null value. This requires data to be copied. >>> s = pl.Series([1, 2, None], dtype=pl.UInt16) >>> s.to_numpy() array([ 1., 2., nan], dtype=float32) Set `allow_copy=False` to raise an error if data would be copied. >>> s.to_numpy(allow_copy=False) # doctest: +SKIP Traceback (most recent call last): ... RuntimeError: copy not allowed: cannot convert to a NumPy array without copying data Series of data type `Array` and `Struct` will result in an array with more than one dimension. >>> s = pl.Series([[1, 2, 3], [4, 5, 6]], dtype=pl.Array(pl.Int64, 3)) >>> s.to_numpy() array([[1, 2, 3], [4, 5, 6]]) zthe `zero_copy_only` parameter for `Series.to_numpy` is deprecated. Use the `allow_copy` parameter instead, which is the inverse of `zero_copy_only`.z0.20.10rFzthe `use_pyarrow` parameter for `Series.to_numpy` is deprecated. Polars now uses its native engine for conversion to NumPy by default. To use PyArrow's engine, call `.to_arrow().to_numpy()` instead.z0.20.28Fr%zcannot return a zero-copy array)rrnrm)r"rLrr4r5r6r1r>rrrlto_arrowrpr)rrnrorrrs rrpSeries.to_numpysn  % %e!  ,+J  " %S"   K "" 48UF"KK$--/A"5dmmoo7 o%==?++#-~, wwIIrc[SSS9n[U[5(aURU5SnURR (dV[ [[RRSS555(dUR[[[1;aUnO=[[[[ [["0nUR%X@R5nUc ['5OUR)U5 UR*R-UR/SS 9S S 9sSSS5 $!,(df  g=f) a Convert this Series to a Jax Array. .. versionadded:: 0.20.27 .. warning:: This functionality is currently considered **unstable**. It may be changed at any point without it being considered a breaking change. Parameters ---------- device Specify the jax `Device` on which the array will be created; can provide a string (such as "cpu", "gpu", or "tpu") in which case the device is retrieved as `jax.devices(string)[0]`. For more specific control you can supply the instantiated `Device` directly. If None, arrays are created on the default device. Examples -------- >>> s = pl.Series("x", [10.5, 0.0, -10.0, 5.5]) >>> s.to_jax() Array([ 10.5, 0. , -10. , 5.5], dtype=float32) jaxzPlease see `https://jax.readthedocs.io/en/latest/installation.html` for specific installation recommendations for the Jax package)install_messagerJAX_ENABLE_X640NFrnK)aorder)rRrrdevicesconfigjax_enable_x64rerosenvirongetrr9r;rCr8r:rBrrdefault_devicerTasarrayrp)rdevicejxsrssingle_precisions rto_jax Series.to_jaxPs4 L  fc " "ZZ'*F II $ $C '7=>??zz'5&!99C '%O )),ZZ89C$n[]"2C2CF2K K88##,,,.$L K Ks 'D44 Ecz[S5nUR[[4;aUR [ 5nO,UR[ :XaUR [5nOUnURSS9nUR"U5nU$![a$ UR[:XaSn[U5Seef=f)av Convert this Series to a PyTorch Tensor. .. versionadded:: 0.20.23 .. warning:: This functionality is currently considered **unstable**. It may be changed at any point without it being considered a breaking change. Notes ----- PyTorch tensors do not support UInt16, UInt32, or UInt64; these dtypes will be automatically cast to Int32, Int64, and Int64, respectively. Examples -------- >>> s = pl.Series("x", [1, 0, 1, 2, 0], dtype=pl.UInt8) >>> s.to_torch() tensor([1, 0, 1, 2, 0], dtype=torch.uint8) >>> s = pl.Series("x", [5.5, -10.0, 2.5], dtype=pl.Float32) >>> s.to_torch() tensor([ 5.5000, -10.0000, 2.5000]) rSTrz=cannot convert List dtype to Tensor (use Array dtype instead)N) rRrrBrCrr;rAr:rp from_numpyrr<)rrSr* numpy_arraytensorrs rto_torchSeries.to_torchs2 ( ::&&) )))E"C ZZ6 !))E"CCllDl1  %%k2F  zzT!Un$.   s 8B .B:future compat_levelz1.1)r5cUcSnO<[U[5(a URnOS[U5<3n[ U5eUR R U5$)a Return the underlying Arrow array. If the Series contains only a single chunk this operation is zero copy. .. versionchanged:: 1.24 The `future` parameter was renamed `compat_level`. Parameters ---------- compat_level Use a specific compatibility level when exporting Polars' internal data structures. Examples -------- >>> s = pl.Series("a", [1, 2, 3]) >>> s = s.to_arrow() >>> s [ 1, 2, 3 ] Fz!`compat_level` has invalid type: )rrZrr*rrr)rr5compat_level_pyrs rrSeries.to_arrowsY:  #O  k 2 2*33O56I,6W5Z[CC. ww00r)use_pyarrow_extension_arrayc UR[:Xa2[R"UR 5[ UR S9$U(a[[R5S:aS[R3n[U5e[(a[[R5S:a.[[(aS[R<35eS5eUR5n[RRUR5(aLUR![R""[R$"5[R&"555nU(aUR("S SSSS .UD6nO&UR+S S 5nUR("S S U0UD6nUR UlU$) a Convert this Series to a pandas Series. This operation copies data if `use_pyarrow_extension_array` is not enabled. Parameters ---------- use_pyarrow_extension_array Use a PyArrow-backed extension array instead of a NumPy array for the pandas Series. This allows zero copy operations and preservation of null values. Subsequent operations on the resulting pandas Series may trigger conversion to NumPy if those operations are not supported by PyArrow compute functions. **kwargs Additional keyword arguments to be passed to :meth:`pyarrow.Array.to_pandas`. Returns ------- :class:`pandas.Series` Notes ----- This operation requires that both :mod:`pandas` and :mod:`pyarrow` are installed. Examples -------- >>> s = pl.Series("a", [1, 2, 3]) >>> s.to_pandas() 0 1 1 2 2 3 Name: a, dtype: int64 Null values are converted to `NaN`. >>> s = pl.Series("b", [1, 2, None]) >>> s.to_pandas() 0 1.0 1 2.0 2 NaN Name: b, dtype: float64 Pass `use_pyarrow_extension_array=True` to get a pandas Series backed by a PyArrow extension array. This will preserve null values. >>> s.to_pandas(use_pyarrow_extension_array=True) 0 1 1 2 2 Name: b, dtype: int64[pyarrow] )rr)r%z\pandas>=1.5.0 is required for `to_pandas("use_pyarrow_extension_array=True")`, found Pandas )rz^pyarrow>=8.0.0 is required for `to_pandas("use_pyarrow_extension_array=True")`, found pyarrow rTc.[R"U5$r)r ArrowDtype)pa_dtypes rr"Series.to_pandas..)s bmmH.Er) self_destruct split_blocks types_mapperdate_as_objectFr)rr>rrrpobjectrr) __version__rXrLrrr is_dictionaryrr dictionaryint64 large_string to_pandasr)rr9r~rpa_arr pd_seriesrDs rrKSeries.to_pandassqn :: 99T]]_FK K &R^^,v5tuwvDvDuEF055%%r~~)F)O0*)'')~~&8:  88 ! !&++ . .[[rxxz2??;L!MNF &(("!E I$ZZ(8%@N((QQ&QI rcURU5R5n[UR5nSUR<SUSUS3$)a Convert Series to instantiable string representation. Parameters ---------- n Only use first n elements. See Also -------- polars.Series.to_init_repr polars.from_repr Examples -------- >>> s = pl.Series("a", [1, 2, None, 4], dtype=pl.Int16) >>> print(s.to_init_repr()) pl.Series('a', [1, 2, None, 4], dtype=pl.Int16) >>> s_from_str_repr = eval(s.to_init_repr()) >>> s_from_str_repr shape: (4,) Series: 'a' [i16] [ 1 2 null 4 ] z pl.Series(z, z, dtype=r)rrrRrJrr)rrtrdtype_init_reprs r to_init_reprSeries.to_init_repr3sH<1%%',TZZ8DII=6((?:K1MMrcDUR5UR5- $)z Return the number of non-null elements in the column. See Also -------- len Examples -------- >>> s = pl.Series("a", [1, 2, None]) >>> s.count() 2 )rrrs rr9 Series.countUsxxzDOO---rc6URR5$)z Return the number of elements in the Series. Null values count towards the total. See Also -------- count Examples -------- >>> s = pl.Series("a", [1, 2, None]) >>> s.len() 3 rrs rr Series.lenes ww{{}rc[SURUR5nUcSURS3n[U5eUR U"URU55$)u- Set masked values. Parameters ---------- filter Boolean mask. value Value with which to replace the masked values. Notes ----- Use of this function is frequently an anti-pattern, as it can block optimisation (predicate pushdown, etc). Consider using `pl.when(predicate).then(value).otherwise(self)` instead. Examples -------- >>> s = pl.Series("a", [1, 2, 3]) >>> s.set(s == 2, 10) shape: (3,) Series: 'a' [i64] [ 1 10 3 ] It is better to implement this as follows: >>> s.to_frame().select( ... pl.when(pl.col("a") == 2).then(10).otherwise(pl.col("a")) ... ) shape: (3, 1) ┌─────────┐ │ literal │ │ --- │ │ i64 │ ╞═════════╡ │ 1 │ │ 10 │ │ 3 │ └─────────┘ zset_with_mask_<>rdz can not be set)rkrrrnr)rrrirprs rrb Series.setwsZZ +TZZ A 9#DJJ<?C%c* *""1VYY#677rcp[U[5(dUnU/n[US9nUR5(aU$[U[5(d6[U[5(a[U[5(aU/n[US9nUR R UR UR 5 U$)uU Set values at the index locations. Parameters ---------- indices Integers representing the index locations. values Replacement values. Notes ----- Use of this function is frequently an anti-pattern, as it can block optimization (predicate pushdown, etc). Consider using `pl.when(predicate).then(value).otherwise(self)` instead. Examples -------- >>> s = pl.Series("a", [1, 2, 3]) >>> s.scatter(1, 10) shape: (3,) Series: 'a' [i64] [ 1 10 3 ] It is better to implement this as follows: >>> s.to_frame().with_row_index().select( ... pl.when(pl.col("index") == 1).then(10).otherwise(pl.col("a")) ... ) shape: (3, 1) ┌─────────┐ │ literal │ │ --- │ │ i64 │ ╞═════════╡ │ 1 │ │ 10 │ │ 3 │ └─────────┘ )r)rrrrrrr)rrrrs rrSeries.scattersb'8,, EgG(     K&&))fh//:fc3J3J 6*F  FII. rc[R"[R"U5RU55R 5$)a Get the index of the first occurrence of a value, or ``None`` if it's not found. Parameters ---------- element Value to find. Examples -------- >>> s = pl.Series("a", [1, None, 17]) >>> s.index_of(17) 2 >>> s.index_of(None) # search for a null 1 >>> s.index_of(55) is None True )r=rr>index_ofrK)rrs rr\Series.index_ofs/&xxd ,,W56;;==rcDUS:aSU3n[U5eUS:Xa)URURR55$[ U5S:a%UR UR /URS9OUR5nUS:aURSUS9$U$)a Create an empty copy of the current Series, with zero to 'n' elements. The copy has an identical name/dtype, but no data. Parameters ---------- n Number of (empty) elements to return in the cleared frame. See Also -------- clone : Cheap deepcopy/clone. Examples -------- >>> s = pl.Series("a", [None, True, False]) >>> s.clear() shape: (0,) Series: 'a' [bool] [ ] >>> s.clear(n=2) shape: (2,) Series: 'a' [bool] [ null null ] rz.`n` should be greater than or equal to 0, got )rrrN)rt) rlrrclearrr(rrrfextend_constant)rrtrrs rr_ Series.clears@ q5B1#FCS/ ! 6&&tww}}7 74y1} NN "DJJN G 011uq   +;!;rcTURURR55$)aD Create a copy of this Series. This is a cheap operation that does not copy data. See Also -------- clear : Create an empty copy of the current Series, with identical schema but no data. Examples -------- >>> s = pl.Series("a", [1, 2, 3]) >>> s.clone() shape: (3,) Series: 'a' [i64] [ 1 2 3 ] )rrrfrs rrf Series.clone,s.""477==?33rcg)a 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 -------- >>> s = pl.Series("a", [1.0, 2.0, 3.0, float("nan")]) >>> s.fill_nan(0) shape: (4,) Series: 'a' [f64] [ 1.0 2.0 3.0 0.0 ] Nr)rris rfill_nanSeries.fill_nanErrcg)ad Fill null values using the specified value or strategy. 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 -------- >>> s = pl.Series("a", [1, 2, 3, None]) >>> s.fill_null(strategy="forward") shape: (4,) Series: 'a' [i64] [ 1 2 3 3 ] >>> s.fill_null(strategy="min") shape: (4,) Series: 'a' [i64] [ 1 2 3 1 ] >>> s = pl.Series("b", ["x", None, "z"]) >>> s.fill_null(pl.lit("")) shape: (3,) Series: 'b' [str] [ "x" "" "z" ] Nr)rristrategyr{s r fill_nullSeries.fill_nullerrc"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 backwardrhr{rirr{s r backward_fillSeries.backward_fills"~~z~??rc"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 forwardrmrnros r forward_fillSeries.forward_fills"~~y~>>rcg)z Rounds down to the nearest integer value. Only works on floating point Series. Examples -------- >>> s = pl.Series("a", [1.12345, 2.56789, 3.901234]) >>> s.floor() shape: (3,) Series: 'a' [f64] [ 1.0 2.0 3.0 ] Nrrs rfloor Series.floorrrcg)z Rounds up to the nearest integer value. Only works on floating point Series. Examples -------- >>> s = pl.Series("a", [1.12345, 2.56789, 3.901234]) >>> s.ceil() shape: (3,) Series: 'a' [f64] [ 2.0 3.0 4.0 ] Nrrs rceil Series.ceilrrcg)az 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'} Rounding mode. Examples -------- >>> s = pl.Series("a", [1.12345, 2.56789, 3.901234]) >>> s.round(2) shape: (3,) Series: 'a' [f64] [ 1.12 2.57 3.9 ] >>> s = pl.Series([-3.5, -2.5, -1.5, -0.5, 0.5, 1.5, 2.5, 3.5]) >>> s.round(mode="half_to_even") shape: (8,) Series: '' [f64] [ -4.0 -2.0 -2.0 -0.0 0.0 2.0 2.0 4.0 ] Nr)rdecimalsmodes rround Series.roundrrcg)a Round to a number of significant figures. Parameters ---------- digits Number of significant figures to round to. Examples -------- >>> s = pl.Series([0.01234, 3.333, 3450.0]) >>> s.round_sig_figs(2) shape: (3,) Series: '' [f64] [ 0.012 3.3 3500.0 ] Nr)rdigitss rround_sig_figsSeries.round_sig_figsrrc[U[5(d [U5n[U5[U5:wa*[U5[U5p2SU<SU<3n[U5eURR UR5$)z Compute the dot/inner product between two Series. Examples -------- >>> s = pl.Series("a", [1, 2, 3]) >>> s2 = pl.Series("b", [4.0, 5.0, 6.0]) >>> s.dot(s2) 32.0 Parameters ---------- other Series (or array) to compute dot product with. z!Series length mismatch: expected z, found )rrrrYrr.)rr6rtmrs rr. Series.dot.sl %((5ME t9E "t9c%jq5aU(1%HCS/ !ww{{588$$rcg)z Compute the most occurring value(s). Can return multiple Values. Examples -------- >>> s = pl.Series("a", [1, 2, 2, 3]) >>> s.mode() shape: (1,) Series: 'a' [i64] [ 2 ] Nrrs rr~ Series.modeFrrcg)a 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 -------- >>> s = pl.Series("a", [-9.0, -0.0, 0.0, 4.0, float("nan"), None]) >>> s.sign() shape: (6,) Series: 'a' [f64] [ -1.0 -0.0 0.0 1.0 NaN null ] Nrrs rsign Series.signWrrcg)z Compute the element-wise value for the sine. Examples -------- >>> import math >>> s = pl.Series("a", [0.0, math.pi / 2.0, math.pi]) >>> s.sin() shape: (3,) Series: 'a' [f64] [ 0.0 1.0 1.2246e-16 ] Nrrs rsin Series.sinsrrcg)z Compute the element-wise value for the cosine. Examples -------- >>> import math >>> s = pl.Series("a", [0.0, math.pi / 2.0, math.pi]) >>> s.cos() shape: (3,) Series: 'a' [f64] [ 1.0 6.1232e-17 -1.0 ] Nrrs rcos Series.cosrrcg)z Compute the element-wise value for the tangent. Examples -------- >>> import math >>> s = pl.Series("a", [0.0, math.pi / 2.0, math.pi]) >>> s.tan() shape: (3,) Series: 'a' [f64] [ 0.0 1.6331e16 -1.2246e-16 ] Nrrs rtan Series.tanrrcg)z Compute the element-wise value for the cotangent. Examples -------- >>> import math >>> s = pl.Series("a", [0.0, math.pi / 2.0, math.pi]) >>> s.cot() shape: (3,) Series: 'a' [f64] [ inf 6.1232e-17 -8.1656e15 ] Nrrs rcot Series.cotrrcg)z Compute the element-wise value for the inverse sine. Examples -------- >>> s = pl.Series("a", [1.0, 0.0, -1.0]) >>> s.arcsin() shape: (3,) Series: 'a' [f64] [ 1.570796 0.0 -1.570796 ] Nrrs rarcsin Series.arcsinrrcg)z Compute the element-wise value for the inverse cosine. Examples -------- >>> s = pl.Series("a", [1.0, 0.0, -1.0]) >>> s.arccos() shape: (3,) Series: 'a' [f64] [ 0.0 1.570796 3.141593 ] Nrrs rarccos Series.arccosrrcg)z Compute the element-wise value for the inverse tangent. Examples -------- >>> s = pl.Series("a", [1.0, 0.0, -1.0]) >>> s.arctan() shape: (3,) Series: 'a' [f64] [ 0.785398 0.0 -0.785398 ] Nrrs rarctan Series.arctanrrcg)z Compute the element-wise value for the inverse hyperbolic sine. Examples -------- >>> s = pl.Series("a", [1.0, 0.0, -1.0]) >>> s.arcsinh() shape: (3,) Series: 'a' [f64] [ 0.881374 0.0 -0.881374 ] Nrrs rarcsinhSeries.arcsinhrrcg)z Compute the element-wise value for the inverse hyperbolic cosine. Examples -------- >>> s = pl.Series("a", [5.0, 1.0, 0.0, -1.0]) >>> s.arccosh() shape: (4,) Series: 'a' [f64] [ 2.292432 0.0 NaN NaN ] Nrrs rarccoshSeries.arccoshrrcg)a  Compute the element-wise value for the inverse hyperbolic tangent. Examples -------- >>> s = pl.Series("a", [2.0, 1.0, 0.5, 0.0, -0.5, -1.0, -1.1]) >>> s.arctanh() shape: (7,) Series: 'a' [f64] [ NaN inf 0.549306 0.0 -0.549306 -inf NaN ] Nrrs rarctanhSeries.arctanhrrcg)z Compute the element-wise value for the hyperbolic sine. Examples -------- >>> s = pl.Series("a", [1.0, 0.0, -1.0]) >>> s.sinh() shape: (3,) Series: 'a' [f64] [ 1.175201 0.0 -1.175201 ] Nrrs rsinh Series.sinh&rrcg)z Compute the element-wise value for the hyperbolic cosine. Examples -------- >>> s = pl.Series("a", [1.0, 0.0, -1.0]) >>> s.cosh() shape: (3,) Series: 'a' [f64] [ 1.543081 1.0 1.543081 ] Nrrs rcosh Series.cosh7rrcg)z Compute the element-wise value for the hyperbolic tangent. Examples -------- >>> s = pl.Series("a", [1.0, 0.0, -1.0]) >>> s.tanh() shape: (3,) Series: 'a' [f64] [ 0.761594 0.0 -0.761594 ] Nrrs rtanh Series.tanhHrr) skip_nullscSSKJn UcSnO [U5nU"XR/SS9 UR UR R XUS95$)u Map a custom/user-defined function (UDF) over elements in this Series. .. 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: `s.sqrt()`. - For mapping inner elements of lists, consider: `s.list.eval(pl.element().sqrt())`. - For mapping elements of struct fields, consider: `s.struct.field("field_name").sqrt()`. If the function returns a different datatype, the return_dtype arg should be set, otherwise the method will fail. Implementing logic using a Python function is almost always *significantly* slower and more memory intensive than implementing the same logic using the native expression API because: - The native expression engine runs in Rust; UDFs run in Python. - Use of Python UDFs forces the DataFrame to be materialized in memory. - Polars-native expressions can be parallelised (UDFs typically cannot). - Polars-native expressions can be logically optimised (UDFs cannot). Wherever possible you should strongly prefer the native expression API to achieve the best performance. Parameters ---------- function Custom function or lambda. return_dtype Output datatype. If not set, the dtype will be inferred based on the first non-null value that is returned by the function. skip_nulls Nulls will be skipped and not passed to the python function. This is faster because python can be skipped and because we call more specialized functions. Warnings -------- If `return_dtype` is not provided, this may lead to unexpected results. We allow this, but it is considered a bug in the user's query. Notes ----- * 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. * A UDF passed to `map_elements` must be pure, meaning that it cannot modify or depend on state other than its arguments. Examples -------- >>> s = pl.Series("a", [1, 2, 3]) >>> s.map_elements(lambda x: x + 10, return_dtype=pl.Int64) # doctest: +SKIP shape: (3,) Series: 'a' [i64] [ 11 12 13 ] Returns ------- Series r)warn_on_inefficient_mapNr)r map_target) return_dtyper)polars._utils.udfsrrHrrr map_elements)rfunctionrrrpl_return_dtypes rrSeries.map_elementsYs\b ?  "O.|>> s = pl.Series([1, 2, 3, 4]) >>> s.shift() shape: (4,) Series: '' [i64] [ null 1 2 3 ] Pass a negative value to shift in the opposite direction instead. >>> s.shift(-2) shape: (4,) Series: '' [i64] [ 3 4 null null ] Specify `fill_value` to fill the resulting null values. >>> s.shift(-2, fill_value=100) shape: (4,) Series: '' [i64] [ 3 4 100 100 ] Nr)rrtrs rshift Series.shiftrrc[X5 URURRURUR55$)av Take values from self or other based on the given mask. Where mask evaluates true, take values from self. Where mask evaluates false, take values from other. Parameters ---------- mask Boolean Series. other Series of same type. Returns ------- Series Examples -------- >>> s1 = pl.Series([1, 2, 3, 4, 5]) >>> s2 = pl.Series([5, 4, 3, 2, 1]) >>> s1.zip_with(s1 < s2, s2) shape: (5,) Series: '' [i64] [ 1 2 3 2 1 ] >>> mask = pl.Series([True, False, True, False, True]) >>> s1.zip_with(mask, s2) shape: (5,) Series: '' [i64] [ 1 4 3 2 5 ] )r+rrzip_with)rmaskr6s rrSeries.zip_withs7X $&""477#3#3DGGUXX#FGGrr)rErcg)u Compute a rolling min based on another series. .. 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] 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 series with a row index value >>> from datetime import timedelta, datetime >>> start = datetime(2001, 1, 1) >>> stop = datetime(2001, 1, 2) >>> s = pl.Series("index", range(25)) >>> s shape: (25,) Series: 'index' [i64] [ 0 1 2 3 4 … 20 21 22 23 24 ] Create another series to apply the window mask: >>> d = pl.Series("date", pl.datetime_range(start, stop, "1h", eager=True)) >>> d shape: (25,) Series: 'date' [datetime[μs]] [ 2001-01-01 00:00:00 2001-01-01 01:00:00 2001-01-01 02:00:00 2001-01-01 03:00:00 2001-01-01 04:00:00 … 2001-01-01 20:00:00 2001-01-01 21:00:00 2001-01-01 22:00:00 2001-01-01 23:00:00 2001-01-02 00:00:00 ] Compute the rolling min with the temporal windows from the second series closed on the right: >>> s.rolling_min_by(d, "3h") shape: (25,) Series: 'index' [i64] [ 0 0 0 1 2 … 18 19 20 21 22 ] Nrrr window_sizerErs rrolling_min_bySeries.rolling_min_by!rr)rEcentercg)aS 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 `weight` 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. Examples -------- >>> s = pl.Series("a", [100, 200, 300, 400, 500]) >>> s.rolling_min(window_size=3) shape: (5,) Series: 'a' [i64] [ null null 100 200 300 ] NrrrweightsrErs r rolling_minSeries.rolling_minrrcg)u Compute a rolling max based on another series. .. 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] 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 series with a row index value >>> from datetime import timedelta, datetime >>> start = datetime(2001, 1, 1) >>> stop = datetime(2001, 1, 2) >>> s = pl.Series("index", range(25)) >>> s shape: (25,) Series: 'index' [i64] [ 0 1 2 3 4 … 20 21 22 23 24 ] Create another series to apply the window mask: >>> d = pl.Series("date", pl.datetime_range(start, stop, "1h", eager=True)) >>> d shape: (25,) Series: 'date' [datetime[μs]] [ 2001-01-01 00:00:00 2001-01-01 01:00:00 2001-01-01 02:00:00 2001-01-01 03:00:00 2001-01-01 04:00:00 … 2001-01-01 20:00:00 2001-01-01 21:00:00 2001-01-01 22:00:00 2001-01-01 23:00:00 2001-01-02 00:00:00 ] Compute the rolling max with the temporal windows from the second series closed on the right: >>> s.rolling_max_by(d, "3h") shape: (25,) Series: 'index' [i64] [ 0 1 2 3 4 … 20 21 22 23 24 ] Nrrs rrolling_max_bySeries.rolling_max_byrrcg)aR 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 `weight` 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. Examples -------- >>> s = pl.Series("a", [100, 200, 300, 400, 500]) >>> s.rolling_max(window_size=2) shape: (5,) Series: 'a' [i64] [ null 200 300 400 500 ] Nrrs r rolling_maxSeries.rolling_maxWrrcg)u Compute a rolling mean based on another series. .. 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] 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 series with a row index value >>> from datetime import timedelta, datetime >>> start = datetime(2001, 1, 1) >>> stop = datetime(2001, 1, 2) >>> s = pl.Series("index", range(25)) >>> s shape: (25,) Series: 'index' [i64] [ 0 1 2 3 4 … 20 21 22 23 24 ] Create another series to apply the window mask: >>> d = pl.Series("date", pl.datetime_range(start, stop, "1h", eager=True)) >>> d shape: (25,) Series: 'date' [datetime[μs]] [ 2001-01-01 00:00:00 2001-01-01 01:00:00 2001-01-01 02:00:00 2001-01-01 03:00:00 2001-01-01 04:00:00 … 2001-01-01 20:00:00 2001-01-01 21:00:00 2001-01-01 22:00:00 2001-01-01 23:00:00 2001-01-02 00:00:00 ] Compute the rolling mean with the temporal windows from the second series closed on the right: >>> s.rolling_mean_by(d, "3h") shape: (25,) Series: 'index' [f64] [ 0.0 0.5 1.0 2.0 3.0 … 19.0 20.0 21.0 22.0 23.0 ] Nrrs rrolling_mean_bySeries.rolling_mean_byrrcg)a^ 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 `weight` vector. The resulting values will be aggregated to their mean. 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. Examples -------- >>> s = pl.Series("a", [100, 200, 300, 400, 500]) >>> s.rolling_mean(window_size=2) shape: (5,) Series: 'a' [f64] [ null 150.0 250.0 350.0 450.0 ] Nrrs r rolling_meanSeries.rolling_mean rrcg)u Compute a rolling sum based on another series. .. 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] 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 series with a row index value >>> from datetime import timedelta, datetime >>> start = datetime(2001, 1, 1) >>> stop = datetime(2001, 1, 2) >>> s = pl.Series("index", range(25)) >>> s shape: (25,) Series: 'index' [i64] [ 0 1 2 3 4 … 20 21 22 23 24 ] Create another series to apply the window mask: >>> d = pl.Series("date", pl.datetime_range(start, stop, "1h", eager=True)) >>> d shape: (25,) Series: 'date' [datetime[μs]] [ 2001-01-01 00:00:00 2001-01-01 01:00:00 2001-01-01 02:00:00 2001-01-01 03:00:00 2001-01-01 04:00:00 … 2001-01-01 20:00:00 2001-01-01 21:00:00 2001-01-01 22:00:00 2001-01-01 23:00:00 2001-01-02 00:00:00 ] Compute the rolling mean with the temporal windows from the second series closed on the right: >>> s.rolling_sum_by(d, "3h") shape: (25,) Series: 'index' [i64] [ 0 1 3 6 9 … 57 60 63 66 69 ] Nrrs rrolling_sum_bySeries.rolling_sum_by=rrcg)aT 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 `weight` 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. Examples -------- >>> s = pl.Series("a", [1, 2, 3, 4, 5]) >>> s.rolling_sum(window_size=2) shape: (5,) Series: 'a' [i64] [ null 3 5 7 9 ] Nrrs r rolling_sumSeries.rolling_sumrr)rErrcg)u> Compute a rolling standard deviation based on another series. .. 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] 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 series with a row index value >>> from datetime import timedelta, datetime >>> start = datetime(2001, 1, 1) >>> stop = datetime(2001, 1, 2) >>> s = pl.Series("index", range(25)) >>> s shape: (25,) Series: 'index' [i64] [ 0 1 2 3 4 … 20 21 22 23 24 ] Create another series to apply the window mask: >>> d = pl.Series("date", pl.datetime_range(start, stop, "1h", eager=True)) >>> d shape: (25,) Series: 'date' [datetime[μs]] [ 2001-01-01 00:00:00 2001-01-01 01:00:00 2001-01-01 02:00:00 2001-01-01 03:00:00 2001-01-01 04:00:00 … 2001-01-01 20:00:00 2001-01-01 21:00:00 2001-01-01 22:00:00 2001-01-01 23:00:00 2001-01-02 00:00:00 ] Compute the rolling std with the temporal windows from the second series closed on the right: >>> s.rolling_std_by(d, "3h") shape: (25,) Series: 'index' [f64] [ null 0.707107 1.0 1.0 1.0 … 1.0 1.0 1.0 1.0 1.0 ] NrrrrrErrs rrolling_std_bySeries.rolling_std_byrr)rErrcg)a Compute a rolling std dev. 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 `weight` vector. The resulting values will be aggregated to their std dev. 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. ddof "Delta Degrees of Freedom": The divisor for a length N window is N - ddof Examples -------- >>> s = pl.Series("a", [1.0, 2.0, 3.0, 4.0, 6.0, 8.0]) >>> s.rolling_std(window_size=3) shape: (6,) Series: 'a' [f64] [ null null 1.0 1.0 1.527525 2.0 ] NrrrrrErrs r rolling_stdSeries.rolling_stdvrrcg)u Compute a rolling variance based on another series. .. 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] 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 series with a row index value >>> from datetime import timedelta, datetime >>> start = datetime(2001, 1, 1) >>> stop = datetime(2001, 1, 2) >>> s = pl.Series("index", range(25)) >>> s shape: (25,) Series: 'index' [i64] [ 0 1 2 3 4 … 20 21 22 23 24 ] Create another series to apply the window mask: >>> d = pl.Series("date", pl.datetime_range(start, stop, "1h", eager=True)) >>> d shape: (25,) Series: 'date' [datetime[μs]] [ 2001-01-01 00:00:00 2001-01-01 01:00:00 2001-01-01 02:00:00 2001-01-01 03:00:00 2001-01-01 04:00:00 … 2001-01-01 20:00:00 2001-01-01 21:00:00 2001-01-01 22:00:00 2001-01-01 23:00:00 2001-01-02 00:00:00 ] Compute the rolling std with the temporal windows from the second series closed on the right: >>> s.rolling_std_by(d, "3h") shape: (25,) Series: 'index' [f64] [ null 0.707107 1.0 1.0 1.0 … 1.0 1.0 1.0 1.0 1.0 ] Nrrs rrolling_var_bySeries.rolling_var_byrrcg)a 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 `weight` vector. The resulting values will be aggregated to their variance. 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. ddof "Delta Degrees of Freedom": The divisor for a length N window is N - ddof Examples -------- >>> s = pl.Series("a", [1.0, 2.0, 3.0, 4.0, 6.0, 8.0]) >>> s.rolling_var(window_size=3) shape: (6,) Series: 'a' [f64] [ null null 1.0 1.0 2.333333 4.0 ] Nrrs r rolling_varSeries.rolling_var1rrcg)a 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:`Series.rolling_sum` if at all possible. Examples -------- >>> from numpy import nansum >>> s = pl.Series([11.0, 2.0, 9.0, float("nan"), 8.0]) >>> s.rolling_map(nansum, window_size=3) shape: (5,) Series: '' [f64] [ null null 22.0 11.0 17.0 ] Nr)rrrrrErs r rolling_mapSeries.rolling_mapgrrcg)u Compute a rolling median based on another series. .. 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] 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 series with a row index value >>> from datetime import timedelta, datetime >>> start = datetime(2001, 1, 1) >>> stop = datetime(2001, 1, 2) >>> s = pl.Series("index", range(25)) >>> s shape: (25,) Series: 'index' [i64] [ 0 1 2 3 4 … 20 21 22 23 24 ] Create another series to apply the window mask: >>> d = pl.Series("date", pl.datetime_range(start, stop, "1h", eager=True)) >>> d shape: (25,) Series: 'date' [datetime[μs]] [ 2001-01-01 00:00:00 2001-01-01 01:00:00 2001-01-01 02:00:00 2001-01-01 03:00:00 2001-01-01 04:00:00 … 2001-01-01 20:00:00 2001-01-01 21:00:00 2001-01-01 22:00:00 2001-01-01 23:00:00 2001-01-02 00:00:00 ] Compute the rolling median with the temporal windows from the second series closed on the right: >>> s.rolling_median_by(d, "3h") shape: (25,) Series: 'index' [f64] [ 0.0 0.5 1.0 2.0 3.0 … 19.0 20.0 21.0 22.0 23.0 ] Nrrs rrolling_median_bySeries.rolling_median_byrrcg)a Compute a rolling median. .. 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. .. 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. Examples -------- >>> s = pl.Series("a", [1.0, 2.0, 3.0, 4.0, 6.0, 8.0]) >>> s.rolling_median(window_size=3) shape: (6,) Series: 'a' [f64] [ null null 2.0 3.0 4.0 6.0 ] Nrrs rrolling_medianSeries.rolling_median"rr)rrErcg)uf Compute a rolling quantile based on another series. .. 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] 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 series with a row index value >>> from datetime import timedelta, datetime >>> start = datetime(2001, 1, 1) >>> stop = datetime(2001, 1, 2) >>> s = pl.Series("index", range(25)) >>> s shape: (25,) Series: 'index' [i64] [ 0 1 2 3 4 … 20 21 22 23 24 ] Create another series to apply the window mask: >>> d = pl.Series("date", pl.datetime_range(start, stop, "1h", eager=True)) >>> d shape: (25,) Series: 'date' [datetime[μs]] [ 2001-01-01 00:00:00 2001-01-01 01:00:00 2001-01-01 02:00:00 2001-01-01 03:00:00 2001-01-01 04:00:00 … 2001-01-01 20:00:00 2001-01-01 21:00:00 2001-01-01 22:00:00 2001-01-01 23:00:00 2001-01-02 00:00:00 ] Compute the rolling quantile with the temporal windows from the second series closed on the right: >>> s.rolling_quantile_by(d, "3h", quantile=0.5) shape: (25,) Series: 'index' [f64] [ 0.0 1.0 1.0 2.0 3.0 … 19.0 20.0 21.0 22.0 23.0 ] Nr)rrrrrrErs rrolling_quantile_bySeries.rolling_quantile_byVrrcg)aq Compute a rolling quantile. The window at a given row will include the row itself and the `window_size - 1` elements before it. .. 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 ---------- 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. Examples -------- >>> s = pl.Series("a", [1.0, 2.0, 3.0, 4.0, 6.0, 8.0]) >>> s.rolling_quantile(quantile=0.33, window_size=3) shape: (6,) Series: 'a' [f64] [ null null 2.0 3.0 4.0 6.0 ] >>> s.rolling_quantile(quantile=0.33, interpolation="linear", window_size=3) shape: (6,) Series: 'a' [f64] [ null null 1.66 2.66 3.66 5.32 ] Nr)rrrrrrErs rrolling_quantileSeries.rolling_quantilerr)biasrErcg)a 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 includes 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. 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 -------- Series.skew Examples -------- >>> pl.Series([1, 4, 2, 9]).rolling_skew(3) shape: (4,) Series: '' [f64] [ null null 0.381802 0.47033 ] Note how the values match >>> pl.Series([1, 4, 2]).skew(), pl.Series([4, 2, 9]).skew() (0.38180177416060584, 0.47033046033698594) Nr)rrrrErs r rolling_skewSeries.rolling_skew"rr)fisherrrErcg)a 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 -------- Series.kurtosis Examples -------- >>> pl.Series([1, 4, 2, 9]).rolling_kurtosis(3) shape: (4,) Series: '' [f64] [ null null -1.5 -1.5 ] Nr)rrrrrErs rrolling_kurtosisSeries.rolling_kurtosisWrr)fractionwith_replacementshuffleseedcg)as Sample from this Series. 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 -------- >>> s = pl.Series("a", [1, 2, 3, 4, 5]) >>> s.sample(2, seed=0) # doctest: +IGNORE_RESULT shape: (2,) Series: 'a' [i64] [ 1 5 ] Nr)rrtrr r r s rsample Series.samplerrcg)z Get a boolean mask of the local maximum peaks. Examples -------- >>> s = pl.Series("a", [1, 2, 3, 4, 5]) >>> s.peak_max() shape: (5,) Series: 'a' [bool] [ false false false false true ] Nrrs rpeak_maxSeries.peak_maxrrcg)z Get a boolean mask of the local minimum peaks. Examples -------- >>> s = pl.Series("a", [4, 1, 3, 2, 5]) >>> s.peak_min() shape: (5,) Series: 'a' [bool] [ false true false true false ] Nrrs rpeak_minSeries.peak_minrrc6URR5$)z~ Count the number of unique values in this Series. Examples -------- >>> s = pl.Series("a", [1, 2, 2, 3]) >>> s.n_unique() 3 )rn_uniquers rrSeries.n_uniquesww!!rcU(aURR5 U$UR5nURR5 U$)z Shrink Series memory usage. Shrinks the underlying array capacity to exactly fit the actual data. (Note that this function does not change the Series data type). )r shrink_to_fitrf)rrwrs rrSeries.shrink_to_fits<  GG ! ! #KZZ\F II # # %Mrcg)a Hash the Series. 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 -------- >>> s = pl.Series("a", [1, 2, 3]) >>> s.hash(seed=42) # doctest: +IGNORE_RESULT shape: (3,) Series: 'a' [u64] [ 10734580197236529959 3022416320763508302 13756996518000038261 ] Nr)rr seed_1seed_2seed_3s rhash Series.hashrr)signedcg)a> 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", [-(2**60), -2, 3]) >>> s shape: (3,) Series: 'a' [i64] [ -1152921504606846976 -2 3 ] >>> s.reinterpret(signed=False) shape: (3,) Series: 'a' [u64] [ 17293822569102704640 18446744073709551614 3 ] Nr)rr!s r reinterpretSeries.reinterpretrrcg)aL Interpolate intermediate values. Nulls at the beginning and end of the series remain null. Parameters ---------- method : {'linear', 'nearest'} Interpolation method. Examples -------- >>> s = pl.Series("a", [1, 2, None, None, 5]) >>> s.interpolate() shape: (5,) Series: 'a' [f64] [ 1.0 2.0 3.0 4.0 5.0 ] Nr)rrs r interpolateSeries.interpolate>rrcg)a Interpolate intermediate values with x-coordinate 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. >>> s = pl.Series([1, None, None, 3]) >>> by = pl.Series([1, 2, 7, 8]) >>> s.interpolate_by(by) shape: (4,) Series: '' [f64] [ 1.0 1.285714 2.714286 3.0 ] Nrrrs rinterpolate_bySeries.interpolate_byXrrcg)z Compute absolute values. Same as `abs(series)`. Examples -------- >>> s = pl.Series([1, -2, -3]) >>> s.abs() shape: (3,) Series: '' [i64] [ 1 2 3 ] Nrrs rr; Series.abstrr)rr cg)a 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: >>> s = pl.Series("a", [3, 6, 1, 1, 6]) >>> s.rank() shape: (5,) Series: 'a' [f64] [ 3.0 4.5 1.5 1.5 4.5 ] The 'ordinal' method: >>> s = pl.Series("a", [3, 6, 1, 1, 6]) >>> s.rank("ordinal") shape: (5,) Series: 'a' [u32] [ 3 4 1 2 5 ] Nr)rrrr s rrank Series.rankrrcg)a 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 -------- >>> s = pl.Series("s", values=[20, 10, 30, 25, 35], dtype=pl.Int8) >>> s.diff() shape: (5,) Series: 's' [i8] [ null -10 20 -5 10 ] >>> s.diff(n=2) shape: (5,) Series: 's' [i8] [ null null 10 15 5 ] >>> s.diff(n=2, null_behavior="drop") shape: (3,) Series: 's' [i8] [ 10 15 5 ] Nr)rrt null_behaviors rdiff Series.diffrrcg)a 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 -------- >>> pl.Series(range(10)).pct_change() shape: (10,) Series: '' [f64] [ null inf 1.0 0.5 0.333333 0.25 0.2 0.166667 0.142857 0.125 ] >>> pl.Series([1, 2, 4, 8, 16, 32, 64, 128, 256, 512]).pct_change(2) shape: (10,) Series: '' [f64] [ null null 3.0 3.0 3.0 3.0 3.0 3.0 3.0 3.0 ] Nrrss r pct_changeSeries.pct_changerr)rc8URRU5$)a 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 -------- >>> s = pl.Series([1, 2, 2, 4, 5]) >>> s.skew() 0.34776706224699483 )rskew)rrs rr9 Series.skew(sXww||D!!r)rrc8URRX5$)a 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 -------- >>> s = pl.Series("grades", [66, 79, 54, 97, 96, 70, 69, 85, 93, 75]) >>> s.kurtosis() -1.0522623626787952 >>> s.kurtosis(fisher=False) 1.9477376373212048 >>> s.kurtosis(fisher=False, bias=False) 2.1040361802642717 )rkurtosis)rrrs rr<Series.kurtosisVs<ww--rcg)a 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. If set to `None` (default), no lower bound is applied. upper_bound Upper bound. Accepts expression input. Non-expression inputs are parsed as literals. If set to `None` (default), no upper bound is applied. 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: >>> s = pl.Series([-50, 5, 50, None]) >>> s.clip(1, 10) shape: (4,) Series: '' [i64] [ 1 5 10 null ] Specifying only a single bound: >>> s.clip(upper_bound=10) shape: (4,) Series: '' [i64] [ -50 5 10 null ] Nr)rrrs rclip Series.clipvrrcg)a Return the lower bound of this Series' dtype as a unit Series. See Also -------- upper_bound : return the upper bound of the given Series' dtype. Examples -------- >>> s = pl.Series("s", [-1, 0, 1], dtype=pl.Int32) >>> s.lower_bound() shape: (1,) Series: 's' [i32] [ -2147483648 ] >>> s = pl.Series("s", [1.0, 2.5, 3.0], dtype=pl.Float32) >>> s.lower_bound() shape: (1,) Series: 's' [f32] [ -inf ] Nrrs rrSeries.lower_boundrrcg)a Return the upper bound of this Series' dtype as a unit Series. See Also -------- lower_bound : return the lower bound of the given Series' dtype. Examples -------- >>> s = pl.Series("s", [-1, 0, 1], dtype=pl.Int8) >>> s.upper_bound() shape: (1,) Series: 's' [i8] [ 127 ] >>> s = pl.Series("s", [1.0, 2.5, 3.0], dtype=pl.Float64) >>> s.upper_bound() shape: (1,) Series: 's' [f64] [ inf ] Nrrs rrSeries.upper_boundrr)defaultrcg)a! Replace values by different values of the same data type. Parameters ---------- old Value or sequence of values to replace. 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. 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:: 0.20.31 Use :meth:`replace_all` 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 is determined automatically based on the other inputs. .. deprecated:: 0.20.31 Use :meth:`replace_all` instead to set a return data type while replacing values. 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. >>> s = pl.Series([1, 2, 2, 3]) >>> s.replace(2, 100) shape: (4,) Series: '' [i64] [ 1 100 100 3 ] Replace multiple values by passing sequences to the `old` and `new` parameters. >>> s.replace([2, 3], [100, 200]) shape: (4,) Series: '' [i64] [ 1 100 100 200 ] Passing a mapping with replacements is also supported as syntactic sugar. >>> mapping = {2: 100, 3: 200} >>> s.replace(mapping) shape: (4,) Series: '' [i64] [ 1 100 100 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. >>> s = pl.Series(["x", "y", "z"]) >>> mapping = {"x": 1, "y": 2, "z": 3} >>> s.replace(mapping) shape: (3,) Series: '' [str] [ "1" "2" "3" ] NrroldnewrErs rr'Series.replacerrcg)a Replace all values by different values. Parameters ---------- old Value or sequence of values to replace. 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. 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 Series. 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. >>> s = pl.Series([1, 2, 2, 3]) >>> s.replace_strict([1, 2, 3], [100, 200, 300]) shape: (4,) Series: '' [i64] [ 100 200 200 300 ] Passing a mapping with replacements is also supported as syntactic sugar. >>> mapping = {1: 100, 2: 200, 3: 300} >>> s.replace_strict(mapping) shape: (4,) Series: '' [i64] [ 100 200 200 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} >>> s.replace_strict(mapping) # doctest: +SKIP Traceback (most recent call last): ... polars.exceptions.InvalidOperationError: incomplete mapping specified for `replace_strict` >>> s.replace_strict(mapping, default=-1) shape: (4,) Series: '' [i64] [ -1 200 200 300 ] The default can be another Series. >>> default = pl.Series([2.5, 5.0, 7.5, 10.0]) >>> s.replace_strict(2, 200, default=default) shape: (4,) Series: '' [f64] [ 2.5 200.0 200.0 10.0 ] 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. >>> s = pl.Series(["x", "y", "z"]) >>> mapping = {"x": 1, "y": 2, "z": 3} >>> s.replace_strict(mapping) shape: (3,) Series: '' [i64] [ 1 2 3 ] >>> s.replace_strict(mapping, default="x") shape: (3,) Series: '' [str] [ "1" "2" "3" ] Set the `return_dtype` parameter to control the resulting data type directly. >>> s.replace_strict(mapping, return_dtype=pl.UInt8) shape: (3,) Series: '' [u8] [ 1 2 3 ] NrrGs rreplace_strictSeries.replace_strictL rrcVURURRU55$)aZ Reshape this Series to a flat Series or an Array Series. Parameters ---------- dimensions Tuple of the dimension sizes. If a -1 is used in any of the dimensions, that dimension is inferred. Returns ------- Series If a single dimension is given, results in a Series of the original data type. If a multiple dimensions are given, results in a Series of data type :class:`Array` with shape `dimensions`. See Also -------- Series.list.explode : Explode a list column. Examples -------- >>> s = pl.Series("foo", [1, 2, 3, 4, 5, 6, 7, 8, 9]) >>> square = s.reshape((3, 3)) >>> square shape: (3,) Series: 'foo' [array[i64, 3]] [ [1, 2, 3] [4, 5, 6] [7, 8, 9] ] >>> square.reshape((9,)) shape: (9,) Series: 'foo' [i64] [ 1 2 3 4 5 6 7 8 9 ] )rrreshape)r dimensionss rrOSeries.reshape s#b""477??:#>??rcg)aQ Shuffle the contents of this Series. 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 -------- >>> s = pl.Series("a", [1, 2, 3]) >>> s.shuffle(seed=1) shape: (3,) Series: 'a' [i64] [ 2 3 1 ] Nr)rr s rr Series.shuffle!rr)comspan half_lifealphaadjustrErcg)a 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 -------- >>> s = pl.Series([1, 2, 3]) >>> s.ewm_mean(com=1, ignore_nulls=False) shape: (3,) Series: '' [f64] [ 1.0 1.666667 2.428571 ] Nr)rrTrUrVrWrXrErs rewm_meanSeries.ewm_mean!rrcg)a 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["values"].ewm_mean_by(df["times"], half_life="4d") shape: (5,) Series: 'values' [f64] [ 0.0 0.292893 1.492474 null 3.254508 ] Nr)rrrVs r ewm_mean_bySeries.ewm_mean_byr!rr)rTrUrVrWrXrrErcg)au 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 -------- >>> s = pl.Series("a", [1, 2, 3]) >>> s.ewm_std(com=1, ignore_nulls=False) shape: (3,) Series: 'a' [f64] [ 0.0 0.707107 0.963624 ] Nr rrTrUrVrWrXrrErs rewm_stdSeries.ewm_std!rrcg)af 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 -------- >>> s = pl.Series("a", [1, 2, 3]) >>> s.ewm_var(com=1, ignore_nulls=False) shape: (3,) Series: 'a' [f64] [ 0.0 0.5 0.928571 ] Nrr`s rewm_varSeries.ewm_var"rrcg)a 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 -------- >>> s = pl.Series([1, 2, 3]) >>> s.extend_constant(99, n=2) shape: (5,) Series: '' [i64] [ 1 2 3 99 99 ] Nr)rrirts rr`Series.extend_constantv"rrcVURURRU55$)a_ Flags the Series as 'sorted'. Enables downstream code to user fast paths for sorted arrays. Parameters ---------- descending If the `Series` order is descending. Warnings -------- This can lead to incorrect results if this `Series` is not sorted!! Use with care! Examples -------- >>> s = pl.Series("a", [1, 2, 3]) >>> s.set_sorted().max() 3 )rrset_sorted_flag)rrs r set_sortedSeries.set_sorted"s$,""477#:#::#FGGrcVURURRX55$)z Create a new Series filled with values from the given index. Examples -------- >>> s = pl.Series("a", [1, 2, 3, 4, 5]) >>> s.new_from_index(1, 3) shape: (3,) Series: 'a' [i64] [ 2 2 2 ] )rrnew_from_index)rrrgs rrmSeries.new_from_index"s$ ""477#9#9%#HIIrcH[URR55$)a 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. Examples -------- >>> s = pl.Series("a", [1, 2, 3, 4, 5, 6]) >>> s shape: (6,) Series: 'a' [i64] [ 1 2 3 4 5 6 ] >>> s.shrink_dtype() shape: (6,) Series: 'a' [i8] [ 1 2 3 4 5 6 ] )r0r shrink_dtypers rrpSeries.shrink_dtype"sBdgg**,--rc6URR5$)aN Get the chunks of this Series as a list of Series. Examples -------- >>> s1 = pl.Series("a", [1, 2, 3]) >>> s2 = pl.Series("a", [4, 5, 6]) >>> s = pl.concat([s1, s2], rechunk=False) >>> s.get_chunks() [shape: (3,) Series: 'a' [i64] [ 1 2 3 ], shape: (3,) Series: 'a' [i64] [ 4 5 6 ]] )r get_chunksrs rrsSeries.get_chunks"s0ww!!##rcg)z Aggregate values into a list. Examples -------- >>> s = pl.Series("a", [1, 2, 3]) >>> s.implode() shape: (1,) Series: 'a' [list[i64]] [ [1, 2, 3] ] Nrrs rrISeries.implode"rrcg)z Evaluate the number of set bits.Nrrs rbitwise_count_onesSeries.bitwise_count_ones#rrcg)z"Evaluate the number of unset Self.Nrrs rbitwise_count_zerosSeries.bitwise_count_zeros #rrcg)zIEvaluate the number most-significant set bits before seeing an unset bit.Nrrs rbitwise_leading_onesSeries.bitwise_leading_ones #rrcg)zHEvaluate the number most-significant unset bits before seeing a set bit.Nrrs rbitwise_leading_zerosSeries.bitwise_leading_zeros#rrcg)zJEvaluate the number least-significant set bits before seeing an unset bit.Nrrs rbitwise_trailing_onesSeries.bitwise_trailing_ones#rrcg)zIEvaluate the number least-significant unset bits before seeing a set bit.Nrrs rbitwise_trailing_zerosSeries.bitwise_trailing_zeros#rrc6URR5$)z'Perform an aggregation of bitwise ANDs.)r bitwise_andrs rrSeries.bitwise_and#ww""$$rc6URR5$)z&Perform an aggregation of bitwise ORs.)r bitwise_orrs rrSeries.bitwise_or#sww!!##rc6URR5$)z'Perform an aggregation of bitwise XORs.)r bitwise_xorrs rrSeries.bitwise_xor!#rrc6URR5$)zN Get the first element of the Series. Returns `None` if the Series is empty. )rfirstrs rr Series.first%#s ww}}rc6URR5$)zM Get the last element of the Series. Returns `None` if the Series is empty. )rlastrs rr Series.last-#s ww||~rc6URR5$)zq Approximate count of unique values. This is done using the HyperLogLog++ algorithm for cardinality estimation. )rapprox_n_uniquers rrSeries.approx_n_unique5#s ww&&((r unorderedrrcUR5R[R"UR5R XUS95R 5$)zEncode to the row encoding.r)rrr=rr _row_encoder)rrrrs rrSeries._row_encode=#sJ MMO Zdii ,,':- Y[ rc UR5R[R"UR5R UUUUUS95R 5$)zDecode from the row encoding.r)rrr=rr _row_decoder)rnamesdtypesrrrs rrSeries._row_decodeO#sT MMO Zdii ,,')) -Y[ rcg)a 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 List, where the inner data type is equal to the original data type. Nrr)s r repeat_bySeries.repeat_byg#rrc[U5$)z9Create an object namespace of all binary related methods.r]rs rr Series.bin~#t$$rc[U5$)z>Create an object namespace of all categorical related methods.r_rs rr Series.cat#sD!!rc[U5$)z;Create an object namespace of all datetime related methods.rars rr Series.dt#s!&&rc[U5$)z7Create an object namespace of all list related methods.rcrs rr Series.list#sT""rc[U5$)z8Create an object namespace of all array related methods.r[rs rr Series.arr#sd##rc[U5$)z9Create an object namespace of all string related methods.rfrs rr Series.str#rrc[U5$)z9Create an object namespace of all struct related methods.rhrs rr Series.struct#rrc[(a[[R5S:a Sn[ U5e[ U5$)a Create a plot namespace. .. warning:: This functionality is currently considered **unstable**. It may be changed at any point without it being considered a breaking change. .. versionchanged:: 1.6.0 In prior versions of Polars, HvPlot was the plotting backend. If you would like to restore the previous plotting functionality, all you need to do is add `import hvplot.polars` at the top of your script and replace `df.plot` with `df.hvplot`. Polars does not implement plotting logic itself, but instead defers to Altair: - `s.plot.hist(**kwargs)` is shorthand for `alt.Chart(s.to_frame()).mark_bar(tooltip=True).encode(x=alt.X(f'{s.name}:Q', bin=True), y='count()', **kwargs).interactive()` - `s.plot.kde(**kwargs)` is shorthand for `alt.Chart(s.to_frame()).transform_density(s.name, as_=[s.name, 'density']).mark_area(tooltip=True).encode(x=s.name, y='density:Q', **kwargs).interactive()` - for any other attribute `attr`, `s.plot.attr(**kwargs)` is shorthand for `alt.Chart(s.to_frame().with_row_index()).mark_attr(tooltip=True).encode(x='index', y=s.name, **kwargs).interactive()` For configuration, we suggest reading `Chart Configuration `_. For example, you can: - Change the width/height/title with ``.properties(width=500, height=350, title="My amazing plot")``. - Change the x-axis label rotation with ``.configure_axisX(labelAngle=30)``. - Change the opacity of the points in your scatter plot with ``.configure_point(opacity=.5)``. Examples -------- Histogram: >>> s = pl.Series([1, 4, 4, 6, 2, 4, 3, 5, 5, 7, 1]) >>> s.plot.hist() # doctest: +SKIP KDE plot: >>> s.plot.kde() # doctest: +SKIP Line plot: >>> s.plot.line() # doctest: +SKIP )r;rz%altair>=5.4.0 is required for `.plot`)rKr)rQrFrXrers rr Series.plot#s8h! M&2D2D$E $Q9C,S1 1$r)r)NNN) rzstr | ArrayLike | NonerzArrayLike | NonerPolarsDataType | NonerrerrerNone)rrmrr)rrrzlist[tuple[int, int]]rr)rrrr)rrrrrr)rrv)rr)rrrrvrr rrr)rrrzSeries | Sequence[Series]rz Series | Nonerr)rr)rrr)rzdict[str, bool])rr)rz tuple[int])rr)rbytes)r"rrr)r6rsrrs)r6r rr)r6r rz Expr | Series)r6r rorxrr)r6rErr)r6rEr Series | Expr)r6r rr)r6r rrrrrr)r6rqrrq)r6r rr)r6r rzSeries | DataFrame | Expr)rrrr)rr)r%zint | float | Seriesrr)r6r rzfloat | Series | None)rr)rDrrr)rKr rre)rzGenerator[Any])rZrrr )rZr}rr)rZz(SingleIndexSelector | MultiIndexSelectorrz Any | Series)rZzFint | Series | np.ndarray[Any, Any] | Sequence[object] | tuple[object]rir rr)NN)rznpt.DTypeLike | Noners bool | Nonerr) rznp.ufuncrrrr r~r rr)rz object | NonerrE)r int | Nonerr )r)rrr int | float)rz Literal[True]rre)rrerr)rzfloat | Seriesrr)r str | Nonerrq))g?g?g?r)rzSequence[float] | float | Nonerrrrq)rr)rzPythonLiteral | None)rz/int | float | date | datetime | timedelta | str)r%)rrrzfloat | timedelta | None)r)rrgrrr float | None)rrrrerrerrq) rzSequence[float]rSequence[str] | Nonerrerrerr) r"zSequence[float] | intrrrrer rerrerr) r/list[float] | Noner+rr,rer-rerrq) r4rer5rerrr6rerrq)rrgr6rerr)rIrsrErr5rerr)rrrr)rz list[int])rUrerr)rUrerr)rUrrgrrr)r6rrr)rozSeries | Iterable[bool]rr) )rtrrr)r)rtrrUrrr) rrerrerrerwrerr)r;)rrrr)rzIntoExpr | Iterable[IntoExpr]rrrUzbool | Sequence[bool]rr)rrerrerr)rr).)rzNonNestedLiteral | Nonerrrrerr)rzDlist[NonNestedLiteral | None] | np.ndarray[Any, Any] | Expr | Seriesrrrrerr)r)rz&IntoExpr | np.ndarray[Any, Any] | Nonerrrrerz int | Series)rrerr)rz6int | list[int] | Expr | Series | np.ndarray[Any, Any]rr)rre)rrerrerre)r6zSeries | Collection[Any]rrerr) r6rrrerrerrerre)rz/type[int | float | str | bool] | PolarsDataTyperrerrerr)rz list[Any])rwrerr)r)rr{rr{rrwrr) r6r{r rgr rgrrerr) rnrerorerrrrrr)r(zjax.Device | str | Nonerz jax.Array)rz torch.Tensor)r5zCompatLevel | Nonerr)r9rer~r rr)i)rtrrr)rrrizint | float | str | bool | Nonerr)rz3Series | Iterable[int] | int | np.ndarray[Any, Any]rz7Series | Iterable[PythonLiteral] | PythonLiteral | Nonerr)rr{rr)rizint | float | Expr | Nonerr)rizAny | Expr | NonerhzFillNullStrategy | Noner{rrr)r{rrr)r half_to_even)r}rr~rrr)rrrr)r6zSeries | ArrayLikerzint | float | None)rzCallable[[Any], Any]rrrrerr)rtrrzIntoExpr | Nonerr)rrr6rrr) rr{rtimedelta | strrErrrwrr) rrrrrErrrerr) rr{rrrErrrwrrrr) rrrrrErrrerrrr) rzCallable[[Series], Any]rrrrrErrrerr)rr{rrrrgrrrErrrwrr)rN)rrgrrrrrrrErrrerr) rrrrerErrrerr) rrrrerrerErrrerr) rtrrrr rer rer rrr)rwrerr)rNNN) r rrrrrrrrr)r!rerr)linear)rrzrr)rr{rr)average)rrrrer rrr)r%ignore)rtrr2rrr)rtint | IntoExprColumnrr)rrerr)rrerrerr)r8NumericLiteral | TemporalLiteral | IntoExprColumn | Nonerrrr) rHz,IntoExpr | Sequence[Any] | Mapping[Any, Any]rIz$IntoExpr | Sequence[Any] | NoDefaultrEzIntoExpr | NoDefaultrrrr)rPztuple[int, ...]rr)r rrr)rTrrUrrVrrWrrXrerErrrerr)rr{rVzstr | timedeltarr)rTrrUrrVrrWrrXrerrerErrrerr)rir{rtrrr)rrerr)rrrgrrr)rz list[Series])rrerrrrrr) rz Sequence[str]rzSequence[PolarsDataType]rrerSequence[bool] | Nonerrrr)rrrr)rr^)rr`)rrb)rrd)rr\)rrg)rri)rre(+r __module__ __qualname____firstlineno____doc__r__annotations__rr classmethodrr!rrrrrrrr staticmethodrpropertyrrrrrrr!r*r-r1rr7rBrJrQrVr\rtrwr~rrrrrrrarrrrrrrrrrrrrr rrrrrr r&r*r/r2r5r8r<r@rErLrVr[rgrrrrrrKrrrrrmatherrrrrrrrrrrr#rrrrrr rrrr%rr#r&r)r0r;r>rBr rJr)rrQrrXr[r^rardrQrrlrrrrxr{r~r4rrrrrrrrrrrrrHrrrrrrrrrrrrrrrrrrrrrRrrUr rrpr,r2rrKrQr9rrbrr\r_rfrerirprtrwrzrrr.r~rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr rrrrrr#r&r*r;r/r3r6r9r<r?rrr(r'rLrOr rZr]rardr`rjrmrprsrIrxr{r~rrrrrrrrrrrrrrrrrrrr__static_attributes__rrrrrsBK\B &J" (,#''+ h! !h!$h!!h!% h!  h!h! h!T  VQ  QQQ(==<:*, <T"T1;TDGT TT> #' 5 5 (5  5  5 5 n..  $       &$I// 00=00 11.. //<// 00// 00=00 11L-\.. 22' .. 22( .. //' .. //' .. //* .. //* ** ++"** ++"** ++"22 33'VR** ++"22 33'VR** ++"** ++")-V99 // .. 8// ..8; 33 448444 55 Q// 99 00 <// 008< << 7< 8" I9 E?? AA1;1 1<)! S)!)!  )!XGK*)*8C* *Xs+s+'*s+58s+DGs+ s+j<<>//6$%$%L 6 636DD <<*.#6#6J36DD <<*.#6#6J*. " " " " 8 8&/&/T7I(1F:3F:&F:  F:P* !&*VX  M&M&!!&!!&  @I99.<9 90  .N.N .N  .N  .N`Z (,!$ G G % G  G  G  G G RZ (,!!&$[ ([ % [  [  [ [  [ [ z @% NZ$(>'!%!%#' >' >' >'  >' ! >' >'>'F R R  R  R  R  R h "%)FF   :Z  xP01E* * *-* =A* * Q* X2 2'*".*/  ,*/  ,+0  6*/  6,1  .PP2*X8tA<&4&4P&4&4P&&P  B! " 22 2  2  2 2h" " N0 */ 0 )0  0 ' 0  0 d" " N0 */ 0 )0  0 ' 0  0 d.3u  > *! ! "%  (   "%  U    "'@ ! @7@@  @  @D05  , M  . $ # <# # /499.3. . . . . 0 8" D 'D  D  D L-* . 0 0 .$ L!>9M #! , ,  ,  ,  ,  , N, d$ +P>+P +P  +P  +PZ$ L! +0%.%.N *"( NNN N  Nh 88 8  8  8 8z#'&* vJvJ vJ ! vJ $ vJ vJpZ///bZ..`!>5I=A#1#1J#1L6;X.2XFIX Xt N ND. $18f>D>H>  >@>*+<+E Lr)rrrz2np.dtype[np.datetime64] | np.dtype[np.timedelta64]rr) __future__r contextlibrr#syscollections.abcrrrrrr r decimalr rtypingr r rrrrrrpolars._reexport _reexportrpolarsrr=polars._utils.constructionrrrrrrrpolars._utils.convertrrrrpolars._utils.deprecationr r!r"polars._utils.getitemr$polars._utils.unstabler%polars._utils.variousr&r'r(r)r*r+r,r-r.polars._utils.wrapr/r0polars.datatypesr1r2r3r4r5r6r7r8r9r:r;r<r=r>r?r@rArBrCrDrErFrGrHrIpolars.datatypes._utilsrJpolars.dependenciesrKrLrMrNrOrPrQrRrSrTrrUrrVrpolars.exceptionsrWrXrYpolars.interchange.protocolrZpolars.series.arrayr\polars.series.binaryr^polars.series.categoricalr`polars.series.datetimerbpolars.series.listrdpolars.series.plottingrepolars.series.stringrgpolars.series.structripolars.series.utilsrjrksuppress ImportError polars._plrrlrm_plrplrrnrorpr numpy.typingnptrqrrrspolars._typingrtrurvrwrxryrzr{r|r}r~rrrrrrrrrrrrr version_infortyping_extensionswarningsmodulesrcurrent_moduler ArrayLikerrrrrrs" ."44(   !  9+   /87   ,,-RR3.024,-00;%1&   [ )! *?>0020 7"* 7"'0[[*N-N  SM   aL aL aL HY  >U[&% * )s* JJ J J!