q-Ph ddlmZddlZddlZddlZddlZddlmZmZddlm Z ddl m Z m Z m Z m Z ddlmZddlmZmZmZmZmZmZmZmZddlmZddlmZdd l m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'dd l(m)Z)m*Z*m+Z+m,Z,dd l-m.Z.m/Z/m0Z0dd l1m2Z2dd l3m4Z4ddl5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;mZ>ddl?m@Z@ddlAmBZBmCZCmDZDmEZEmFZFmZmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQmRZRmSZSmTZTmUZUmVZVmWZWmXZXmYZYmZZZddl[m\Z\ddl]m^Z^m_Z_m`Z`maZambZbmcZcmdZdmeZemfZfddl]mgZhddl]miZjddl]mkZlddlmmnZnmoZompZpddlqmrZrddlsmtZtddlumvZvddlwmxZxddlymzZzddl{m|Z|ddl}m~Z~ddlmZddlmZdd lmZmZeje5dd!lmZmZdddn #1swxYwYerdd"lmZmZmZddlZddlmZdd#lmZmZmZdd$lmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZdd%l5mZejd&krdd'lmZndd'lmZejd(krdd)lm/Z/ndd)lm/Z/ne6rejeZe=e_eeed*d+d,d-d.d/d0d1f ZeGd2d*Zd9d8ZdS):) 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_df)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.DatetimeIndexrsrtc eZdZUdZdZded<hdZded< dwdd d dxdZedydZ ee ddzdZ edzdZ ed{d"Z d|d%Zd}d'Zd~d)Zedd.Ze ddd3Zedd4Zedd6Zedd8Zedd9Zedd;Zdd=Zdd?ZddAZddBZddCZddDZe ddGZ!e ddHZ!ddJZ!e ddKZ"e ddLZ"ddMZ"e ddNZ#e ddOZ#ddPZ#e ddQZ$e ddRZ$ddSZ$e ddTZ%e ddUZ%ddVZ%e ddWZ&e ddXZ&ddYZ&dd\Z'e dd]Z(e dd_Z(ddaZ(e ddbZ)e ddcZ)dddZ)e ddeZ*e ddfZ*ddgZ*e ddhZ+e ddiZ+ddjZ+e ddkZ,e ddlZ,ddmZ,e ddnZ-e ddoZ-ddpZ-e ddqZ.e ddrZ.ddsZ.e ddtZ/e dduZ/ddvZ/e ddwZ0e ddxZ0ddyZ0e ddzZ1e dd{Z1dd|Z1e dd}Z2e dd~Z2ddZ2e ddZ3e ddZ3ddZ3e ddZ4e ddZ4ddZ4e ddZ5e ddZ5ddZ5ddZ6e ddZ7e ddZ7e ddZ7ddZ7e ddZ8e ddZ8ddZ8ddZ9e ddZ:e ddZ:ddZ:e ddZ;e ddZ;ddZ;ddZe ddZ>ddZ>ddZ?ddZ@ddZAddZBddZCddZDddZEddZFddZGddZHddZIddZJddZKddZLdddZMddZNddZOe ddZPe ddZPddÄZPddƄZQ ddd˄ZRddфZSdddԄZTddՄZUddd؄ZVddd݄ZWddބZXdd߄ZYe ddddZZe ddZZddddZZe ddddZ[e ddZ[ddddZ[e\j]fddZ^ddZ_ddZ`ddZaddZbddZcdddZd dddZeddZfddZgddZhddZiddZjddZkddZlddZmdddZnddd Zodd Zp ddd Zqdd dddZresdd d dddZtesdd d d dddZudd Zvdd!Zwes ddddd"dd(Zxd d dd d)dd-Zydd.Zze\j]fdd/dd0Z{ese|d1d2d34dd d5dd7Z}dd8Z~dd9Zdd;Zdd<Zd d=dd?Zd d=dd@Zd d=ddAZd d=ddBZd d=ddCZdddFZddGZddHZddKZdÐdĐdNZdÐdĐdOZdÐdĐdPZdŐdƐdRZd d dd dSdǐdXZdȐdɐd[ZdȐdɐd\Zd d d]dʐd^Zdd_Zdːd`ZdːdaZe d̐d͐dfZe d̐dΐdhZ dϐdАdlZd dmdѐdoZdҐdrZddsZdӐdtZe dudӐdvZdӐdwZd d d]dԐdxZddyZddzZdd{Zdd|Zdd}Zdd~ZddZd ddՐdZddZddZddZddZddZddZe|ddd4d d ddd֐dZdd ddאdZddZdؐdZd ddِdZddZ dڐdېdZd dddddܐdZesddݐdZesdސdZe|ddd4dddߐdZd dddZdddZddZddZddZddZdd„ZdŐdĐdÄZddĄZddƄZ dwdd˄Zddd̄Zddd̈́ZÐdd΄ZĐddτZŐdddԄZƐddքZǐddلZȐddڄZɐddۄZʐdd܄Zːdd݄Z̐ddބZ͐dd߄ZΐddZϐddZАddZѐddZҐddZӐddZԐddZՐddZ֐ddZ dddddZؐdddddZِddZe|d1d2d34 ddd dddZe|d1d2d34 ddd dddZe|d1d2d34 ddd dddZe|d1d2d34 ddd dddZe|d1d2d34 ddd ddddZe|d1d2d34 ddd ddddZese|d1d2d34 ddd dddZese|d1d2d34 ddd dddZese|d1d2d34 ddd dddZesddd dddZesdddd ddd Z ddd d dd ddZddZddZddZd dddZ dddZddddZdddZdd Zdd!Z dd dd#dd%Zddd)Zddd+Zdd,dd-Zddd.dd/Z ddd1Zdd2Zdd3Zefedd4dd;Zefedd4dd<Zdd?Zdd d@Ze|d1d2d34ddddddd dAd dGZd dIZe|d1d2d34dddddd dd dJd dKZe|d1d2d34dddddd dd dJd dLZd dMZd dNddOZddPZddQZddSZddTZddUZddVZddWZ ddXZ ddYZ ddZZ dd[Z dd\Zdd]Zdd^Zdd_Zdd`ZeddbZedddZeddfZeddhZeddjZeddlZeddnZeesddpZdduZddvZdS(ra 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 ] Nrl_s>dtarrbincatstrlistplotstructzClassVar[set[str]] _accessorsTFstrict nan_to_nullnamestr | ArrayLike | NonevaluesArrayLike | NonedtypePolarsDataType | NonerboolrreturnNonecR|tkrd}n |t|st|}d}|d}n0t|tr|}n||}d}nd}t |t|t rt||||||_dS|t|g||_dSt|r*t|tj rt|||||_|j jtjtjfvrt#d|j }t#||j }|||d|tjtj|dj|_dS|#|||j|_dSdSt/|rmt|t0jrSt||d|||_|#|||j|_dSdSt7|r@t|t8jt8jfrt?|||| |_dStA|rKt|tBj"tBj#tBj$frtK|||| |_dStM|d s)tO|rtQ|||| |_dSt|tDrtS|||| |_dSt|tTj+rtY|||| |_dStM|d rt[j.||_dStM|d rt[j/||_dSd t|j0d }t |)NzSeries name must be a string)rrrrrF)r)force)rr__arrow_c_stream____arrow_c_array__z0Series constructor called with unsupported type z for the `values` parameter)1rCrDrG isinstancer TypeErrorrrrrLnpndarrayrrtype datetime64 timedelta64_resolve_temporal_dtypecastscatterargwhereisnatflattenrOrRTensorrSrNpar0 ChunkedArrayrrMpdrIndex DatetimeIndexrhasattrr'rrplrprrlfrom_arrow_c_arrayfrom_arrow_c_stream__name__) selfrrrrr original_namemsg input_dtypes T/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/polars/series/series.py__init__zSeries.__init__sE G  EE  u'='= $U++E%) <DD c " " % MM~4nn$ fh ' 'K !*' DGGG^*45AAADGGG f % %? !*VRZ*H*H? !'fVDG| R]BN$CCC5dFLII /v|DD$ +e <<e RXf-=-=!>!>!F!F!H!H$OO GF ))E&)99<! f % %) !*VU\*J*J) !'flll//KDG ))E&)99<!   ' '" !J RXr/- - " !(fE&QQQDGGG v & & !: RY"*:;, ,  !)vU6RRRDGGG!566 !=;P;P !*4uVTTTDGGG  ' ' !(vU6DGGG - - !+vU6DGGGV0 1 1 !1&99DGGG V1 2 2 !26::DGGG.4<||}||_|SN)__new__r)clsrseriess r_from_pyserieszSeries._from_pyseriesxsS!!  rz`_import_from_c` is deprecated; use `_import_arrow_from_c` instead. If you are using an extension, please compile it with the latest 'pyo3-polars'rpointerslist[tuple[int, int]]cR|tj||Srrrl_import_arrow_from_crrrs r_import_from_czSeries._import_from_c~s%!!("?h"O"OPPPrcR|tj||S)a Construct a Series from Arrows C interface. Parameters ---------- name The name that should be given to the `Series`. pointers A list with tuples containing two entries: - The raw pointer to a C ArrowArray struct - The raw pointer to a C ArrowSchema struct Warning ------- This will read the `array` pointer without moving it. The host process should garbage collect the heap pointer, but not its contents. rrs rrzSeries._import_arrow_from_cs%&!!("?h"O"OPPPrpointerintcP|tj|Sr)rrl_import)rrs rrzSeries._imports!!!("27";";<<z'Series._get_buffers..sF   1 t""1%%%A   r)r _get_bufferszip)rbufferskeyss` rrzSeries._get_bufferssR.'&&((0    D'**    rr buffer_infoownerr cT|tj|||S)a Construct a Series from information about its underlying buffer. Parameters ---------- dtype The data type of the buffer. Must be a physical type (integer, float, or boolean). buffer_info Tuple containing buffer information in the form `(pointer, offset, length)`. owner The object owning the buffer. Returns ------- Series Raises ------ TypeError When the given `dtype` is not supported. Notes ----- This method is mainly intended for use with the dataframe interchange protocol. )rrl _from_buffer)rrrrs rrzSeries._from_buffers'<!!("7{E"R"RSSSrdataSeries | Sequence[Series]r Series | Nonect|tr |jg}n d|D}||j}|t j|||S)an Construct a Series from information about its underlying buffers. Parameters ---------- dtype The data type of the resulting Series. data Buffers describing the data. For most data types, this is a single Series of the physical data type of `dtype`. Some data types require multiple buffers: - `String`: A data buffer of type `UInt8` and an offsets buffer of type `Int64`. Note that this does not match how the data is represented internally and data copy is required to construct the Series. validity Validity buffer. If specified, must be a Series of data type `Boolean`. Returns ------- Series Raises ------ TypeError When the given `dtype` is not supported or the other inputs do not match the requirements for constructing a Series of the given `dtype`. Warnings -------- Constructing a `String` Series requires specifying a values and offsets buffer, which does not match the actual underlying buffers. The values and offsets buffer are converted into the actual buffers, which copies data. Notes ----- This method is mainly intended for use with the dataframe interchange protocol. cg|] }|j S)r)rss r z(Series._from_buffers..As'''QAD'''r)rrrrrl _from_buffers)rrrrs rrzSeries._from_buffersseZ dF # # (G9DD''$'''D  {H!!("8h"O"OPPPrc2tjjS)zZ Get the newest supported compat level. This is for pyo3-polars. )rY_newest_versionrrr_newest_compat_levelzSeries._newest_compat_levelFs"$$--rrqc4|jS)z Get the data type of this Series. Examples -------- >>> s = pl.Series("a", [1, 2, 3]) >>> s.dtype Int64 )rrrs rrz Series.dtypeOsw}}rdict[str, bool]c|j|jd}|jtkr|j|d<|S)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 rflagsz Series.flags\s^'::<<7<<>>   :  "&'"?"?"A"AC  rc4|jS)z Get the name of this Series. Examples -------- >>> s = pl.Series("a", [1, 2, 3]) >>> s.name 'a' )rrrs rrz Series.nameosw||~~r tuple[int]c6|jfS)z Shape of this Series. Examples -------- >>> s = pl.Series("a", [1, 2, 3]) >>> s.shape (3,) rlenrs rshapez Series.shape|s rrc$d}t|)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__zSeries.__bool__s B nnrbytesc4|jSr)r __getstate__rs rrzSeries.__getstate__sw##%%%rstatecjtj|_|j|dSr)rr __setstate__)rrs rrzSeries.__setstate__s+((+ U#####rcx|j}|d|jjdS)Nr)ras_strreplace __class__r)rs_reprs r__str__zSeries.__str__s1gnn&&~~h4>+B(DaHHHrc*|Sr)r&rs r__repr__zSeries.__repr__s||~~rc*|Srrrs r__len__zSeries.__len__xxzzrotherrrcdSrrrr-s r__and__zSeries.__and__,/CrcdSrrr/s rr0zSeries.__and__-0Sr Expr | Seriesct|tjrtj||zSt|t st |g}||j|jSr) rrrrFlitrrrbitandr/s rr0zSeries.__and__l eRW % % '5;;& &%(( $E7OOE""47>>%(#;#;<<st?|g}ntt|t@r_|jtkrOtC|}t|dztD|j }|J| ||St|tFrgt|t sR|jtHtJfvr|g}t?d |}|jtLkr||jt|t>r6| tO|j ||j S|tQ||j}t|dz|j|j }|tRS| ||S) N)eqneqTrVFrWz_<>uszdatetime time zone z does not match Series timezone z3cannot compare datetime.datetime to Series of type r)*rr1rrclonefloat is_integerrr8rjrrrr3r4 time_zonertzinfor time_unit ValueErrorrr:r r?rr r5rr2r6rrrr9rr;r0r<getattrrENotImplemented) rr-rTfr^r\rtsdtds r_compz Series._compsl : Zt%<%< }ATAT "**%5..R5[[zz||#5..R4ZZUd]]rU{{u u % %/ -$**?*?*A*A/ -99W%%DR%Z$'::A===&&qqxx00 0 x ( (( -zT!!yy$00 x'' J0 u|$$I66m mm`immC#C..( J0 XDJXX oo%  22BR%Z88A===&&qquu-- - t $ $ -t););E""AR%Z88A===&&qqtt,, , y ) ) -djH.D.D ,I!%33BR%Z88A===&&qquu-- - ZK. . .z%7P7P .E7OOEE t $ $ -t););E""AR%Z88A===&&qqtt,, , eX & & 'z%/E/E 'zdE]**2u%%E{d"" 4:&&& eV $ $ G&&';wtw';';EH'E'EFF F  udj11E eTZ 9 9 9! !""11U88,,,rcdSrrr/s r__eq__z Series.__eq__?rCrobjectcdSrrr/s rrhz Series.__eq__B/2sr Series | Exprct|t|tjr't j||S||dS)NrV)r.rrrrr6r7rhrfr/s rrhz Series.__eq__ETU### eRW % % -5;;%%e,, ,zz%&&&rcdSrrr/s r__ne__z Series.__ne__KrCrcdSrrr/s rrpz Series.__ne__Nrkrct|t|tjr't j||S||dS)NrW)r.rrrrr6r7rprfr/s rrpz Series.__ne__QsTU### eRW % % -5;;%%e,, ,zz%'''rcdSrrr/s r__gt__z Series.__gt__WrCrcdSrrr/s rrtz Series.__gt__Zr1rct|t|tjr't j||S||dS)Ngt)r.rrrrr6r7rtrfr/s rrtz Series.__gt__]rnrcdSrrr/s r__lt__z Series.__lt__crCrcdSrrr/s rryz Series.__lt__fr1rct|t|tjr't j||S||dS)Nlt)r.rrrrr6r7ryrfr/s rryz Series.__lt__irnrcdSrrr/s r__ge__z Series.__ge__orCrcdSrrr/s rr~z Series.__ge__rr1rct|t|tjr't j||S||dS)Ngt_eq)r.rrrrr6r7r~rfr/s rr~z Series.__ge__uTU### eRW % % -5;;%%e,, ,zz%)))rcdSrrr/s r__le__z Series.__le__{rCrcdSrrr/s rrz Series.__le__~r1rct|t|tjr't j||S||dS)Nlt_eq)r.rrrrr6r7rrfr/s rrz Series.__le__rrcdSrrr/s rlez Series.le'*srcdSrrr/s rrz Series.le(+rc,||S)z;Method equivalent of operator expression `series <= other`.)rr/s rrz Series.le{{5!!!rcdSrrr/s rr|z Series.ltrrcdSrrr/s rr|z Series.ltrrc,||S)z:Method equivalent of operator expression `series < other`.)ryr/s rr|z Series.ltrrcdSrrr/s rrVz Series.eqrrcdSrrr/s rrVz Series.eqrrc,||S)z;Method equivalent of operator expression `series == other`.)rhr/s rrVz Series.eqrrcdSrrr/s r eq_missingzSeries.eq_missingrkrcdSrrr/s rrzSeries.eq_missing03rcJt|tjr'tj||S|tj|j | S)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 ] ) rrrrr6r7rto_frameselectcolr to_seriesr/s rrzSeries.eq_missingwJ eRW % % 15;;))%00 0}}%%aeDI&6&6&A&A%&H&HIISSUUUrcdSrrr/s rnez Series.nerrcdSrrr/s rrz Series.nerrc,||S)z;Method equivalent of operator expression `series != other`.)rpr/s rrz Series.nerrcdSrrr/s r ne_missingzSeries.ne_missingrkrcdSrrr/s rrzSeries.ne_missingrrcJt|tjr'tj||S|tj|j | S)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 ] ) rrrrr6r7rrrrrrr/s rrzSeries.ne_missingrrcdSrrr/s rgez Series.ge rrcdSrrr/s rrz Series.gerrc,||S)z;Method equivalent of operator expression `series >= other`.)r~r/s rrz Series.gerrcdSrrr/s rrwz Series.gtrrcdSrrr/s rrwz Series.gtrrc,||S)z:Method equivalent of operator expression `series > other`.)rtr/s rrwz Series.gtrrop_sop_ffic t|tjr:||}n|tjddg}t|t r6|t|j ||j St|r]t|tj rC|t|j |t |j St|tttt t"fr|js|t)|j|g}d|vr1|t|||j S|t|j ||S|jrt|t.t0frt|t0rRt)|j|g}||t5dj }nt)|j|gt4}d|vr1|t|||j S|t|j ||St7||j}t9||j|j }|.d|jdt;|j}t?||||S)Nrrhsr)scalerz+cannot do arithmetic with Series of dtype: z and argument of type: ) rrrrr select_seqrrrr`rrLrrrZrrr rris_floatrr is_decimal PyDecimalrrr rErjrrr)rr-rrrrrbrs r _arithmeticzSeries._arithmetic!s eRW % % *MMOO..u55??AAEE ]Ib4&))E eV $ $ G&&'=wtw'='=eh'G'GHH H e $ $ GE2:)F)F G&&'=wtw'='=fUmm>N'O'OPP P uudHiE F F GJ'')) G&di%99B**+<72t+<+)rrrrrprrr6r7rrrZrrrrrrrr/s rrzSeries.__add__Us eS ! ! '2w''EE r| , , '4<  rw ' ' '5;;& & : " " Pz%%'F'F P==??))!% *:*:U*BCCMMOO Ouh777rcdSrrr/s r__sub__zSeries.__sub__`r1rcdSrrr/s rrzSeries.__sub__crCrct|tjrtj||z S|jrot|ttfrS| tj |j |z  S||ddS)Nsubzsub_<>)rrrrr6r7rrrZrrrrrrrr/s rrzSeries.__sub__fs eRW % % '5;;& & : " " Pz%%'F'F P==??))!% *:*:U*BCCMMOO Ouh777r leaf_dtypecZdfd ||jS)z Convert leaf dtype the to given primitive datatype. This is equivalent to logic in DataType::cast_leaf() in Rust. rrrct|tr$t|j|jSt|trt |jSS)N)r)rr0innerrr;)rconvert_to_primitivers rrz=Series._recursive_cast_to_dtype..convert_to_primitivetsm%'' S11%+>>ekRRRR%&& ?00==>>> r)rrrr)rr)rrrs `@r_recursive_cast_to_dtypezSeries._recursive_cast_to_dtypemsI       yy--dj99:::rcdSrrr/s r __truediv__zSeries.__truediv__}rrcdSrrr/s rrzSeries.__truediv__14rct|tjrtj||z S|jr+t|jtsd}t|t|ttfr|j st|jtrS| tj|j|z S|jsv|j s]t|jt$t&tfs6t|t(r#t|jt$t&fr|n |t-}||ddS)N5first cast to integer before dividing datelike dtypesdivzdiv_<>)rrrrr6r7r is_temporalr5rrrZrrrrrrrr;r0rrr8rrr-rs rrzSeries.__truediv__s eRW % % '5;;& & : ! ! # # !Jtz8,L,L !ICC.. ec5\ * * P J ! ! # # P'1$*h'G'G P==??))!% *:*:U*BCCMMOO O  ##%% ::((** :dj4*ABB : uf-- : 3=U[4QV-2X2X :DD..wyy99 uh777rcdSrrr/s r __floordiv__zSeries.__floordiv__rrcdSrrr/s rrzSeries.__floordiv__s25#rct|tjrtj||zS|jrd}t||jrot|ttfrS| tj |j|zSt|tjstj|}| tj |j|zSNr)rrrrr6r7rrrrrZrrrrrrrrs rrzSeries.__floordiv__s eRW % % (5;;%' ' : ! ! # # !ICC.. : " " Qz%%'F'F Q==??))!% *:*:e*CDDNNPP P%)) !E%LLE}}))!% *:*:e*CDDNNPPPrc*|Sr)not_rs r __invert__zSeries.__invert__syy{{rcdSrrr/s r__mul__zSeries.__mul__r1rcdSrrr/s rrzSeries.__mul__rrcdSrrr/s rrzSeries.__mul__r3rct|tjrtj||zS|jr+t|jtsd}t|t|ttfr|j st|jtrS| tj|j|zSt|tjr||zS||ddSNz8first cast to integer before multiplying datelike dtypesmulzmul_<>)rrrrr6r7rrr5rrrZrrrrrrrprrs rrzSeries.__mul__s eRW % % '5;;& & : ! ! # # !Jtz8,L,L !LCC.. ec5\ * * < J ! ! # # <'1$*h'G'G <==??))!% *:*:U*BCCMMOO O r| , , <4< ##E5(;; ;rcdSrrr/s r__mod__zSeries.__mod__r1rcdSrrr/s rrzSeries.__mod__r3rct|tjr'tj||S|jrd}t||j rot|ttfrS| tj|j|zS||ddS)N?first cast to integer before applying modulo on datelike dtypesremzrem_<>)rrrrr6r7rrrrrrZrrrrrrrrs rrzSeries.__mod__s eRW % % .5;;&&u-- - : ! ! # # !SCC.. : " " Pz%%'F'F P==??))!% *:*:U*BCCMMOO Ouh777rc|jrd}t|||ddS)Nrrz rem_<>_rhsrrrrrs r__rmod__zSeries.__rmod__sA : ! ! # # !SCC.. ul;;;rcjt|ts5t|ttfrl|jrS||tj |j z S| |ddS)Nrz add_<>_rhs) rrrrZrrrrr6rrrrr/s r__radd__zSeries.__radd__s eS ! ! P usEl + + P04 0E0E0G0G P==??))%!% 2B2B*BCCMMOO Oul;;;rc@t|ttfrl|jrS||tj|j z  S| |ddS)Nrz sub_<>_rhs) rrrZrrrrr6rrrrr/s r__rsub__zSeries.__rsub__s ec5\ * * Ptz/D/D/F/F P==??))%!% 2B2B*BCCMMOO Oul;;;rcd|jrd}t||jr||t |t tfrl|jrS| |tj |j z St |t rt|}|t |Sr)rrrr __rfloordiv__rrrZrrrr6rrrrr8rs r __rtruediv__zSeries.__rtruediv__s : ! ! # # !ICC.. :    &   u % % % ec5\ * * Ptz/D/D/F/F P==??))%!% 2B2B*BCCMMOO O eS ! ! !%LLEyy!!//666rc|jrd}t|||ddS)Nrrz div_<>_rhsrrs rrzSeries.__rfloordiv__sA : ! ! # # !ICC.. ul;;;rc|jr+t|jtsd}t |t|t t fr|jst|jtrS| |tj |j z S||ddSr)rrrr5rrrZrrrr6rrrrrs r__rmul__zSeries.__rmul__s : ! ! # # !Jtz8,L,L !LCC.. ec5\ * * P J ! ! # # P'1$*h'G'G P==??))%!% 2B2B*BCCMMOO Ouh777rexponentint | float | Seriesc,||Sr)powrrs r__pow__zSeries.__pow__ sxx!!!rc||tj|jz|jSr)rrr6rraliasrr/s r__rpow__zSeries.__rpow__ sI MMOO Z!% "2"2299$)DD E E Y[[ rfloat | Series | Nonect|ts)t|r)t|tjrt |}||SrrrrLrrrdotr/s r __matmul__zSeries.__matmul__sW eX & & " U # # "(25"*(E(E "5MMExxrct|ts)t|r)t|tjrt |}||Srrr/s r __rmatmul__zSeries.__rmatmul__sU eX & & " U # # "(25"*(E(E "5MMEyyrc|tj|j Sr)rrr6rrrrs r__neg__zSeries.__neg__$s9}}))15+;+;*;<<FFHHHrc|Srrrs r__pos__zSeries.__pos__'s rc*|Sr)absrs r__abs__zSeries.__abs__*r,rc*|SrrYrs r__copy__zSeries.__copy__-zz||rmemoc*|Srr)rrs r __deepcopy__zSeries.__deepcopy__0rritemc||S|j|Sr) has_nullsimplodercontainsr)rrs r __contains__zSeries.__contains__3sB <>>## #||~~"++D1166888rGenerator[Any]c#^K|jttfvr?|jj}t |D]}||VdSd}t d||D]0}|||Ed{V1dS)Niar) rr;r0r get_indexrangersliceto_list)rridx buffer_sizeoffsets r__iter__zSeries.__iter__8s :$ & &)ITXXZZ(( % %inn$$$$ % %!K488::{;; E E::fk::BBDDDDDDDDDD E ErkeyrcdSrrrr$s r __getitem__zSeries.__getitem__EsAcr(SingleIndexSelector | MultiIndexSelector Any | Seriesc"t||S)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#r&s rr'zSeries.__getitem__Ks8&dC000rFint | Series | np.ndarray[Any, Any] | Sequence[object] | tuple[object]valuec t|tr-t|ts|||dSt|tryt|t sd|js|jr|||dSd|jd}t|t|tr|jtkr"| ||j |_ dS|jtkr:||t |j |_ dS|jt kr"|||j |_ dSdSt#|rt|t$jr|jt$jkr>|t%j|dddf|j |_ dS|t/jdt%j|t$jd}|||dSt|t8t:frB|t=d|t }|||dSd|d }t|) Nzcannot set Series of dtype: z- with list/tuple as value; use a scalar valuerrT)_strictrz cannot use "z" for indexing)rrrrrrr is_numericrrrr1setrrBrrArLrrbool_rrrlnew_u32arrayuint32 __setitem__rtupler)rr$r-rrs rr6zSeries.__setitem__is c3   ! 3(=(= ! LLe $ $ $4 x ( ( !E31G1G !z$$&& $**@*@*B*B  S%(((t&tz&&& C.. c6 " " !yG##((3..1f$$,,sxx'7'7??Bf$$,,sE225%$c " " !z#rz'B'B !yBH$$,,r{3'7'71'=uEEH''$R#ry)A)A4PPP  E***** dE] + + !##$8S$O$O$OPPA   Q & & & & &6666CC.. rnpt.DTypeLike | Nonecopy bool | Nonerc|8|s$|jtkrtjd}|d\}}n(|durd\}}n|durd\}}nd|}t |||| }|A||jkr6|durd |jd |d }t |||}|S) a 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__ NU)FTT)TTF)FFzinvalid input for `copy`: writable allow_copyzcopy not allowed: cast from z to z prohibited)rrr>rrto_numpy RuntimeError __array__)rrr9r>r?rrs rrBzSeries.__array__s& =!1!1=djF6J6JHSMME <#. Hjj T\\#- Hjj U]]#/ Hjj7t77CC.. mmX*mEE  #)!3!3u}}VSYVVEVVV"3'''--&&C rufuncnp.ufuncmethodinputskwargsc|jdkr|jd|j}|dkr'jdkrd}t |g|D]}t |t ttj fr |?t |try| }|jdkr|jd |j dt|d|}t|tjj} djD} | D]} tj| | r| } nd vr,tjd jn| t-j} | rb|rd }t3|jJjd \} }|d kr d iS| |k}nd}t7dt9|}|"dt9d}t ||fd|}||}| r|S|}|D].}t |tr||z}/| tCj"|#tCj$|j%&dSd|d}t |)zNumpy universal functions.r!Tin_place__call__z2only ufuncs that return one 1D array are supportedzunsupported type z for cHg|]}t|d|d S))rH)rinput_output_types rrz*Series.__array_ufunc__..sA%,->r-BCC!"%rrzcan'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.Nz->z()zapply_ufunc_<>zcould not find `apply_ufunc_`c|dS)N)rrr)rargs dtype_charrGrCs rz(Series.__array_ufunc__..sEE4S MMfMMrrzBonly `__call__` is implemented for numpy ufuncs on a Series, got `)'rn_chunksrechunknoutNotImplementedErrorrrrZrrappendr to_physical to_numpy_viewr*r result_typechartypescan_castrpopr signaturerrVsplitrjrFr is_not_nullrrr6whenthenrrr)rrCrErFrGrrargphys_argdtype_char_minimum dtypes_ufunc dtype_ufuncis_generalized_ufunc ufunc_input ufunc_outputallocate_outputrbrresult validity_maskrQrRs ` ` @@r__array_ufunc__zSeries.__array_ufunc__s 7     ! ! GOOTO * * * G Z  zQJ)#...=?D ) )cC #;<< )KK$$$$V,,)"00H{++--11 ++T+:::KK 9 9 ; ;<<<<V.A#.F.FVVsVVC#C..(')nd&;&@  ).L ,   ;1;??)4&Ef$$G,,--22' $(#8#8 # '>>##,wC&s+++ 222,1O,A,A$,G,G) \4''!5$CjCFCCC&1\&AOO"&-/G /S/SUVWWAyL$>> s1 = pl.Series("a", [1]) >>> s1.item() 1 >>> s2 = pl.Series("a", [9, 8, 7]) >>> s2.cum_sum().item(-1) 24 Nr!zlcan only call '.item()' if the Series is of length 1, or an explicit index is provided (Series is of length )r)rr_rrget_index_signed)rrwrs rrz Series.itemAsy =4yyA~~[NQRVii[[[!oo%7$$Q'' 'w''...rrunitr int | floatcT|j}t||S)a 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,)rr|szs rrzSeries.estimated_size\s(FW # # % %2t$$$rcdS)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 rsqrtz Series.sqrtrcdS)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 rcbrtz Series.cbrtrr. ignore_nullsr Literal[True]cdSrrrrs ranyz Series.anyADrcdSrrrs rrz Series.any9<rc8|j|S)a Return whether any of the values in the column are `True`. Only works on columns of data type :class:`Boolean`. Parameters ---------- ignore_nulls Ignore null values (default). If set to `False`, `Kleene logic`_ is used to deal with nulls: if the column contains any null values and no `True` values, the output is `None`. .. _Kleene logic: https://en.wikipedia.org/wiki/Three-valued_logic Returns ------- bool or None Examples -------- >>> 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 rrz Series.anyDw{{ {555rcdSrrrs rallz Series.allrrcdSrrrs rrz Series.allrrc8|j|S)a| Return whether all values in the column are `True`. Only works on columns of data type :class:`Boolean`. Parameters ---------- ignore_nulls Ignore null values (default). 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 rrz Series.allrrbaserZcdS)a 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)rrs rlogz Series.log rrcdS)a8 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 rlog1pz Series.log1prrcdS)a& 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 rlog10z Series.log10.rrcdS)a 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 rexpz Series.exp?rrcdS)a 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_nullszSeries.drop_nullsPrrcdS)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_nanszSeries.drop_nanslrr str | Nonect|tr5tt||jgStt|jgS)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/rkrenamerrrs rrzSeries.to_framesZH dC  @; D(9(9(<'=>>?? ?{DG9--...rg?g?g?nearest percentilesSequence[float] | float | None interpolationrc|||}ddg|_|t jdS)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 │ └────────────┴───────┘ )rr statisticr-)rdescribecolumnsfilterr6rrb)rrrstatss rrzSeries.describesaB ((#')  %g. ||AE'NN6688999rc4|jS)a2 Reduce this Series to the sum value. 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.sum() 6 )rsumrs rrz Series.sumsw{{}}rPythonLiteral | Nonec4|jS)z Reduce this Series to the mean value. Examples -------- >>> s = pl.Series("a", [1, 2, 3]) >>> s.mean() 2.0 )rmeanrs rrz Series.mean sw||~~rc4|jS)z Reduce this Series to the product value. Examples -------- >>> s = pl.Series("a", [1, 2, 3]) >>> s.product() 6 )rproductrs rrzSeries.productsw   rc8t|r)t|tjrt |}|tj|j  | S)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 ] ) rLrrrrrrr6rrrrrs rrz Series.pow!swP H % % (*Xrz*J*J (h''H}}))!% *:*:*>*>x*H*HIISSUUUrc4|jS)z Get the minimal value in this Series. Examples -------- >>> s = pl.Series("a", [1, 2, 3]) >>> s.min() 1 )rminrs rrz Series.minMw{{}}rc4|jS)z Get the maximum value in this Series. Examples -------- >>> s = pl.Series("a", [1, 2, 3]) >>> s.max() 3 )rmaxrs rrz Series.maxYrr/int | float | date | datetime | timedelta | strc|tj|jS)a 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 )rrr6rrnan_maxrrs rrzSeries.nan_maxeD"}}))!% *:*:*B*B*D*DEEJJLLLrc|tj|jS)a 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 )rrr6rrnan_minrrs rrzSeries.nan_minxrrr!ddoffloat | timedelta | Nonec6|j|S)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 )rstdrrs rrz Series.std"w{{4   rc6|j|S)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 rrz Series.varrrc4|jS)z Get the median of this Series. Examples -------- >>> s = pl.Series("a", [1, 2, 3]) >>> s.median() 2.0 )rmedianrs rrz Series.mediansw~~rquantile float | Nonec8|j||S)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 )rr)rrrs rrzSeries.quantiles&w-888r_) separator drop_firstrrcRt|j||S)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. 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)rrrs rrzSeries.to_dummiess%Ptw)))Z@@AAAr)labels left_closedinclude_breaksbreaksSequence[float]rSequence[str] | NonerrcdS)u3 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)rrrrrs rcutz Series.cutrr)rrallow_duplicatesr quantilesSequence[float] | intrcdS)uB 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)rrrrrrs rqcutz Series.qcutF rrcdS)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 rrlez Series.rle rrcdS)a. 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_idz Series.rle_id rr) bin_countinclude_categoryinclude_breakpointbinslist[float] | Nonerrrc2|tj|j||||}|s|s|S|jS)uM 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 │ └────────────┴─────────────┴───────┘ )rrrr) rrr6rrhistrrunnest)rrrrrrs rrz Series.hist sb MMOO Zdi  %%'%5'9 &Y[[ " '*: '<<>> !:$$&& &rsortparallelr normalizerrrc|p|rdnd}tj|j||||S)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 │ └───────┴──────────┘ proportioncountr)rrp _from_pydfr value_counts)rrrrrs rrzSeries.value_counts, sUX? > w|&& G H49 !     rcdS)a? 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_countszSeries.unique_counts rrrc|tj|j||S)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)rrr6rrentropyrr)rrrs rrzSeries.entropy sR. MMOO Zdi((000KK L L Y[[ TVV  r min_periods min_samplesz1.21.0version)rrexprcdS)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)rrrrs rcumulative_evalzSeries.cumulative_eval rrcb|}|j||S)aP 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 ] )rYrr)rrrs rrz Series.alias s** JJLL  Drc,||S)aw 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 ] )rrs rrz Series.rename s.zz$r list[int]c4|jS)a 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 rrzSeries.chunk_lengths s&w$$&&&rc4|jS)a 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 )rrTrs rrTzSeries.n_chunks" s*w!!!r)reverser cdS)a| 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 ] Nrrr s rcum_maxzSeries.cum_max9 rrcdS)a| 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 ] Nrr s rcum_minzSeries.cum_minO rrcdS)a 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 ] Nrr s rcum_prodzSeries.cum_prode rrcdS)a  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 ] Nrr s rcum_sumzSeries.cum_sum rrcdS)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 ] Nrr s r cum_countzSeries.cum_count rrr"lengthc`||j||S)a 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 ] )r"r)rrr)rr"rs rrz Series.slice s*.""47==v=#N#NOOOrc"t|| |j|jn]#t$rP}t |dkr2|j|jnYd}~nd}~wwxYw|S)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 Already mutably borrowedN)r+rrXrArrYrr-excs rrXz Series.append sP $&&&  GNN58 $ $ $ $   3xx555ux~~//000010000   2 B ABB c"t|| |j|jn]#t$rP}t |dkr2|j|jnYd}~nd}~wwxYw|S)aZ 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 rN)r+rextendrArrYrs rrz Series.extend sl $&&&  GNN58 $ $ $ $   3xx555ux~~//000010000   r predicateSeries | Iterable[bool]ct|tstd|}||j|jS)a4 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)rrs rrz Series.filter= sI4)V,, .r9--I""47>>),#?#?@@@r nc|dkr%td||z}||j|S)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)rrrrheadrr#s rr%z Series.head[ IH q55AtxxzzA~&&A""47<<??333rc|dkr%td||z}||j|S)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)rrrrtailr&s rr)z Series.tail r'rc,||S)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 ] )r%r&s rlimitz Series.limit sLyy||rrcdS)a5 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)rr#r"s r gather_everyzSeries.gather_every rr) descending nulls_last multithreadedrJr.r/r0rJc|r#|j||||_|S||j|||S)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 ] )rrr)rr.r/r0rJs rrz Series.sort sXX  gll:z=IIDGK&& Z]CC rrcdS)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 -------- bottom_k Examples -------- >>> s = pl.Series("a", [2, 5, 1, 4, 3]) >>> s.top_k(3) shape: (3,) Series: 'a' [i64] [ 5 4 3 ] Nrrrs rtop_kz Series.top_k% rrcdS)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 Examples -------- >>> s = pl.Series("a", [2, 5, 1, 4, 3]) >>> s.bottom_k(3) shape: (3,) Series: 'a' [i64] [ 1 2 3 ] Nrr4s rbottom_kzSeries.bottom_kG rr)r.r/cdS)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 ] Nrrr.r/s rarg_sortzSeries.arg_sorti rrcdS)a@ 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_uniquezSeries.arg_unique rrc4|jS)z Get the index of the minimal value. Returns ------- int Examples -------- >>> s = pl.Series("a", [3, 2, 1]) >>> s.arg_min() 2 )rarg_minrs rr>zSeries.arg_min w   rc4|jS)z Get the index of the maximal value. Returns ------- int Examples -------- >>> s = pl.Series("a", [3, 2, 1]) >>> s.arg_max() 0 )rarg_maxrs rrAzSeries.arg_max r?relementNonNestedLiteral | NonesidercdSrrrrBrDs r search_sortedzSeries.search_sorted s crDlist[NonNestedLiteral | None] | np.ndarray[Any, Any] | Expr | SeriescdSrrrFs rrGzSeries.search_sorted s rr&IntoExpr | np.ndarray[Any, Any] | None int | Seriesctjtj|||}t |t t tjfr| St|r.t |tj r| S| S)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. 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 ] )r6rr7rGrrrrrrrrLrrr)rrBrDdfs rrGzSeries.search_sorted sjXaeDkk//>> ? ? gfbg6 7 7 <<>> ! g & & :grz+J+J <<>> !7799 r)maintain_orderrNcdS)a 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)rrNs runiquez Series.uniquerrindices6int | list[int] | Expr | Series | np.ndarray[Any, Any]cdS)a` 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)rrQs rgatherz Series.gatherrrc4|jS)z Count the null values in this Series. Examples -------- >>> s = pl.Series([1, None, None]) >>> s.null_count() 2 )r null_countrs rrVzSeries.null_count3sw!!###rc4|jS)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 rrrs rrzSeries.has_nulls?sw  """rz_`has_validity` is deprecated; use `has_nulls` instead to check for the presence of null values.c4|jS)z Check whether the Series contains one or more null values. .. deprecated:: 0.20.30 Use the :meth:`has_nulls` method instead. rXrs r has_validityzSeries.has_validityMsw  """rc2|dkS)z Check if the Series is empty. Examples -------- >>> s = pl.Series("a", [], dtype=pl.Float32) >>> s.is_empty() True rr*rs ris_emptyzSeries.is_emptyZsxxzzQrc8|j||S)a 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_sortedr9s rr^zSeries.is_sortedfs*w  Z888rcZ||jS)ap 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 rrz Series.not_}s"*""47<<>>222rcdS)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_nullzSeries.is_nullrrcdS)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 rrbzSeries.is_not_nullrrcdS)a 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_finitezSeries.is_finiterrcdS)a 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_infinitezSeries.is_infiniterrcdS)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_nanz Series.is_nanrrcdS)a 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_nanzSeries.is_not_nanrr) nulls_equalSeries | Collection[Any]rkcdS)a 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)rr-rks ris_inz Series.is_in rrc.tj|dS)ah 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)r6 arg_wherers rarg_truezSeries.arg_truefs&{4t,,,,rcdS)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_uniquezSeries.is_unique{rrcdS)a 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_distinctzSeries.is_first_distinctrrcdS)a 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_distinctzSeries.is_last_distinctrrcdS)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_duplicatedzSeries.is_duplicatedrrcdS)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 rexplodezSeries.exploderr check_dtypesz0.20.31r} check_names null_equalrrcht|||j|j|||S)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)rr-r}rrs rrz Series.equalss@N $&&&w~~ H%#!    r)rwrap_numerical/type[int | float | str | bool] | PolarsDataTyperc~t|}||j|||S)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 ] )rGrrr)rrrrs rrz Series.cast.s8T!''""47<<v~#N#NOOOrcdS)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 rrYzSeries.to_physical[rr list[Any]c4|jS)a 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()) )rrrs rrzSeries.to_listr?rrIch|j|}|r|n||S)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 )rrUr)rrJopt_ss rrUzSeries.rechunks5@))?ttT%8%8%?%??rcdS)a 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 rr zSeries.reverserrboth lower_boundrz upper_boundclosedrvc$|dkr||k||kz}n;|dkr||k||kz}n'|dkr||k||kz}n|dkr ||k||kz}t|tjr&tj|}|S)as 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 ] nonerrightleft)rrrrr6rr)rrrrrs r is_betweenzSeries.is_betweensD V  +%$*<=CC v  ;&4;+>?CC w  +%$+*=>CC v  ;&4++=>C c27 # # ,(3--))++C r)r>r? use_pyarrowzero_copy_onlyr>r?rrc|tdd| }|tddnd}|rtr|jttt t tfvri|s=|dkr%| sd }t|| | | S|j || S) 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]]) Nzthe `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.10rzthe `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)rr>r=)r"rKrr3r4r5r0r=rTr\r_to_arrowr@r)rr>r?rrrs rr@zSeries.to_numpysn  % %e!     ,+J  " %S"       K  "  48UF"KKK &$--//A"5"5dmmoo"57 oo%==??++#-~, wjIIIrdevicejax.Device | str | None jax.Arrayctdd}t|tr||d}|jjsUt ttj dds|j ttthvr|}nFtttt tt"i}|||j }|t'n||5|j|d d cdddS#1swxYwYdS) ab 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_X640NFr>K)aorder)rQrrdevicesconfigjax_enable_x64rrosenvirongetrr8r:rBr7r9rArrdefault_devicerSasarrayr@)rrjxsrssingle_precisions rto_jaxz Series.to_jaxs|4 L    fc " " +ZZ''*F I $ :C '7==>>?? :z'5&!999CC '%O )),TZ899C$n[]]]"2C2CF2K2K  8##,,,..$                  s0EEE torch.Tensorctd}|jttfvr|t }n-|jt kr|t}n|}|d} |j |}n1#t$r$|jtkrd}t|dwxYw|S)a 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]) rRTrz=cannot convert List dtype to Tensor (use Array dtype instead)N) rQrrArBrr:r@r9r@ from_numpyrr;)rrRr numpy_arraytensorrs rto_torchzSeries.to_torchs2 (( :&&) ) )))E""CC Z6 ! !))E""CCCllDl11  %U%k22FF   zT!!Unn$.    s B.Cfuture compat_levelz1.1)rCompatLevel | Nonercx|d}nt|tr|j}|j|S)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 # doctest: +ELLIPSIS [ 1, 2, 3 ] NF)rrYrrr)rrs rrzSeries.to_arrowsA8   LL  k 2 2 1'0Lw ---r)use_pyarrow_extension_arrayrrc (|jtkr3tj|t |jS|rttjdkrdtj}t|trttjdkr%ttrdtjnd| }tj |jrJ|tjtjtj}|r|jd dddd |}n%|d d }|jd d |i|}|j|_|S) 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!r2z\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*tj|Sr)r ArrowDtype)pa_dtypes rrSz"Series.to_pandas..bsbmH.E.Er) self_destruct split_blocks types_mapperdate_as_objectFr)rr=rrr@rirr) __version__rWrKrrr] is_dictionaryrr dictionaryint64 large_string to_pandasr_)rrrGrpa_arr pd_seriesrs rrzSeries.to_pandassn :  9T]]__FKKK K & R^,,v55FuwvDFF0555% r~)F)F)O)O0*:')~:::  8 ! !&+ . . O[[rxzz2?;L;L!M!MNNF & R(("!EE II$ZZ(8%@@N((QQQ&QQI rc||}t|j}d|jd|d|dS)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=rz)r%rrIrr)rr#rdtype_init_reprs r to_init_reprzSeries.to_init_reprlsQ<1%%'',TZ88MDIMM6MM?MMMMrcT||z S)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 )rrVrs rrz Series.counts!xxzzDOO----rc4|jS)a  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 rrz Series.lens w{{}}rrint | float | str | bool | Nonectd|j|j}|tS|||j|S)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_<>)rjrrrar)rrr-rbs rr1z Series.setsHZ +TZ A A 9! !""11VY#6#6777r3Series | Iterable[int] | int | np.ndarray[Any, Any]7Series | Iterable[PythonLiteral] | PythonLiteral | Nonectt|ts|}|g}t|}|r|St|ts=t|trt|tr|g}t|}|j|j|j|S)u 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)rrrr\rrr)rrQrrws rrzSeries.scattersb'8,,  EgG(((      K&&)) +fh// ":fc3J3J " 6***F  FI... rctjtj||S)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 )r6rr7index_ofr)rrBs rrzSeries.index_of"s6&xd ,,W5566;;===rcj|dkrd|}t||dkr,||jSt |dkr"||jg|jn|}|dkr| d|n|S)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)r#) r_rrclearrr$rrrYextend_constant)rr#rrs rrz Series.clear7s@ q55F1FFCS// ! 66&&tw}}77 74yy1}} NN "DJN G G G 011uuq   +++!;rcZ||jS)a 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 ] )rrrYrs rrYz Series.cloneds".""47==??333rint | float | Expr | NonecdS)aj 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)rr-s rfill_nanzSeries.fill_nan}rrAny | Expr | NonestrategyFillNullStrategy | Noner+cdS)a 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)rr-rr+s r fill_nullzSeries.fill_nullrrc0|d|S)aT 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 backwardrr+rrr+s r backward_fillzSeries.backward_fills"~~z~???rc0|d|S)aS 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 forwardrrrs r forward_fillzSeries.forward_fills"~~y~>>>rcdS)a] 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 rfloorz Series.floorrrcdS)aZ 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 rceilz Series.ceilrr half_to_evendecimalsmodercdS)a 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)rrrs rroundz Series.round'rrdigitscdS)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)rrs rround_sig_figszSeries.round_sig_figsPrrSeries | ArrayLikeint | float | Nonec2t|tst|}t|t|kr5t|t|}}d|d|}t||j|jS)aT 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 )rrrrXrr)rr-r#mrs rrz Series.dotfs %(( "5MME t99E " "t99c%jjqAHaHH1HHCS// !w{{58$$$rcdS)a 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 rrz Series.mode~rrcdS)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 rsignz Series.signrrcdS)aD 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 rsinz Series.sinrrcdS)aG 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 rcosz Series.cosrrcdS)aN 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 rtanz Series.tanrrcdS)aP 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 rcotz Series.cotrrcdS)a. 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 rarcsinz Series.arcsinrrcdS)a/ 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 rarccosz Series.arccosrrcdS)a1 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 rarctanz Series.arctanrrcdS)a: 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 rarcsinhzSeries.arcsinh&rrcdS)aK 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 rarccoshzSeries.arccosh7rrcdS)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 rarctanhzSeries.arctanhIrrcdS)a/ 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 rsinhz Series.sinh^rrcdS)a0 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 rcoshz Series.coshorrcdS)a2 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 rtanhz Series.tanhrr) skip_nullsfunctionCallable[[Any], Any] return_dtypercddlm}|d}nt|}|||jgd||j|||S)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. 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)rr)polars._utils.udfsr!rGrrr map_elements)rrrrr!pl_return_dtypes rr$zSeries.map_elementssZ ?>>>>>  "OO.|<>> 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)rr#r&s rshiftz Series.shiftrrmaskct||||j|j|jS)a 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)rr*r-s rr,zSeries.zip_with&s?X $&&&""47#3#3DGUX#F#FGGGr)rcenter window_sizeweightsr-cdS)ac 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 ] Nrrr.r/rr-s r rolling_minzSeries.rolling_minUrrcdS)ab 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 ] Nrr1s r rolling_maxzSeries.rolling_maxrrcdS)an 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 ] Nrr1s r rolling_meanzSeries.rolling_meanrrcdS)ad 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 ] Nrr1s r rolling_sumzSeries.rolling_sumrr)rr-rcdS)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 ] Nrrr.r/rr-rs r rolling_stdzSeries.rolling_stdrrcdS)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 ] Nrr:s r rolling_varzSeries.rolling_varSrrCallable[[Series], Any]cdS)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)rrr.r/rr-s r rolling_mapzSeries.rolling_maprrcdS)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 ] Nrr1s rrolling_medianzSeries.rolling_medianrrcdS)a 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 1.0 2.0 3.0 4.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)rrrr.r/rr-s rrolling_quantilezSeries.rolling_quantilerr)biasrr-rFcdS)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)rr.rFrr-s r rolling_skewzSeries.rolling_skew;rr)fisherrFrr-rIcdS)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)rr.rIrFrr-s rrolling_kurtosiszSeries.rolling_kurtosisprr)fractionwith_replacementshuffleseedrLrMrNrOcdS)aC 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)rr#rLrMrNrOs rsamplez Series.samplerrcdS)a\ 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_maxzSeries.peak_maxrrcdS)aG 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_minzSeries.peak_minrrc4|jS)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 rrWzSeries.n_uniquesw!!!rc|r|j|S|}|j|S)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_fitrY)rrJrs rrYzSeries.shrink_to_fitsK   G ! ! # # #KZZ\\F I # # % % %Mrseed_1seed_2seed_3cdS)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)rrOrZr[r\s rhashz Series.hash rr)signedr_cdS)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 reinterpretzSeries.reinterpret6rrlinearrycdS)a 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)rrEs r interpolatezSeries.interpolateWrrbycdS)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 ] Nrrres rinterpolate_byzSeries.interpolate_byqrrcdS)a 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 z Series.absrraverage)r.rOrcdS)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)rrEr.rOs rrankz Series.rankrrignore null_behaviorr~cdS)aO 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)rr#rns rdiffz Series.diffrrint | IntoExprColumncdS)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 ] Nrr&s r pct_changezSeries.pct_changerr)rFc6|j|S)az 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)rrFs rruz Series.skewAsXw||D!!!r)rIrFc8|j||S)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)rrIrFs rrwzSeries.kurtosisos<w---r8NumericLiteral | TemporalLiteral | IntoExprColumn | NonecdS)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 rclipz Series.cliprrcdS)aB 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 rrzSeries.lower_boundrrcdS)a7 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 rrzSeries.upper_boundrr)defaultrold,IntoExpr | Sequence[Any] | Mapping[Any, Any]new$IntoExpr | Sequence[Any] | NoDefaultr}IntoExpr | NoDefaultcdS)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" ] Nrrr~rr}rs rr#zSeries.replacerrcdS)ap 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_all(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 ] Nrrs rreplace_strictzSeries.replace_stricterr dimensionstuple[int, ...]c\||j|S)a 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)rrs rrzSeries.reshapes'b""47??:#>#>???rcdS)a 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 1 3 ] Nr)rrOs rrNzSeries.shuffle rr)comspan half_lifealphaadjustrrrrrrrcdS)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)rrrrrrrrs rewm_meanzSeries.ewm_mean7rrstr | timedeltacdS)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)rrers r ewm_mean_byzSeries.ewm_mean_byrr)rrrrrrFrrcdS)am 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 rrrrrrrFrrs rewm_stdzSeries.ewm_stdrrcdS)a^ 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 ] Nrrs rewm_varzSeries.ewm_var7rrcdS)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)rr-r#s rrzSeries.extend_constantrr)r.c\||j|S)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)rr.s r set_sortedzSeries.set_sorteds(,""47#:#::#F#FGGGrc^||j||S)a0 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)rrwrs rrzSeries.new_from_indexs* ""47#9#9%#H#HIIIrcdS)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 ] Nrrs r shrink_dtypezSeries.shrink_dtyperr list[Series]c4|jS)a 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 rrzSeries.get_chunkss0w!!###rcdS)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 rrzSeries.imploderrcdS)z Evaluate the number of set bits.Nrrs rbitwise_count_oneszSeries.bitwise_count_onesrrcdS)z"Evaluate the number of unset Self.Nrrs rbitwise_count_zeroszSeries.bitwise_count_zeros"rrcdS)zIEvaluate the number most-significant set bits before seeing an unset bit.Nrrs rbitwise_leading_oneszSeries.bitwise_leading_ones%rrcdS)zHEvaluate the number most-significant unset bits before seeing a set bit.Nrrs rbitwise_leading_zeroszSeries.bitwise_leading_zeros(rrcdS)zJEvaluate the number least-significant set bits before seeing an unset bit.Nrrs rbitwise_trailing_oneszSeries.bitwise_trailing_ones+rrcdS)zIEvaluate the number least-significant unset bits before seeing a set bit.Nrrs rbitwise_trailing_zeroszSeries.bitwise_trailing_zeros.rrc4|jS)z'Perform an aggregation of bitwise ANDs.)r bitwise_andrs rrzSeries.bitwise_and1w""$$$rc4|jS)z&Perform an aggregation of bitwise ORs.)r bitwise_orrs rrzSeries.bitwise_or5sw!!###rc4|jS)z'Perform an aggregation of bitwise XORs.)r bitwise_xorrs rrzSeries.bitwise_xor9rrc4|jS)zf Get the first element of the Series. Returns `None` if the Series is empty. )rfirstrs rrz Series.first=s w}}rc4|jS)ze Get the last element of the Series. Returns `None` if the Series is empty. )rlastrs rrz Series.lastEs w||~~rc4|jS)z Approximate count of unique values. This is done using the HyperLogLog++ algorithm for cardinality estimation. )rapprox_n_uniquers rrzSeries.approx_n_uniqueMs w&&(((rr]c t|S)z9Create an object namespace of all binary related methods.r\rs rrz Series.binXt$$$rr_c t|S)z>Create an object namespace of all categorical related methods.r^rs rrz Series.cat]sD!!!rrac t|S)z;Create an object namespace of all datetime related methods.r`rs rrz Series.dtbs!&&&rrcc t|S)z7Create an object namespace of all list related methods.rbrs rrz Series.listgsT"""rr[c t|S)z8Create an object namespace of all array related methods.rZrs rrz Series.arrlsd###rrfc t|S)z9Create an object namespace of all string related methods.rers rrz Series.strqrrrhc t|S)z9Create an object namespace of all struct related methods.rgrs rrz Series.structvrrrdctrttjdkrd}t |t |S)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 )r2rz%altair>=5.4.0 is required for `.plot`)rJr)rPrrWrdrs rrz Series.plot{sCh! 2M&2D$E$E $Q$Q9C,S11 1$rdtypesIterable[tuple[str, DataType]]fields!Iterable[tuple[bool, bool, bool]]ctj|jt |t |S)a  Row decode the given Series. This is an internal function not meant for outside consumption and can be changed or removed at any point in time. fields have order: - descending - nulls_last - no_order )rrprr _row_decoder)rrrs rrzSeries._row_decodes8 |&&tw':':4<<f'V'VWWWrcdS)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. Nrrgs r repeat_byzSeries.repeat_byrr)NNN) rrrrrrrrrrrr)rrlrr)rrrrrr)rrrr)rrrrrr)rru)rr)rrrrurr rrr)rrrrrrrr)rr)rrq)rr)rr)rr)rr)rr)rrrr)r-rrrrr)r-r rr)r-r rr4)r-r rTrwrr)r-rirr)r-rirrl)r-r rrl)r-r rrrrrr)r-rprrp)r-r rr)r-r rr)rrrr)rr)rrrr)r-r rr)rr)rrrr)rr rr)rr)r$rrr )r$r|rr)r$r)rr*)r$r,r-r rr)NN)rr8r9r:rr) rCrDrErrFr rGr rr)rqrrrri)rwrxrr )r)r|rrr})rrrr)rrrr:)rrZrr)rrrrp)rr)rrrrrrp)rr})rr)rr)r!)rrrr)r)rrZrrrr)rrrrrrp) rrrrrrrrrr) rrrrrrrrrrrr) rrrrxrrrrrrp) rrrrrrrrrrp)rrZrrrr)rrrrrrrrr)rrrr)rr)r rrr)r rrr)r"rrrxrr)r-rrr)rr rr)r")r#rrr)r)r#rr"rrr) r.rr/rr0rrJrrr)r2)rrrr)r.rr/rrr)rrx).)rBrCrDrrr)rBrHrDrrr)r)rBrJrDrrrK)rNrrr)rQrRrr)rr)r.rr/rrr)r-rlrkrrr) r-rr}rrrrrrr)rrrrrrrr)rr)rJrrr)r)rrzrrzrrvrr) r>rr?rrr:rr:rr)rrrr)rr)rrrr)rrrGr rr)r)r#rrr)rrr-rrr)rQrrrrr)rBrzrrx)r-rrr)r-rrrr+rxrr)r+rxrr)rr)rrrrrr)rrrr)r-rrr)rrrrrrrr)r#rr&r'rr)r*rr-rrr) r.rr/rrrxr-rrr) r.rr/rrrxr-rrrrr) rr>r.rr/rrrxr-rrr)rrCN)rrZrrr.rr/rrrxr-rrr) r.rrFrrrxr-rrr) r.rrIrrFrrrxr-rrr) r#rxrLrrMrrNrrOrxrr)rJrrr)rNNN) rOrrZrxr[rxr\rxrr)r_rrr)rb)rEryrr)rerzrr)rj)rErr.rrOrxrr)r!rm)r#rrnr~rr)r#rqrr)rFrrr)rIrrFrrr)rrxrrxrr) r~rrrr}rrrrr)rrrr)rOrxrr)rrrrrrrrrrrrrrrr)rerzrrrr)rrrrrrrrrrrFrrrrrrr)r-rzr#rqrr)r.rrr)rwrrrrr)rr)rr])rr_)rra)rrc)rr[)rrf)rrh)rrd)rrrrrrp)rerqrr(r __module__ __qualname____doc__r__annotations__rr classmethodrr!rrrrrrrr staticmethodrpropertyrrrrrrrr&r(r+rr0r;rBrHrLrQrfrhrprtryr~rrr|rVrrrrrwrrrrrrrrrrrrrrrrrrrrr r rrrr#r'r6rBrprrvrrrrrrmatherrrrrrrrrrrrrrrrrrrrrr%rrrrrrrrr rrrrrTr rrrrrrXrrr%r)r+r-rr5r7r:r<r>rArGrPrTrVrrZr\r^rrarbrdrfrhrjrnrrrtrvrxrzr|rrrYrrUr rr@rrrrrrrr1rrrrYrrrrrrrrrrrrrrr r r rrrrrrrr$r)r,r2r4r6r8r;r=r@rBrErHrKrQrSrUrWrYr^rardrhr rlrprsrurwrzrrr(r#rrrNrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrs%KKZB & & &J    (,#''+ h! !h!h!h!h!h!h!T[ Z VQQQ [ QQQQ[Q(===[=<<<<:****,    <TTT[T> #' 2Q2Q2Q2Q[2Qh...\.   X X$   X     X      &&&&$$$$IIII///X/ 000X0====000X0 111X1...X. ///X/<<<<///X/ 000X0///X/ 000X0====000X0 111X1I-I-I-I-V...X. 222X2'''' ...X. 222X2(((( ...X. ///X/'''' ...X. ///X/'''' ...X. ///X/**** ...X. ///X/**** ***X* +++X+""""***X* +++X+""""***X* +++X+""""222X2 333X3'V'V'V'VR***X* +++X+""""222X2 333X3'V'V'V'VR***X* +++X+""""***X* +++X+"""")-)-)-)-V999X9 ///X/ ...X. 8 8 8 8///X/ ...X.8888;;;; 333X3 444X488884444X4 555X5 Q Q Q Q///X/ 999X9 000X0 < < < <///X/ 000X08888<<<< <<<<<<<< 7 7 7 7<<<< 8888""""    IIII9999 E E E E???X? AAAXA1111<)!)!)!)!XGK*****Xs+s+s+s+j<<<<<>>>>/////6$%$%$%$%$%L    6    636DDDDDXD <<<X<*."6"6"6"6"6"6H36DDDDDXD <<<X<*."6"6"6"6"6"6H!%     "    "    "    "    8    8&/&/&/&/&/T7I(1F:F:F:F:F:P"     ! ! ! !*V*V*V*VX        MMMM&MMMM&!!!!!&!!!!!&     @I99999,#&%(B(B(B(B(B(BTXZZ (,!$ G G G G G ZG RXZZ (,!!&$[ [ [ [ [ Z[ z    @% % % % NXZZ$(>'!%!%#' >'>'>'>'>'Z>'F Q Q Q Q Q Q f    "%)F       :XZZ   xPPP01E* * * * * QPZ* X2    2''''*"""".*/      ,*/      ,+0      6*/      6,1      .PPPPP20000d>>>>@AAAA<&4&4&4&4&4P&4&4&4&4&4P&&&&&P     B! " 222222h      D      D.3u      >    *!!!! !!!! ILX"%X"';;;;;z05      ,    . $ $ $ $ # # # #Z <### #    /4999999.3333.    .    .    .    .    0    8" D D D D D D L----*    .    0    0    .$ $ $ $ L! >9MMM #! , , , , , NM, d$ +P+P+P+P+P+PZ$ $ $ $ L!!!! +0!@!@!@!@!@!@F    *"( NNNNNf#'&* vJvJvJvJvJvJpXZZ////Z/bXZZ...Z.`! >5III=A.....JI.D6;XXXXXXt N N N N ND.... $08080808d>>>>@>>>>*+<+<+<+<+">E Lr)rrrrrr) __future__r contextlibrrsyscollections.abcrrrrrr r decimalr rtypingr r rrrrrrpolars._reexport _reexportrpolarsrr6polars._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/polars.datatypesr0r1r2r3r4r5r6r7r8r9r:r;r<r=r>r?r@rArBrCrDrErFrGrHpolars.datatypes._utilsrIpolars.dependenciesrJrKrLrMrNrOrPrQrRrSrrTrrUrpolars.exceptionsrVrWrXpolars.interchange.protocolrYpolars.series.arrayr[polars.series.binaryr]polars.series.categoricalr_polars.series.datetimerapolars.series.listrcpolars.series.plottingrdpolars.series.stringrfpolars.series.structrhpolars.series.utilsrirjsuppress ImportError polars.polarsrkrlrmrnror numpy.typingnptrprqrrpolars._typingrsrtrurvrwrxryrzr{r|r}r~rrrrrrrrrrrr version_infortyping_extensionswarningsmodulesrcurrent_moduler ArrayLikerrrrrr sN"""""" ........""""""444444444444((((((                    !!!!!!  988888++++++                      '&&&&&8766666                      ,+++++,,,,,,------RRRRRRRRRR333333......000000222222444444,,,,,,------000000000000;;;;;;;;Z%%44333333334444444444444440.>>>>>>>>>>JJJ000000000020///// 7""****** 7""'''''''0000000.[*N-N  SM   dx dx dx dx dx dx dx dx Nqs% E::E>E>