hTBSSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJ r SS KJ r SS KJ r SS K J r SS KJr SS KJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJ r SSKJ!r! SSK"J#r# SSK"J$r$ SSK"J%r% SSK"J&r& SSK"J'r' SSK"J(r( \(abSSK)J*r* SSK+r,SSK-r.SSK/J0r0 SS K1J2r2 SS!K3J4r4 SS"K5J6r6 SS#K5J7r7 SS$KJ8r8 SS%KJ9r9 SS&KJ:r: SS'KJ;r; SS(KJr> SS+KJ?r? SS,K"J@r@ "S-S.\\5rAg)/) annotations) TYPE_CHECKING)Any)Callable)Generic)Iterator)Literal)Mapping)Sequence)overload)is_numpy_scalar)_validate_dtype) ComputeErrorSeriesCatNamespaceSeriesDateTimeNamespaceSeriesListNamespaceSeriesStringNamespaceSeriesStructNamespace) to_native) IntoSeriesT)NonNestedLiteral)SingleIndexSelector)_validate_rolling_arguments) generate_repr)is_compliant_series)is_index_selector) parse_version)supports_arrow_c_stream) ModuleTypeN)Self) ArrowArray)CompliantSeries DataFrame)MultiIndexSelector)DType)ClosedInterval)FillNullStrategy)NumericLiteral) RankMethod)RollingInterpolationMethod)TemporalLiteral)_1DArray)ImplementationcJ\rSrSrSr\SSj5rSSjr\SSj5rSSSjjr \ SSj5r \ SS j5r SS jr SS jr SSS jjr SS jrSSjr\SSj5rSSjrSSjrSSjrSSjrSSjrSSjr\SSj5r\SSj5rSSSSSSSS.SSjjrSSjrSSjrSSjrSS jrSS!jrSS"jrSS#jr SS$jr!SS%jr"SS&jr#SS'jr$SS(jr%SS)jr&SS*jr'SS+.SS,jjr(SS+.SS-jjr)SSS.jjr*SS/jr+SS0jr,SS1jr-SS2jr.SS3.SS4jjr/SS5.SS6jjr0SS7jr1SS8jr2SSSSS9.SS:jjjr3SS;jr4SS<jr5SSS=.SS>jjjr6SSS?.SS@jjr7SSAjr8SSBjr9SSSCjjr:SSSDjjr;SSEjrSSHjr?SSIjr@SSJjrASSKjrBSSLjrCSSMjrDSSNjrESSOjrFSSPjrGSSQjrHSSRjrISSSjrJSSTjrKSSUjrLSSVjrMSSWjrNSSXjrOSSYjrPSSZjrQSS[jrRSS\jrSSS]jrTSS^jrUSS_jrVSS`jrWSSajrXSSbjrYSScjrZSSdjr[SSejr\SSfjr]SSgjr^SShjr_SSi.SSjjjr`SSSSSk.SSljjraSSmjrbSSnjrcSSSojjrdSSSpjjreSSSqjjrfSSSrjjrgSsSSt.SSujjrhSSSvjjriSSwjrjSSxjrkSSyjrlSS3.SSzjjrmSS3.SS{jjrnSS3.SS|jjroSS3.SS}jjrpSSS~.SSjjrqSSS~.SSjjrrSSSS.SSjjrsSSSS.SSjjrtSSjruSSjrvSSSi.SSjjjrwSSSS.SSjjjrx\SSj5ry\SSj5rz\SSj5r{\SSj5r|\SSj5r}Sr~g)Series6aNarwhals Series, backed by a native series. !!! warning This class is not meant to be instantiated directly - instead: - If the native object is a series from one of the supported backend (e.g. pandas.Series, polars.Series, pyarrow.ChunkedArray), you can use [`narwhals.from_native`][]: ```py narwhals.from_native(native_series, allow_series=True) narwhals.from_native(native_series, series_only=True) ``` - If the object is a generic sequence (e.g. a list or a tuple of values), you can create a series via [`narwhals.new_series`][]: ```py narwhals.new_series( name=name, values=values, backend=narwhals.get_native_namespace(another_object), ) ``` cSSKJn U$)Nrr()narwhals.dataframer))selfr)s A/var/www/html/env/lib/python3.13/site-packages/narwhals/series.py _dataframeSeries._dataframeOs 0cX l[U5(aUR5UlgS[ U5S3n[ U5e)NzQExpected Polars Series or an object which implements `__narwhals_series__`, got: .)_levelr __narwhals_series___compliant_seriestypeAssertionError)r9serieslevelmsgs r:__init__Series.__init__UsN ?D v & &**,  "ffjkqfresstuC % %r=c.URR$)aNReturn implementation of native Series. This can be useful when you need to use special-casing for features outside of Narwhals' scope - for example, when dealing with pandas' Period Dtype. Returns: Implementation. Examples: >>> import narwhals as nw >>> import pandas as pd >>> s_native = pd.Series([1, 2, 3]) >>> s = nw.from_native(s_native, series_only=True) >>> s.implementation >>> s.implementation.is_pandas() True >>> s.implementation.is_pandas_like() True >>> s.implementation.is_polars() False )rB_implementationr9s r:implementationSeries.implementationds:%%555r=Nc4URRXS9$)N)dtypecopy)rB __array__)r9rPrQs r:rRSeries.__array__s%%//e/GGr=cgNr9idxs r: __getitem__Series.__getitem__>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([[1, 2, 3]]) >>> nw.from_native(s_native, series_only=True)[0] 1 >>> nw.from_native(s_native, series_only=True)[ ... :2 ... ].to_native() # doctest:+ELLIPSIS [ [ 1, 2 ] ] >iuz*Unexpected type for `Series.__getitem__`: z. Hints: - use `s.item` to select a single item. - Use `s[indices]` to select rows positionally. - Use `s.filter(mask)` to filter rows based on a boolean mask.) isinstanceintr rPkindrBitemr __class___with_compliant _with_nativer!rC TypeErrorr5)r9rXrGs r:rYrZs%@ c3   C SYY^^z%A",S#"6"6#c(CC))..s3 3 c>>+55 6 6&&t'='='J'J3'OPC %%(>s?T?T(UV Vc3''''##D$:$:3$?@@r=c6URR5$rU)rB__native_namespace__rLs r:riSeries.__native_namespace__s%%::<=16.0.0 is required for `Series.__arrow_c_stream__` for object of type )r) chunked_array) rBnativer#__arrow_c_stream__pyarrowModuleNotFoundErrorrCr"narwhals._arrow.utilsrnto_arrow)r9rl native_seriespaexcrGrncas r:rpSeries.__arrow_c_stream__s..55 "= 1 1 33EU3V V 4   w &cdhivdwcxyC%c* *7 4==? +$$6F$GG# 4cdhivdwcxyC%c* 3 4sB B7B22B7c.URR$)aConvert Narwhals series to native series. Returns: Series of class that user started with. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> s_native = pl.Series([1, 2]) >>> s = nw.from_native(s_native, series_only=True) >>> s.to_native() # doctest: +NORMALIZE_WHITESPACE shape: (2,) Series: '' [i64] [ 1 2 ] )rBrorLs r:rSeries.to_natives(%%,,,r=ctURURRXRU555$)a)Set value(s) at given position(s). Arguments: indices: Position(s) to set items at. values: Values to set. Returns: A new Series with values set at given positions. Note: This method always returns a new Series, without modifying the original one. Using this function in a for-loop is an anti-pattern, we recommend building up your positions and values beforehand and doing an update in one go. For example, instead of ```python for i in [1, 3, 2]: value = some_function(i) s = s.scatter(i, value) ``` prefer ```python positions = [1, 3, 2] values = [some_function(x) for x in positions] s = s.scatter(positions, values) ``` Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> df_native = pa.table({"a": [1, 2, 3], "b": [4, 5, 6]}) >>> df_nw = nw.from_native(df_native) >>> df_nw.with_columns(df_nw["a"].scatter([0, 1], [999, 888])).to_native() pyarrow.Table a: int64 b: int64 ---- a: [[999,888,3]] b: [[4,5,6]] )rerBscatter_extract_native)r9indicesvaluess r:r}Series.scatters7Z##  " " * *74H4H4P Q  r=c8URR54$)aGet the shape of the Series. Returns: A tuple containing the length of the Series. Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> s_native = pd.Series([1, 2, 3]) >>> nw.from_native(s_native, series_only=True).shape (3,) rBlenrLs r:shape Series.shape(s&&**,..r=cJSSKJn [X5(a UR$U$)Nr)r5)narwhals.seriesr5r`rB)r9argr5s r:r~Series._extract_native9s!* c " "(( ( r=c4URXRS9$)NrF)rdr@)r9rEs r:reSeries._with_compliant@s~~fKK~88r=cU"U/UQ70UD6$)aPipe function call. Returns: A new Series with the results of the piped function applied. Examples: >>> import polars as pl >>> import narwhals as nw >>> s_native = pl.Series([1, 2, 3]) >>> s = nw.from_native(s_native, series_only=True) >>> s.pipe(lambda x: x + 2).to_native() # doctest: +NORMALIZE_WHITESPACE shape: (3,) Series: '' [i64] [ 3 4 5 ] rV)r9functionargskwargss r:pipe Series.pipeCs(.t.v..r=cR[SUR5R55$)NzNarwhals Series)rr__repr__rLs r:rSeries.__repr__Ys .0@0I0I0KLLr=c,[UR5$rUrrBrLs r:__len__Series.__len__\s4))**r=c,[UR5$)aHReturn the number of elements in the Series. Null values count towards the total. Returns: The number of elements in the Series. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([[1, 2, None]]) >>> nw.from_native(s_native, series_only=True).len() 3 rrLs r:r Series.len_s 4))**r=c.URR$)aGet the data type of the Series. Returns: The data type of the Series. Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> s_native = pd.Series([1, 2, 3]) >>> nw.from_native(s_native, series_only=True).dtype Int64 )rBrPrLs r:rP Series.dtypeqs%%+++r=c.URR$)aGet the name of the Series. Returns: The name of the Series. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> s_native = pl.Series("foo", [1, 2, 3]) >>> nw.from_native(s_native, series_only=True).name 'foo' )rBnamerLs r:r Series.names%%***r=TFcomspan half_lifealphaadjust min_samples ignore_nullsc ^URURRUUUUUUUS95$)apCompute exponentially-weighted moving average. Arguments: com: Specify decay in terms of center of mass, $\gamma$, with
$\alpha = \frac{1}{1+\gamma}\forall\gamma\geq0$ span: Specify decay in terms of span, $\theta$, with
$\alpha = \frac{2}{\theta + 1} \forall \theta \geq 1$ half_life: Specify decay in terms of half-life, $\tau$, with
$\alpha = 1 - \exp \left\{ \frac{ -\ln(2) }{ \tau } \right\} \forall \tau > 0$ alpha: Specify smoothing factor alpha directly, $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 $w_i = (1 - \alpha)^i$ - When `adjust=False` the EW function is calculated recursively by $$ 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 $x_0$ and $x_2$ used in calculating the final weighted average of $[x_0, None, x_2]$ are $(1-\alpha)^2$ and $1$ if `adjust=True`, and $(1-\alpha)^2$ and $\alpha$ if `adjust=False`. - When `ignore_nulls=True`, weights are based on relative positions. For example, the weights of $x_0$ and $x_2$ used in calculating the final weighted average of $[x_0, None, x_2]$ are $1-\alpha$ and $1$ if `adjust=True`, and $1-\alpha$ and $\alpha$ if `adjust=False`. Returns: Series Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> s_native = pd.Series(name="a", data=[1, 2, 3]) >>> nw.from_native(s_native, series_only=True).ewm_mean( ... com=1, ignore_nulls=False ... ).to_native() 0 1.000000 1 1.666667 2 2.428571 Name: a, dtype: float64 r)rerBewm_mean)r9rrrrrrrs r:rSeries.ewm_meansFz##  " " + +#') ,   r=cl[U5 URURRU55$)aCast between data types. Arguments: dtype: Data type that the object will be cast into. Returns: A new Series with the specified data type. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([[True, False, True]]) >>> nw.from_native(s_native, series_only=True).cast(nw.Int64).to_native() [ [ 1, 0, 1 ] ] )rrerBcast)r9rPs r:r Series.casts.0 ##D$:$:$?$?$FGGr=cfURURR5URS9$)uConvert to dataframe. Returns: A DataFrame containing this Series as a single column. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> s_native = pl.Series("a", [1, 2]) >>> nw.from_native(s_native, series_only=True).to_frame().to_native() shape: (2, 1) ┌─────┐ │ a │ │ --- │ │ i64 │ ╞═════╡ │ 1 │ │ 2 │ └─────┘ r)r;rBto_framer@rLs r:rSeries.to_frames3,  " " + + -++  r=c6URR5$)aConvert to list. Notes: This function converts to Python scalars. It's typically more efficient to keep your data in the format native to your original dataframe, so we recommend only calling this when you absolutely need to. Returns: A list of Python objects. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([[1, 2, 3]]) >>> nw.from_native(s_native, series_only=True).to_list() [1, 2, 3] )rBto_listrLs r:rSeries.to_lists(%%--//r=c6URR5$)a#Reduce this Series to the mean value. Returns: The average of all elements in the Series. Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> s_native = pd.Series([1.2, 4.2]) >>> nw.from_native(s_native, series_only=True).mean() np.float64(2.7) )rBmeanrLs r:r Series.mean(s%%**,,r=c6URR5$)aReduce this Series to the median value. Notes: Results might slightly differ across backends due to differences in the underlying algorithms used to compute the median. Returns: The median value of all elements in the Series. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([[5, 3, 8]]) >>> nw.from_native(s_native, series_only=True).median() 5.0 )rBmedianrLs r:r Series.median8s"%%,,..r=c6URR5$)aCalculate the sample skewness of the Series. Returns: The sample skewness of the Series. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> s_native = pl.Series([1, 1, 2, 10, 100]) >>> nw.from_native(s_native, series_only=True).skew() 1.4724267269058975 Notes: The skewness is a measure of the asymmetry of the probability distribution. A perfectly symmetric distribution has a skewness of 0. )rBskewrLs r:r Series.skewKs$%%**,,r=c6URR5$)a7Returns the number of non-null elements in the Series. Returns: The number of non-null elements in the Series. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([[1, 2, None]]) >>> nw.from_native(s_native, series_only=True).count() 2 )rBcountrLs r:r Series.count_s%%++--r=c6URR5$)a}Return whether any of the values in the Series are True. Notes: Only works on Series of data type Boolean. Returns: A boolean indicating if any values in the Series are True. Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> s_native = pd.Series([False, True, False]) >>> nw.from_native(s_native, series_only=True).any() np.True_ )rBanyrLs r:r Series.anyos"%%))++r=c6URR5$)aHReturn whether all values in the Series are True. Returns: A boolean indicating if all values in the Series are True. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([[False, True, False]]) >>> nw.from_native(s_native, series_only=True).all() False )rBallrLs r:r Series.all%%))++r=c6URR5$)a Get the minimal value in this Series. Returns: The minimum value in the Series. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> s_native = pl.Series([1, 2, 3]) >>> nw.from_native(s_native, series_only=True).min() 1 )rBminrLs r:r Series.minrr=c6URR5$)aGet the maximum value in this Series. Returns: The maximum value in the Series. Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> s_native = pd.Series([1, 2, 3]) >>> nw.from_native(s_native, series_only=True).max() np.int64(3) )rBmaxrLs r:r Series.maxrr=c6URR5$)zReturns the index of the minimum value. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([[1, 2, 3]]) >>> nw.from_native(s_native, series_only=True).arg_min() 0 )rBarg_minrLs r:rSeries.arg_min%%--//r=c6URR5$)zReturns the index of the maximum value. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> s_native = pl.Series([1, 2, 3]) >>> nw.from_native(s_native, series_only=True).arg_max() 2 )rBarg_maxrLs r:rSeries.arg_maxrr=c6URR5$)aReduce this Series to the sum value. Returns: The sum of all elements in the Series. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([[1, 2, 3]]) >>> nw.from_native(s_native, series_only=True).sum() 6 )rBsumrLs r:r Series.sumrr=ddofc4URRUS9$)aGet the standard deviation of this Series. Arguments: ddof: "Delta Degrees of Freedom": the divisor used in the calculation is N - ddof, where N represents the number of elements. Returns: The standard deviation of all elements in the Series. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> s_native = pl.Series([1, 2, 3]) >>> nw.from_native(s_native, series_only=True).std() 1.0 r)rBstdr9rs r:r Series.stds$%%))t)44r=c4URRUS9$)a|Get the variance of this Series. Arguments: ddof: "Delta Degrees of Freedom": the divisor used in the calculation is N - ddof, where N represents the number of elements. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([[1, 2, 3]]) >>> nw.from_native(s_native, series_only=True).var() 1.0 r)rBvarrs r:r Series.vars%%))t)44r=cURURRURU5URU5S95$)aClip values in the Series. Arguments: lower_bound: Lower bound value. upper_bound: Upper bound value. Returns: A new Series with values clipped to the specified bounds. Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> s_native = pd.Series([-1, 1, -3, 3, -5, 5]) >>> nw.from_native(s_native, series_only=True).clip(-1, 3).to_native() 0 -1 1 1 2 -1 3 3 4 -1 5 3 dtype: int64 ) lower_bound upper_bound)rerBclipr~)r9rrs r:r Series.clipsL8##  " " ' ' 00= 00= (   r=c fURURR[USS955$)a>Check if the elements of this Series are in the other sequence. Arguments: other: Sequence of primitive type. Returns: A new Series with boolean values indicating if the elements are in the other sequence. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([[1, 2, 3]]) >>> s = nw.from_native(s_native, series_only=True) >>> s.is_in([3, 2, 8]).to_native() # doctest: +ELLIPSIS [ [ false, true, true ] ] T) pass_through)rerBis_inrr9others r:r Series.is_in$s22##  " " ( (5t)L M  r=cTURURR55$)aFind elements where boolean Series is True. Returns: A new Series with the indices of elements that are True. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> s_native = pl.Series([1, None, None, 2]) >>> nw.from_native( ... s_native, series_only=True ... ).is_null().arg_true().to_native() # doctest: +NORMALIZE_WHITESPACE shape: (2,) Series: '' [u32] [ 1 2 ] )rerBarg_truerLs r:rSeries.arg_trueAs$*##D$:$:$C$C$EFFr=cTURURR55$)aDrop null values. Notes: pandas handles null values differently from Polars and PyArrow. See [null_handling](../pandas_like_concepts/null_handling.md/) for reference. Returns: A new Series with null values removed. Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> s_native = pd.Series([2, 4, None, 3, 5]) >>> nw.from_native(s_native, series_only=True).drop_nulls().to_native() 0 2.0 1 4.0 3 3.0 4 5.0 dtype: float64 )rerB drop_nullsrLs r:rSeries.drop_nullsXs$.##D$:$:$E$E$GHHr=cTURURR55$)aCalculate the absolute value of each element. Returns: A new Series with the absolute values of the original elements. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([[2, -4, 3]]) >>> nw.from_native( ... s_native, series_only=True ... ).abs().to_native() # doctest: +ELLIPSIS [ [ 2, 4, 3 ] ] )rerBabsrLs r:r Series.absqs$.##D$:$:$>$>$@AAr=reversecRURURRUS95$)aCalculate the cumulative sum. Arguments: reverse: reverse the operation Returns: A new Series with the cumulative sum of non-null values. Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> s_native = pd.Series([2, 4, 3]) >>> nw.from_native(s_native, series_only=True).cum_sum().to_native() 0 2 1 6 2 9 dtype: int64 r)rerBcum_sumr9rs r:rSeries.cum_sums)(##D$:$:$B$B7$B$STTr=maintain_ordercRURURRUS95$)aReturns unique values of the series. Arguments: maintain_order: Keep the same order as the original series. This may be more expensive to compute. Settings this to `True` blocks the possibility to run on the streaming engine for Polars. Returns: A new Series with duplicate values removed. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> s_native = pl.Series([2, 4, 4, 6]) >>> s = nw.from_native(s_native, series_only=True) >>> s.unique( ... maintain_order=True ... ).to_native() # doctest: +NORMALIZE_WHITESPACE shape: (3,) Series: '' [i64] [ 2 4 6 ] r)rerBunique)r9rs r:r Series.uniques.8##  " " ) ) ) H  r=cTURURR55$)afCalculate the difference with the previous element, for each element. Notes: pandas may change the dtype here, for example when introducing missing values in an integer column. To ensure, that the dtype doesn't change, you may want to use `fill_null` and `cast`. For example, to calculate the diff and fill missing values with `0` in a Int64 column, you could do: s.diff().fill_null(0).cast(nw.Int64) Returns: A new Series with the difference between each element and its predecessor. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([[2, 4, 3]]) >>> nw.from_native( ... s_native, series_only=True ... ).diff().to_native() # doctest: +ELLIPSIS [ [ null, 2, -1 ] ] )rerBdiffrLs r:r Series.diffs%@##D$:$:$?$?$ABBr=cVURURRU55$)aGShift values by `n` positions. Arguments: n: Number of indices to shift forward. If a negative value is passed, values are shifted in the opposite direction instead. Returns: A new Series with values shifted by n positions. Notes: pandas may change the dtype here, for example when introducing missing values in an integer column. To ensure, that the dtype doesn't change, you may want to use `fill_null` and `cast`. For example, to shift and fill missing values with `0` in a Int64 column, you could do: s.shift(1).fill_null(0).cast(nw.Int64) Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> s_native = pd.Series([2, 4, 3]) >>> nw.from_native(s_native, series_only=True).shift(1).to_native() 0 NaN 1 2.0 2 4.0 dtype: float64 )rerBshiftr9ns r:r Series.shifts&<##D$:$:$@$@$CDDr=)fractionwith_replacementseedc TURURRXX4S95$)aSample randomly from this Series. Arguments: n: Number of items to return. Cannot be used with fraction. fraction: Fraction of items to return. Cannot be used with n. with_replacement: Allow values to be sampled more than once. seed: Seed for the random number generator. If set to None (default), a random seed is generated for each sample operation. Returns: A new Series containing randomly sampled values from the original Series. Notes: The `sample` method returns a Series with a specified number of randomly selected items chosen from this Series. The results are not consistent across libraries. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> s_native = pl.Series([1, 2, 3, 4]) >>> s = nw.from_native(s_native, series_only=True) >>> s.sample( ... fraction=1.0, with_replacement=True ... ).to_native() # doctest: +SKIP shape: (4,) Series: '' [i64] [ 1 4 3 4 ] )rr r r )rerBsample)r9rr r r s r:r Series.samples7V##  " " ) )9I *   r=cRURURRUS95$)aRename the Series. Notes: This method is very cheap, but does not guarantee that data will be copied. For example: ```python s1: nw.Series s2 = s1.alias("foo") arr = s2.to_numpy() arr[0] = 999 ``` may (depending on the backend, and on the version) result in `s1`'s data being modified. We recommend: - if you need to alias an object and don't need the original one around any more, just use `alias` without worrying about it. - if you were expecting `alias` to copy data, then explicitly call `.clone` before calling `alias`. Arguments: name: The new name. Returns: A new Series with the updated name. Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> s_native = pd.Series([1, 2, 3], name="foo") >>> nw.from_native(s_native, series_only=True).alias("bar").to_native() 0 1 1 2 2 3 Name: bar, dtype: int64 r)rerBaliasr9rs r:r Series.alias3s*N##D$:$:$@$@d$@$KLLr=c URUS9$)aRename the Series. Alias for `Series.alias()`. Notes: This method is very cheap, but does not guarantee that data will be copied. For example: ```python s1: nw.Series s2 = s1.rename("foo") arr = s2.to_numpy() arr[0] = 999 ``` may (depending on the backend, and on the version) result in `s1`'s data being modified. We recommend: - if you need to rename an object and don't need the original one around any more, just use `rename` without worrying about it. - if you were expecting `rename` to copy data, then explicitly call `.clone` before calling `rename`. Arguments: name: The new name. Returns: A new Series with the updated name. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> s_native = pl.Series("foo", [1, 2, 3]) >>> s = nw.from_native(s_native, series_only=True) >>> s.rename("bar").to_native() # doctest: +NORMALIZE_WHITESPACE shape: (3,) Series: 'bar' [i64] [ 1 2 3 ] r)rrs r:rename Series.rename\sZzztz$$r= return_dtypecUcT[U[5(d Sn[U5e[UR 55n[UR 55nUR URRXUS95$)a9Replace all values by different values. This function must replace all non-null input values (else it raises an error). Arguments: old: Sequence of values to replace. It also accepts a mapping of values to their replacement as syntactic sugar for `replace_all(old=list(mapping.keys()), new=list(mapping.values()))`. new: Sequence of values to replace by. Length must match the length of `old`. 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. Returns: A new Series with values replaced according to the mapping. Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> s_native = pd.Series([3, 0, 1, 2], name="a") >>> nw.from_native(s_native, series_only=True).replace_strict( ... [0, 1, 2, 3], ... ["zero", "one", "two", "three"], ... return_dtype=nw.String, ... ).to_native() 0 three 1 zero 2 one 3 two Name: a, dtype: object zB`new` argument is required if `old` argument is not a Mapping typer) r`r rglistrkeysrerBreplace_strict)r9oldnewrrGs r:rSeries.replace_strictsrN ;c7++Zn$szz|$Csxxz"C##  " " 1 1# 1 V  r= descending nulls_lastcRURURRXS95$)aSort this Series. Place null values first. Arguments: descending: Sort in descending order. nulls_last: Place null values last instead of first. Returns: A new sorted Series. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> s_native = pl.Series([5, None, 1, 2]) >>> s = nw.from_native(s_native, series_only=True) >>> s.sort(descending=True).to_native() # doctest: +NORMALIZE_WHITESPACE shape: (4,) Series: '' [i64] [ null 5 2 1 ] r!)rerBsort)r9r"r#s r:r% Series.sorts.4##  " " ' ': ' U  r=cTURURR55$)aReturns a boolean Series indicating which values are null. Notes: pandas handles null values differently from Polars and PyArrow. See [null_handling](../pandas_like_concepts/null_handling.md/) for reference. Returns: A boolean Series indicating which values are null. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([[1, 2, None]]) >>> nw.from_native( ... s_native, series_only=True ... ).is_null().to_native() # doctest:+ELLIPSIS [ [ false, false, true ] ] )rerBis_nullrLs r:r(Series.is_nulls$8##D$:$:$B$B$DEEr=cTURURR55$)a1Returns a boolean Series indicating which values are NaN. Returns: A boolean Series indicating which values are NaN. Notes: pandas handles null values differently from Polars and PyArrow. See [null_handling](../pandas_like_concepts/null_handling.md/) for reference. Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> s_native = pd.Series([0.0, None, 2.0], dtype="Float64") >>> nw.from_native(s_native, series_only=True).is_nan().to_native() 0 False 1 2 False dtype: boolean )rerBis_nanrLs r:r+ Series.is_nans$,##D$:$:$A$A$CDDr=cUbUb Sn[U5eUcUc Sn[U5eUbUS;aSU3n[U5eURURRUR U5X#S95$)aFill null values using the specified value. Arguments: value: Value used to fill null values. strategy: Strategy used to fill null values. limit: Number of consecutive null values to fill when using the 'forward' or 'backward' strategy. Notes: pandas handles null values differently from Polars and PyArrow. See [null_handling](../pandas_like_concepts/null_handling.md/) for reference. Returns: A new Series with null values filled according to the specified value or strategy. Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> s_native = pd.Series([1, 2, None]) >>> >>> nw.from_native(s_native, series_only=True).fill_null(5).to_native() 0 1.0 1 2.0 2 5.0 dtype: float64 Or using a strategy: >>> nw.from_native(s_native, series_only=True).fill_null( ... strategy="forward", limit=1 ... ).to_native() 0 1.0 1 2.0 2 2.0 dtype: float64 z*cannot specify both `value` and `strategy`z0must specify either a fill `value` or `strategy`>forwardbackwardzstrategy not supported: )valuestrategylimit) ValueErrorrerB fill_nullr~)r9r0r1r2rGs r:r4Series.fill_nullsV  !5>CS/ ! =X-DCS/ !  H4K$K,XJ7CS/ !##  " " , ,**51H -   r=cURURRURU5URU5US95$)avGet a boolean mask of the values that are between the given lower/upper bounds. Arguments: lower_bound: Lower bound value. upper_bound: Upper bound value. closed: 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 values will be False, as no value can satisfy the condition. Returns: A boolean Series indicating which values are between the given bounds. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([[1, 2, 3, 4, 5]]) >>> s = nw.from_native(s_native, series_only=True) >>> s.is_between(2, 4, "right").to_native() # doctest: +ELLIPSIS [ [ false, false, true, true, false ] ] )closed)rerB is_betweenr~)r9rrr7s r:r8Series.is_betweenLsPL##  " " - -$$[1$$[1 .   r=c6URR5$)aCount the number of unique values. Returns: Number of unique values in the Series. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> s_native = pl.Series([1, 2, 2, 3]) >>> nw.from_native(s_native, series_only=True).n_unique() 3 )rBn_uniquerLs r:r;Series.n_uniquezs%%..00r=c6URRSSS9$)a!Convert to numpy. Returns: NumPy ndarray representation of the Series. Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> s_native = pd.Series([1, 2, 3], name="a") >>> nw.from_native(s_native, series_only=True).to_numpy() array([1, 2, 3]...) N)rQ)rBto_numpyrLs r:r>Series.to_numpys %%..t$.??r=c6URR5$)aRConvert to pandas Series. Returns: A pandas Series containing the data from this Series. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> s_native = pl.Series("a", [1, 2, 3]) >>> nw.from_native(s_native, series_only=True).to_pandas() 0 1 1 2 2 3 Name: a, dtype: int64 )rB to_pandasrLs r:rASeries.to_pandass"%%//11r=c6URR5$)aConvert to polars Series. Returns: A polars Series containing the data from this Series. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([[1, 2, 3]]) >>> nw.from_native( ... s_native, series_only=True ... ).to_polars() # doctest: +NORMALIZE_WHITESPACE shape: (3,) Series: '' [i64] [ 1 2 3 ] )rB to_polarsrLs r:rDSeries.to_polarss,%%//11r=ctURURRURU555$rU)rerB__add__r~rs r:rGSeries.__add__4##  " " * *4+?+?+F G  r=ctURURRURU555$rU)rerB__radd__r~rs r:rKSeries.__radd__4##  " " + +D,@,@,G H  r=ctURURRURU555$rU)rerB__sub__r~rs r:rOSeries.__sub__rIr=ctURURRURU555$rU)rerB__rsub__r~rs r:rRSeries.__rsub__rMr=ctURURRURU555$rU)rerB__mul__r~rs r:rUSeries.__mul__rIr=ctURURRURU555$rU)rerB__rmul__r~rs r:rXSeries.__rmul__rMr=ctURURRURU555$rU)rerB __truediv__r~rs r:r[Series.__truediv__s4##  " " . .t/C/CE/J K  r=ctURURRURU555$rU)rerB __rtruediv__r~rs r:r^Series.__rtruediv__4##  " " / /0D0DU0K L  r=ctURURRURU555$rU)rerB __floordiv__r~rs r:rbSeries.__floordiv__r`r=ctURURRURU555$rU)rerB __rfloordiv__r~rs r:reSeries.__rfloordiv__s4##  " " 0 01E1Ee1L M  r=ctURURRURU555$rU)rerB__pow__r~rs r:rhSeries.__pow__rIr=ctURURRURU555$rU)rerB__rpow__r~rs r:rkSeries.__rpow__rMr=ctURURRURU555$rU)rerB__mod__r~rs r:rnSeries.__mod__rIr=ctURURRURU555$rU)rerB__rmod__r~rs r:rqSeries.__rmod__rMr=ctURURRURU555$rU)rerB__eq__r~rs r:rt Series.__eq__ 4##  " " ) )$*>*>u*E F  r=ctURURRURU555$rU)rerB__ne__r~rs r:rx Series.__ne__rvr=ctURURRURU555$rU)rerB__gt__r~rs r:r{ Series.__gt__rvr=ctURURRURU555$rU)rerB__ge__r~rs r:r~ Series.__ge__rvr=ctURURRURU555$rU)rerB__lt__r~rs r:r Series.__lt__rvr=ctURURRURU555$rU)rerB__le__r~rs r:r Series.__le__$rvr=ctURURRURU555$rU)rerB__and__r~rs r:rSeries.__and__)rIr=ctURURRURU555$rU)rerB__rand__r~rs r:rSeries.__rand__.rMr=ctURURRURU555$rU)rerB__or__r~rs r:r Series.__or__3rvr=ctURURRURU555$rU)rerB__ror__r~rs r:rSeries.__ror__8rIr=cTURURR55$rU)rerB __invert__rLs r:rSeries.__invert__>s"##D$:$:$E$E$GHHr=ctURURRURU555$)aFilter elements in the Series based on a condition. Returns: A new Series with elements that satisfy the condition. Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> s_native = pd.Series([4, 10, 15, 34, 50]) >>> s_nw = nw.from_native(s_native, series_only=True) >>> s_nw.filter(s_nw > 10).to_native() 2 15 3 34 4 50 dtype: int64 )rerBfilterr~)r9 predicates r:r Series.filterAs6$##  " " ) )$*>*>y*I J  r=c$UR5)$)aGet a mask of all duplicated rows in the Series. Returns: A new Series with boolean values indicating duplicated rows. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([[1, 2, 3, 1]]) >>> nw.from_native( ... s_native, series_only=True ... ).is_duplicated().to_native() # doctest: +ELLIPSIS [ [ true, false, false, true ] ] ) is_uniquerLs r: is_duplicatedSeries.is_duplicatedXs0   r=c<URR5S:H$)a^Check if the series is empty. Returns: A boolean indicating if the series is empty. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> s_native = pl.Series([1, 2, 3]) >>> s_nw = nw.from_native(s_native, series_only=True) >>> s_nw.is_empty() False >>> s_nw.filter(s_nw > 10).is_empty() True rrrLs r:is_emptySeries.is_emptyrs$%%))+q00r=cTURURR55$)aGet a mask of all unique rows in the Series. Returns: A new Series with boolean values indicating unique rows. Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> s_native = pd.Series([1, 2, 3, 1]) >>> nw.from_native(s_native, series_only=True).is_unique().to_native() 0 False 1 True 2 True 3 False dtype: bool )rerBrrLs r:rSeries.is_uniques$$##D$:$:$D$D$FGGr=c6URR5$)aCount the number of null values. Notes: pandas handles null values differently from Polars and PyArrow. See [null_handling](../pandas_like_concepts/null_handling.md/) for reference. Returns: The number of null values in the Series. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([[1, None, None]]) >>> nw.from_native(s_native, series_only=True).null_count() 2 )rB null_countrLs r:rSeries.null_counts&%%0022r=cTURURR55$)a0Return a boolean mask indicating the first occurrence of each distinct value. Returns: A new Series with boolean values indicating the first occurrence of each distinct value. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> s_native = pl.Series([1, 1, 2, 3, 2]) >>> nw.from_native( ... s_native, series_only=True ... ).is_first_distinct().to_native() # doctest: +NORMALIZE_WHITESPACE shape: (5,) Series: '' [bool] [ true false true true false ] )rerBis_first_distinctrLs r:rSeries.is_first_distincts$0##D$:$:$L$L$NOOr=cTURURR55$)aReturn a boolean mask indicating the last occurrence of each distinct value. Returns: A new Series with boolean values indicating the last occurrence of each distinct value. Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> s_native = pd.Series([1, 1, 2, 3, 2]) >>> nw.from_native(s_native, series_only=True).is_last_distinct().to_native() 0 False 1 True 2 False 3 True 4 True dtype: bool )rerBis_last_distinctrLs r:rSeries.is_last_distincts$&##D$:$:$K$K$MNNr=r"c4URRUS9$)aCheck if the Series is sorted. Arguments: descending: Check if the Series is sorted in descending order. Returns: A boolean indicating if the Series is sorted. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([[3, 2, 1]]) >>> s_nw = nw.from_native(s_native, series_only=True) >>> s_nw.is_sorted(descending=False) False >>> s_nw.is_sorted(descending=True) True r)rB is_sorted)r9r"s r:rSeries.is_sorteds,%%//:/FFr=r%parallelr normalizec fURURRXX4S9URS9$)aCount the occurrences of unique values. Arguments: sort: Sort the output by count in descending order. If set to False (default), the order of the output is random. parallel: Execute the computation in parallel. Used for Polars only. name: Give the resulting count column a specific name; if `normalize` is True defaults to "proportion", otherwise defaults to "count". normalize: If true gives relative frequencies of the unique values Returns: A DataFrame with two columns: - The original values as first column - Either count or proportion as second column, depending on normalize parameter. Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> s_native = pd.Series([1, 1, 2, 3, 2], name="s") >>> nw.from_native(s_native, series_only=True).value_counts( ... sort=True ... ).to_native() s count 0 1 2 1 2 2 2 3 1 rr)r;rB value_countsr@)r9r%rrrs r:rSeries.value_countssBH  " " / /4 0 ++   r=c4URRXS9$)acGet quantile value of the series. Note: pandas and Polars may have implementation differences for a given interpolation method. Arguments: quantile: Quantile between 0.0 and 1.0. interpolation: Interpolation method. Returns: The quantile value. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> s_native = pl.Series(list(range(50))) >>> s_nw = nw.from_native(s_native, series_only=True) >>> [ ... s_nw.quantile(quantile=q, interpolation="nearest") ... for q in (0.1, 0.25, 0.5, 0.75, 0.9) ... ] [5.0, 12.0, 25.0, 37.0, 44.0] )quantile interpolation)rBr)r9rrs r:rSeries.quantile!s%6%%../  r=cURURRURU5URU555$)aTake 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. Arguments: mask: Boolean Series other: Series of same type. Returns: A new Series with values selected from self or other based on the mask. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> data_native = pa.chunked_array([[1, 2, 3, 4, 5]]) >>> other_native = pa.chunked_array([[5, 4, 3, 2, 1]]) >>> mask_native = pa.chunked_array([[True, False, True, False, True]]) >>> >>> data_nw = nw.from_native(data_native, series_only=True) >>> other_nw = nw.from_native(other_native, series_only=True) >>> mask_nw = nw.from_native(mask_native, series_only=True) >>> >>> data_nw.zip_with(mask_nw, other_nw).to_native() # doctest: +ELLIPSIS [ [ 1, 4, 3, 2, 5 ] ] )rerBzip_withr~)r9maskrs r:rSeries.zip_with@sGH##  " " + +$$T*D,@,@,G   r=c4URRUS9$)aReturn the Series as a scalar, or return the element at the given index. If no index is provided, this is equivalent to `s[0]`, with a check that the shape is (1,). With an index, this is equivalent to `s[index]`. Returns: The scalar value of the Series or the element at the given index. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> nw.from_native(pl.Series("a", [1]), series_only=True).item() 1 >>> nw.from_native(pl.Series("a", [9, 8, 7]), series_only=True).item(-1) 7 )index)rBrc)r9rs r:rc Series.itemjs&%%***77r=cVURURRU55$)aqGet the first `n` rows. Arguments: n: Number of rows to return. Returns: A new Series containing the first n rows. Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> s_native = pd.Series(list(range(10))) >>> nw.from_native(s_native, series_only=True).head(3).to_native() 0 0 1 1 2 2 dtype: int64 )rerBheadrs r:r Series.heads&(##D$:$:$?$?$BCCr=cVURURRU55$)aGet the last `n` rows. Arguments: n: Number of rows to return. Returns: A new Series with the last n rows. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([list(range(10))]) >>> s = nw.from_native(s_native, series_only=True) >>> s.tail(3).to_native() # doctest: +ELLIPSIS [ [ 7, 8, 9 ] ] )rerBtailrs r:r Series.tails&2##D$:$:$?$?$BCCr=cVURURRU55$)a_Round underlying floating point data by `decimals` digits. Arguments: decimals: Number of decimals to round by. Returns: A new Series with rounded values. Notes: For values exactly halfway between rounded decimal values pandas behaves differently than Polars and Arrow. pandas rounds to the nearest even value (e.g. -0.5 and 0.5 round to 0.0, 1.5 and 2.5 round to 2.0, 3.5 and 4.5 to 4.0, etc..). Polars and Arrow round away from 0 (e.g. -0.5 to -1.0, 0.5 to 1.0, 1.5 to 2.0, 2.5 to 3.0, etc..). Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> s_native = pl.Series([1.12345, 2.56789, 3.901234]) >>> s = nw.from_native(s_native, series_only=True) >>> s.round(1).to_native() # doctest: +NORMALIZE_WHITESPACE shape: (3,) Series: '' [f64] [ 1.1 2.6 3.9 ] )rerBround)r9decimalss r:r Series.rounds'@##D$:$:$@$@$JKKr=_ separator drop_firstcdURURRXS9URS9$)aCGet dummy/indicator variables. Arguments: separator: Separator/delimiter used when generating column names. drop_first: Remove the first category from the variable being encoded. Returns: A new DataFrame containing the dummy/indicator variables. Notes: pandas and Polars handle null values differently. Polars distinguishes between NaN and Null, whereas pandas doesn't. Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> s_native = pd.Series([1, 2, 3], name="a") >>> s_nw = nw.from_native(s_native, series_only=True) >>> s_nw.to_dummies(drop_first=False).to_native() a_1 a_2 a_3 0 1 0 0 1 0 1 0 2 0 0 1 >>> s_nw.to_dummies(drop_first=True).to_native() a_2 a_3 0 0 0 1 1 0 2 0 1 rr)r;rB to_dummiesr@)r9rrs r:rSeries.to_dummiess9F  " " - - - Y++  r=cRURURRXS95$)a5Take every nth value in the Series and return as new Series. Arguments: n: Gather every *n*-th row. offset: Starting index. Returns: A new Series with every nth value starting from the offset. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([[1, 2, 3, 4]]) >>> nw.from_native(s_native, series_only=True).gather_every( ... n=2, offset=1 ... ).to_native() # doctest:+ELLIPSIS [ [ 2, 4 ] ] )roffset)rerB gather_every)r9rrs r:rSeries.gather_everys.4##  " " / /! / C  r=c6URR5$)aConvert to arrow. Returns: A PyArrow Array containing the data from the Series. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> s_native = pl.Series([1, 2, 3, 4]) >>> nw.from_native( ... s_native, series_only=True ... ).to_arrow() # doctest:+NORMALIZE_WHITESPACE [ 1, 2, 3, 4 ] )rBrtrLs r:rtSeries.to_arrows,%%..00r=cTURURR55$)aCompute the most occurring value(s). Can return multiple values. Returns: A new Series containing the mode(s) (values that appear most frequently). Examples: >>> import pandas as pd >>> import narwhals as nw >>> s_native = pd.Series([1, 1, 2, 2, 3]) >>> nw.from_native(s_native, series_only=True).mode().sort().to_native() 0 1 1 2 dtype: int64 )rerBmoderLs r:r Series.mode0s$"##D$:$:$?$?$ABBr=cTURURR55$)aReturns a boolean Series indicating which values are finite. Warning: Different backend handle null values differently. `is_finite` will return False for NaN and Null's in the Dask and pandas non-nullable backend, while for Polars, PyArrow and pandas nullable backends null values are kept as such. Returns: Expression of `Boolean` data type. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([[float("nan"), float("inf"), 2.0, None]]) >>> nw.from_native( ... s_native, series_only=True ... ).is_finite().to_native() # doctest: +ELLIPSIS [ [ false, false, true, null ] ] )rerB is_finiterLs r:rSeries.is_finiteCs$:##D$:$:$D$D$FGGr=cRURURRUS95$)a"Return the cumulative count of the non-null values in the series. Arguments: reverse: reverse the operation Returns: A new Series with the cumulative count of non-null values. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> s_native = pl.Series(["x", "k", None, "d"]) >>> nw.from_native(s_native, series_only=True).cum_count( ... reverse=True ... ).to_native() # doctest:+NORMALIZE_WHITESPACE shape: (4,) Series: '' [u32] [ 3 2 1 1 ] r)rerB cum_countrs r:rSeries.cum_countbs)4##D$:$:$D$DW$D$UVVr=cRURURRUS95$)aReturn the cumulative min of the non-null values in the series. Arguments: reverse: reverse the operation Returns: A new Series with the cumulative min of non-null values. Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> s_native = pd.Series([3, 1, None, 2]) >>> nw.from_native(s_native, series_only=True).cum_min().to_native() 0 3.0 1 1.0 2 NaN 3 1.0 dtype: float64 r)rerBcum_minrs r:rSeries.cum_min~s)*##D$:$:$B$B7$B$STTr=cRURURRUS95$)a'Return the cumulative max of the non-null values in the series. Arguments: reverse: reverse the operation Returns: A new Series with the cumulative max of non-null values. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([[1, 3, None, 2]]) >>> nw.from_native( ... s_native, series_only=True ... ).cum_max().to_native() # doctest:+ELLIPSIS [ [ 1, 3, null, 3 ] ] r)rerBcum_maxrs r:rSeries.cum_maxs)8##D$:$:$B$B7$B$STTr=cRURURRUS95$)aReturn the cumulative product of the non-null values in the series. Arguments: reverse: reverse the operation Returns: A new Series with the cumulative product of non-null values. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> s_native = pl.Series([1, 3, None, 2]) >>> nw.from_native( ... s_native, series_only=True ... ).cum_prod().to_native() # doctest:+NORMALIZE_WHITESPACE shape: (4,) Series: '' [i64] [ 1 3 null 6 ] r)rerBcum_prodrs r:rSeries.cum_prods)4##D$:$:$C$CG$C$TUUr=)rcenterc[XS9up[U5S:XaU$URURR XUS95$)a0Apply a rolling sum (moving sum) over the values. A window of length `window_size` will traverse the values. 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. Arguments: window_size: The length of the window in number of elements. It must be a strictly positive integer. 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`. If provided, it must be a strictly positive integer, and less than or equal to `window_size` center: Set the labels at the center of the window. Returns: A new series. Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> s_native = pd.Series([1.0, 2.0, 3.0, 4.0]) >>> nw.from_native(s_native, series_only=True).rolling_sum( ... window_size=2 ... ).to_native() 0 NaN 1 3.0 2 5.0 3 7.0 dtype: float64  window_sizerrrrr)rrrerB rolling_sum)r9rrrmin_samples_ints r:rSeries.rolling_sumsYR(C#( $  t9>K##  " " . .'V /   r=c[XS9up[U5S:XaU$URURR XUS95$)aApply a rolling mean (moving mean) over the values. A window of length `window_size` will traverse the values. 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. Arguments: window_size: The length of the window in number of elements. It must be a strictly positive integer. 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`. If provided, it must be a strictly positive integer, and less than or equal to `window_size` center: Set the labels at the center of the window. Returns: A new series. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([[1.0, 2.0, 3.0, 4.0]]) >>> nw.from_native(s_native, series_only=True).rolling_mean( ... window_size=2 ... ).to_native() # doctest:+ELLIPSIS [ [ null, 1.5, 2.5, 3.5 ] ] rrr)rrrerB rolling_mean)r9rrrs r:rSeries.rolling_mean sXZ$?#$   t9>K##  " " / /' 0   r=)rrrc [XS9up[U5S:XaU$URURR XX4S95$)aApply a rolling variance (moving variance) over the values. A window of length `window_size` will traverse the values. 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. Arguments: window_size: The length of the window in number of elements. It must be a strictly positive integer. 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`. If provided, it must be a strictly positive integer, and less than or 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. Returns: A new series. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> s_native = pl.Series([1.0, 3.0, 1.0, 4.0]) >>> nw.from_native(s_native, series_only=True).rolling_var( ... window_size=2, min_samples=1 ... ).to_native() # doctest:+NORMALIZE_WHITESPACE shape: (4,) Series: '' [f64] [ null 2.0 2.0 4.5 ] rrrrrr)rrrerB rolling_varr9rrrrs r:rSeries.rolling_var? sX\$?#$   t9>K##  " " . .' /   r=c [XS9up[U5S:XaU$URURR XX4S95$)aApply a rolling standard deviation (moving standard deviation) over the values. A window of length `window_size` will traverse the values. The resulting values will be aggregated to their standard deviation. The window at a given row will include the row itself and the `window_size - 1` elements before it. Arguments: window_size: The length of the window in number of elements. It must be a strictly positive integer. 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`. If provided, it must be a strictly positive integer, and less than or 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. Returns: A new series. Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> s_native = pd.Series([1.0, 3.0, 1.0, 4.0]) >>> nw.from_native(s_native, series_only=True).rolling_std( ... window_size=2, min_samples=1 ... ).to_native() 0 NaN 1 1.414214 2 1.414214 3 2.121320 dtype: float64 rrr)rrrerB rolling_stdrs r:rSeries.rolling_stdz sXV$?#$   t9>K##  " " . .' /   r=c#T# URR5ShvN gN7frU)rB__iter__rLs r:rSeries.__iter__ s))22444s (&(c8URRU5$rU)rB __contains__rs r:rSeries.__contains__ s%%22599r=c1SknX;aSUS3n[U5eURURRXS95$)aAssign ranks to data, dealing with ties appropriately. Notes: The resulting dtype may differ between backends. Arguments: method: 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. descending: Rank in descending order. Returns: A new series with rank data as values. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([[3, 6, 1, 1, 6]]) >>> nw.from_native(s_native, series_only=True).rank( ... method="dense" ... ).to_native() # doctest:+ELLIPSIS [ [ 2, 3, 1, 1, 3 ] ] >rrdenseaverageordinalzTRanking method must be one of {'average', 'min', 'max', 'dense', 'ordinal'}. Found '')methodr")r3rerBrank)r9rr"supported_rank_methodsrGs r:r Series.rank s^^"O  / $ S/ !##  " " ' 'v ' M  r=) bin_countinclude_breakpointcUbUb Sn[U5eUcUcSnUb6[S[U55HnXS- X:dMSn[U5e URURR UUUS9UR S9$)u.Bin values into buckets and count their occurrences. !!! warning This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. Arguments: bins: A monotonically increasing sequence of values. bin_count: If no bins provided, this will be used to determine the distance of the bins. include_breakpoint: Include a column that shows the intervals as categories. Returns: A new DataFrame containing the counts of values that occur within each passed bin. Examples: >>> import pandas as pd >>> import narwhals as nw >>> s_native = pd.Series([1, 3, 8, 8, 2, 1, 3], name="a") >>> nw.from_native(s_native, series_only=True).hist(bin_count=4) ┌────────────────────┐ | Narwhals DataFrame | |--------------------| | breakpoint count| |0 2.75 3| |1 4.50 2| |2 6.25 0| |3 8.00 2| └────────────────────┘ z-can only provide one of `bin_count` or `bins` rz bins must increase monotonically)binsr r r)rrangerr;rBhistr@)r9rr r rGr^s r:r Series.hist sH   5ACs# # rArDrGrKrOrRrUrXr[r^rbrerhrkrnrqrtrxr{r~rrrrrrrrrrrrrrrrrrrcrrrrrrtrrrrrrrrrrrrrrrrrrr __static_attributes__rVr=r:r5r56s0 & &6 &  &66<H?? ??5An=H6-,/ b// 9/,M++$,, ++&!!"&""G G  G  G  G G G G  G RH6 60,- /&-(. ,&, , , 0 0, "#5("#5&GKFJ! C! D!   ! F :G.I2B2*/U,05 @ CDED/ "&!& / /  /  /  /  / b'MR-%d%)1 48 1 .1 "1 1 1  1 f*/5 <F<E4*.,0 8 &8 *8  8  8 |"( , ,  ,  ,  , \1 @ 2&20                        I .!41(H(3*P4O*/4G6 ) )  )  )  )  ) V  .H  >( T8*D,D6 LF#&%& & 37& & P <10C&H>,1W8*/U.*/U<+0V@#' 4 4  4  4  4 t#' 8 8  8  8  8 |#' 9 9  9  9  9  9 ~#' 6 6  6  6  6  6 p5:9 9 9 z*.7 !%#' 7 &7  7 ! 7  7 r++--(())++r=r5)B __future__rtypingrrrrrr r r r narwhals.dependenciesr narwhals.dtypesrnarwhals.exceptionsrnarwhals.series_catrnarwhals.series_dtrnarwhals.series_listrnarwhals.series_strrnarwhals.series_structrnarwhals.translaternarwhals.typingrrrnarwhals.utilsrrr r!r"r#typesr$pandaspdpolarspltyping_extensionsr%narwhals._arrow.typingr&narwhals._compliantr'r8r)r*r+r,r-r.r/r0r1r2r3r5rVr=r:rIs" 1+,26458(',/6(.,(2 &13,5%.0.*:/(-H(+W[ !H(+r=