Ë WËh‚ãóÆ—UddlmZddlZddlZddlmZmZmZddl m Z m Z m Z ddl mZmZmZddlmZmZmZddlmZddlmZmZdd lmZdd lmZdd lmZdd l m!Z!dd l"m#Z#ddl$m%Z%ddl&m'Z'e rcddl m(Z(m)Z)ddl*m+Z+m,Z,m-Z-m.Z.ddl/m0Z0m1Z1ddlm2Z2ddl3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;mZ>e,d«Z?e)d«Z@e e1e e fge0e e ffZAdeBd<Gd„d«ZCdgZDy)é)Ú annotationsN)ÚIterableÚMappingÚSequence)Ú TYPE_CHECKINGÚAnyÚCallable)Ú ExprMetadataÚapply_n_ary_operationÚcombine_metadata)Ú_validate_rolling_argumentsÚ ensure_typeÚflatten)Ú_validate_dtype)Ú ComputeErrorÚInvalidOperationError©ÚExprCatNamespace©ÚExprDateTimeNamespace©ÚExprListNamespace©ÚExprNameNamespace©ÚExprStringNamespace©ÚExprStructNamespace)Ú to_native)ÚNoReturnÚTypeVar)Ú ConcatenateÚ ParamSpecÚSelfÚ TypeAlias)Ú CompliantExprÚCompliantNamespace)ÚDType) ÚClosedIntervalÚFillNullStrategyÚ IntoDTypeÚIntoExprÚModeKeepStrategyÚNonNestedLiteralÚNumericLiteralÚ RankMethodÚRollingInterpolationMethodÚTemporalLiteralÚ_1DArrayÚPSÚRr%Ú _ToCompliantcó.—eZdZdyd„Zdzd„Zdzd„Z dzd„Zdzd„Zdzd„Zdzd„Z dzd„Z d{d „Z d|d „Z d}d „Z d~d „Zdd „Z d€d„Zdd„Zddœ d‚d„Zdƒd„Zdƒd„Zd„d„Zd„d„Zd„d„Zd„d„Zd„d„Zd„d„Zd„d„Zd„d„Zd„d„Zd„d„Zd„d„Zd„d „Z d„d!„Z!d„d"„Z"d„d#„Z#d„d$„Z$d„d%„Z%d„d&„Z&d„d'„Z'd„d(„Z(d„d)„Z)d„d*„Z*d~d+„Z+d~d,„Z,d~d-„Z-d.d.d.d.dd/d0d1œ d…d2„Z.d~d3„Z/d~d4„Z0d/d5œd†d6„Z1d/d5œd†d7„Z2 d‡d0d8œ dˆd9„Z3d~d:„Z4d~d;„Z5d‰d<„Z6d~d=„Z7d~d>„Z8d~d?„Z9d~d@„Z:d~dA„Z;d~dB„Zd‹dF„Z? d‡d.dGœ dŒdH„Z@ d dŽdI„ZAd„dJ„ZBddK„ZCd~dL„ZDd~dM„ZE d d‘dN„ZFd’dO„ZGd~dP„ZHd.dQœ d“dR„ZId~dS„ZJd~dT„ZKd~dU„ZLd~dV„ZMd~dW„ZN d”dX„ZOd•d–dY„ZPd~dZ„ZQ d— d˜d[„ZRd\d]œd™d^„ZSd~d_„ZTd0dCœdŠd`„ZUd0dCœdŠda„ZVd0dCœdŠdb„ZWd0dCœdŠdc„ZXd.d0ddœ dšde„ZYd.d0ddœ dšdf„ZZd.d0d/dgœ d›dh„Z[d.d0d/dgœ d›di„Z\dœd0djœddk„Z]e^j¾fdždl„Z`d~dm„Zad~dn„Zbdodpd0dqœ dŸdr„Zcedd ds„«Zeedd¡dt„«Zfedd¢du„«Zgedd£dv„«Zhedd¤dw„«Ziedd¥dx„«Zjy.)¦ÚExprcó2‡‡—dˆˆfd„ }|‰_|‰_y)Ncó:•—‰|«}‰j|_|S©N©Ú _metadata)ÚplxÚresultÚselfÚto_compliant_exprs €€úG/var/www/html/jupyter_env/lib/python3.12/site-packages/narwhals/expr.pyÚfunczExpr.__init__..func7sø€Ù& sÓ+ˆFØ#Ÿ~™~ˆFÔ ØˆMó)r>zCompliantNamespace[Any, Any]ÚreturnzCompliantExpr[Any, Any])Ú_to_compliant_exprr=)r@rAÚmetadatarCs`` rBÚ__init__z Expr.__init__5sù€ö ð 15ˆÔØ!ˆrDcóV—|j||jj««Sr;)Ú __class__r=Úwith_elementwise_op©r@rAs rBÚ_with_elementwisezExpr._with_elementwise?s!€Ø~‰~Ð/°·±×1SÑ1SÓ1UÓVÐVrDcóV—|j||jj««Sr;)rJr=Úwith_aggregationrLs rBÚ_with_aggregationzExpr._with_aggregationBs!€Ø~‰~Ð/°·±×1PÑ1PÓ1RÓSÐSrDcóV—|j||jj««Sr;)rJr=Úwith_orderable_aggregationrLs rBÚ_with_orderable_aggregationz Expr._with_orderable_aggregationEs'€ð~‰~Ø ˜tŸ~™~×HÑHÓJó ð rDcóV—|j||jj««Sr;)rJr=Úwith_orderable_windowrLs rBÚ_with_orderable_windowzExpr._with_orderable_windowLs!€Ø~‰~Ð/°·±×1UÑ1UÓ1WÓXÐXrDcóV—|j||jj««Sr;)rJr=Ú with_windowrLs rBÚ _with_windowzExpr._with_windowOs!€Ø~‰~Ð/°·±×1KÑ1KÓ1MÓNÐNrDcóV—|j||jj««Sr;)rJr=Úwith_filtrationrLs rBÚ_with_filtrationzExpr._with_filtrationRs!€Ø~‰~Ð/°·±×1OÑ1OÓ1QÓRÐRrDcóV—|j||jj««Sr;)rJr=Úwith_orderable_filtrationrLs rBÚ_with_orderable_filtrationzExpr._with_orderable_filtrationUs%€Ø~‰~Ø ˜tŸ~™~×GÑGÓIó ð rDc óT‡‡‡—‰jˆˆˆfd„t‰g‰¢­ddddœŽ«S)Ncó&•—t|‰‰g‰¢­ddiŽS)NÚ str_as_litF©r )r>ÚargsÚn_ary_functionr@s €€€rBúz!Expr._with_nary..`s$ø€Ô-Ø^ TðØ,0òØ=Bñ€rDF©rbÚallow_multi_outputÚto_single_output)rJr )r@rerds```rBÚ _with_naryzExpr._with_naryZs@ú€ð ~‰~õ ô Øð àñ ð!Ø#(Ø!&ò  ó  ð rDcó"—d|j›dS)NzNarwhals Expr metadata: ú r<©r@s rBÚ__repr__z Expr.__repr__ls€Ø*¨4¯>©>Ð*:¸"Ð=Ð=rDcó6—dt|«›d}t|«‚)Nzthe truth value of a– is ambiguous You probably got here by using a Python standard library function instead of the native expressions API. Here are some things you might want to try: - instead of `nw.col('a') and nw.col('b')`, use `nw.col('a') & nw.col('b')` - instead of `nw.col('a') in [y, z]`, use `nw.col('a').is_in([y, z])` - instead of `max(nw.col('a'), nw.col('b'))`, use `nw.max_horizontal(nw.col('a'), nw.col('b'))` )ÚtypeÚ TypeError)r@Úmsgs rBÚ__bool__z Expr.__bool__os*€à!¤$ t£* ð.pð pð ô˜‹nÐrDcó,‡—‰jˆfd„«S)Ncó^•—‰j|«j«j«Sr;)rFÚabsÚsum©r>r@s €rBrfz$Expr._taxicab_norm..€s$ø€˜×/Ñ/°Ó4×8Ñ8Ó:×>Ñ>Ó@€rD©rPrms`rBÚ _taxicab_normzExpr._taxicab_norm|sø€ð×%Ñ%Û @ó ð rDcóF‡‡—‰jˆˆfd„‰j«S)u”Rename the expression. Arguments: name: The new name. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [1, 2], "b": [4, 5]}) >>> df = nw.from_native(df_native) >>> df.select((nw.col("b") + 10).alias("c")) ┌──────────────────┠|Narwhals DataFrame| |------------------| | c | | 0 14 | | 1 15 | └──────────────────┘ cóD•—‰j|«j‰«Sr;)rFÚalias)r>Únamer@s €€rBrfzExpr.alias..šsø€˜×/Ñ/°Ó4×:Ñ:¸4Ó@€rD)rJr=)r@r~s``rBr}z Expr.alias„sù€ð*~‰~Ü @À$Ç.Á.ó ð rDcó—||g|¢­i|¤ŽS)u^Pipe function call. Arguments: function: Function to apply. args: Positional arguments to pass to function. kwargs: Keyword arguments to pass to function. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [1, 2, 3, 4]}) >>> df = nw.from_native(df_native) >>> df.with_columns(a_piped=nw.col("a").pipe(lambda x: x + 1)) ┌──────────────────┠|Narwhals DataFrame| |------------------| | a a_piped | | 0 1 2 | | 1 2 3 | | 2 3 4 | | 3 4 5 | └──────────────────┘ ©)r@ÚfunctionrdÚkwargss rBÚpipez Expr.pipes€ñ:˜Ð.˜tÒ. vÑ.Ð.rDcóF‡‡—t‰«‰jˆˆfd„«S)u Redefine an object's data type. Arguments: dtype: Data type that the object will be cast into. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"foo": [1, 2, 3], "bar": [6.0, 7.0, 8.0]}) >>> df = nw.from_native(df_native) >>> df.select(nw.col("foo").cast(nw.Float32), nw.col("bar").cast(nw.UInt8)) ┌──────────────────┠|Narwhals DataFrame| |------------------| | foo bar | | 0 1.0 6 | | 1 2.0 7 | | 2 3.0 8 | └──────────────────┘ cóD•—‰j|«j‰«Sr;)rFÚcast)r>Údtyper@s €€rBrfzExpr.cast..Ósø€˜×/Ñ/°Ó4×9Ñ9¸%Ó@€rD)rrM)r@r‡s``rBr†z Expr.cast¼s#ù€ô* ˜ÔØ×%Ñ%Ü @ó ð rDT©rbcób‡‡‡‡—‰jˆˆˆˆfd„tj‰‰««S)Ncó$•—t|‰‰‰‰¬«S)Nrˆrc)r>rÚotherr@rbs €€€€rBrfz#Expr._with_binary..ßsø€Ô-ØX˜t U°zô€rD)rJr Úfrom_binary_op)r@rr‹rbs````rBÚ _with_binaryzExpr._with_binary×s-û€ð~‰~ö ô × 'Ñ '¨¨eÓ 4ó  ð rDcóB—|jtj|«Sr;)rÚopÚeq©r@r‹s rBÚ__eq__z Expr.__eq__åó€Ø× Ñ ¤§¡¨Ó.Ð.rDcóB—|jtj|«Sr;)rrÚner‘s rBÚ__ne__z Expr.__ne__èr“rDcóB—|jtj|«Sr;)rrÚand_r‘s rBÚ__and__z Expr.__and__ës€Ø× Ñ ¤§¡¨%Ó0Ð0rDcó*—||zjd«S©NÚliteral©r}r‘s rBÚ__rand__z Expr.__rand__îó€Øu‘ ×#Ñ# IÓ.Ð.rDcóB—|jtj|«Sr;)rrÚor_r‘s rBÚ__or__z Expr.__or__ñó€Ø× Ñ ¤§¡¨Ó/Ð/rDcó*—||zjd«Sr›rr‘s rBÚ__ror__z Expr.__ror__ôrŸrDcóB—|jtj|«Sr;)rrÚaddr‘s rBÚ__add__z Expr.__add__÷r£rDcó*—||zjd«Sr›rr‘s rBÚ__radd__z Expr.__radd__úrŸrDcóB—|jtj|«Sr;)rrÚsubr‘s rBÚ__sub__z Expr.__sub__ýr£rDcó(—|jd„|«S)Ncó$—|j|«Sr;)Ú__rsub__©ÚxÚys rBrfzExpr.__rsub__..ó€¨a¯j©j¸«m€rD©rr‘s rBr°z Expr.__rsub__ó€Ø× Ñ Ñ!;¸UÓCÐCrDcóB—|jtj|«Sr;)rrÚtruedivr‘s rBÚ __truediv__zExpr.__truediv__s€Ø× Ñ ¤§¡¨UÓ3Ð3rDcó(—|jd„|«S)Ncó$—|j|«Sr;)Ú __rtruediv__r±s rBrfz#Expr.__rtruediv__..s€¨a¯n©n¸QÓ.?€rDrµr‘s rBr¼zExpr.__rtruediv__s€Ø× Ñ Ñ!?ÀÓGÐGrDcóB—|jtj|«Sr;)rrÚmulr‘s rBÚ__mul__z Expr.__mul__ r£rDcó*—||zjd«Sr›rr‘s rBÚ__rmul__z Expr.__rmul__ rŸrDcóB—|jtj|«Sr;)rrÚler‘s rBÚ__le__z Expr.__le__r“rDcóB—|jtj|«Sr;)rrÚltr‘s rBÚ__lt__z Expr.__lt__r“rDcóB—|jtj|«Sr;)rrÚgtr‘s rBÚ__gt__z Expr.__gt__r“rDcóB—|jtj|«Sr;)rrÚger‘s rBÚ__ge__z Expr.__ge__r“rDcóB—|jtj|«Sr;)rrÚpowr‘s rBÚ__pow__z Expr.__pow__r£rDcó(—|jd„|«S)Ncó$—|j|«Sr;)Ú__rpow__r±s rBrfzExpr.__rpow__..r´rDrµr‘s rBrÓz Expr.__rpow__r¶rDcóB—|jtj|«Sr;)rrÚfloordivr‘s rBÚ __floordiv__zExpr.__floordiv__!s€Ø× Ñ ¤§¡¨eÓ4Ð4rDcó(—|jd„|«S)Ncó$—|j|«Sr;)Ú __rfloordiv__r±s rBrfz$Expr.__rfloordiv__..%s€¨a¯o©o¸aÓ.@€rDrµr‘s rBrÙzExpr.__rfloordiv__$s€Ø× Ñ Ñ!@À%ÓHÐHrDcóB—|jtj|«Sr;)rrÚmodr‘s rBÚ__mod__z Expr.__mod__'r£rDcó(—|jd„|«S)Ncó$—|j|«Sr;)Ú__rmod__r±s rBrfzExpr.__rmod__..+r´rDrµr‘s rBrßz Expr.__rmod__*r¶rDcó,‡—‰jˆfd„«S)NcóB•—‰j|«j«Sr;)rFÚ __invert__rxs €rBrfz!Expr.__invert__..0óø€˜×/Ñ/°Ó4×?Ñ?ÓA€rD©rMrms`rBrâzExpr.__invert__.sø€Ø×%Ñ%Û Aó ð rDcó,‡—‰jˆfd„«S)u¬Return whether any of the values in the column are `True`. If there are no non-null elements, the result is `False`. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [True, False], "b": [True, True]}) >>> df = nw.from_native(df_native) >>> df.select(nw.col("a", "b").any()) ┌──────────────────┠|Narwhals DataFrame| |------------------| | a b | | 0 True True | └──────────────────┘ cóB•—‰j|«j«Sr;)rFÚanyrxs €rBrfzExpr.any..Eóø€°$×2IÑ2IÈ#Ó2N×2RÑ2RÓ2T€rDryrms`rBrçzExpr.any3óø€ð$×%Ñ%Ó&TÓUÐUrDcó,‡—‰jˆfd„«S)u¤Return whether all values in the column are `True`. If there are no non-null elements, the result is `True`. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [True, False], "b": [True, True]}) >>> df = nw.from_native(df_native) >>> df.select(nw.col("a", "b").all()) ┌──────────────────┠|Narwhals DataFrame| |------------------| | a b | | 0 False True | └──────────────────┘ cóB•—‰j|«j«Sr;)rFÚallrxs €rBrfzExpr.all..YrèrDryrms`rBrìzExpr.allGrérDNéF©ÚcomÚspanÚ half_lifeÚalphaÚadjustÚ min_samplesÚ ignore_nullsc óH‡‡‡‡‡‡‡‡—‰jˆˆˆˆˆˆˆˆfd„«S)u Compute 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`. Examples: >>> import pandas as pd >>> import polars as pl >>> import narwhals as nw >>> from narwhals.typing import IntoFrameT >>> >>> data = {"a": [1, 2, 3]} >>> df_pd = pd.DataFrame(data) >>> df_pl = pl.DataFrame(data) We define a library agnostic function: >>> def agnostic_ewm_mean(df_native: IntoFrameT) -> IntoFrameT: ... df = nw.from_native(df_native) ... return df.select( ... nw.col("a").ewm_mean(com=1, ignore_nulls=False) ... ).to_native() We can then pass either pandas or Polars to `agnostic_ewm_mean`: >>> agnostic_ewm_mean(df_pd) a 0 1.000000 1 1.666667 2 2.428571 >>> agnostic_ewm_mean(df_pl) # doctest: +NORMALIZE_WHITESPACE shape: (3, 1) ┌──────────┠│ a │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•â•â•â•â•â•¡ │ 1.0 │ │ 1.666667 │ │ 2.428571 │ └──────────┘ c óR•—‰j|«j‰‰‰‰‰‰‰¬«S)Nrî)rFÚewm_mean) r>róròrïrñrõrôr@rðs €€€€€€€€rBrfzExpr.ewm_mean..¯s7ø€˜×/Ñ/°Ó4×=Ñ=ØØØ#ØØØ'Ø)ð>ó€rD©rV)r@rïrðrñròrórôrõs````````rBrøz Expr.ewm_mean[s#ÿ€ðf×*Ñ*÷ ò ó  ð rDcó,‡—‰jˆfd„«S)u9Get mean value. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [-1, 0, 1], "b": [2, 4, 6]}) >>> df = nw.from_native(df_native) >>> df.select(nw.col("a", "b").mean()) ┌──────────────────┠|Narwhals DataFrame| |------------------| | a b | | 0 0.0 4.0 | └──────────────────┘ cóB•—‰j|«j«Sr;)rFÚmeanrxs €rBrfzExpr.mean..Êóø€°$×2IÑ2IÈ#Ó2N×2SÑ2SÓ2U€rDryrms`rBrüz Expr.meanºóø€ð ×%Ñ%Ó&UÓVÐVrDcó,‡—‰jˆfd„«S)uÒGet median value. Notes: Results might slightly differ across backends due to differences in the underlying algorithms used to compute the median. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [1, 8, 3], "b": [4, 5, 2]}) >>> df = nw.from_native(df_native) >>> df.select(nw.col("a", "b").median()) ┌──────────────────┠|Narwhals DataFrame| |------------------| | a b | | 0 3.0 4.0 | └──────────────────┘ cóB•—‰j|«j«Sr;)rFÚmedianrxs €rBrfzExpr.median..ßóø€°$×2IÑ2IÈ#Ó2N×2UÑ2UÓ2W€rDryrms`rBrz Expr.medianÌsø€ð&×%Ñ%Ó&WÓXÐXrD©Úddofcó0‡‡—‰jˆˆfd„«S)u/Get standard deviation. Arguments: 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: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [20, 25, 60], "b": [1.5, 1, -1.4]}) >>> df = nw.from_native(df_native) >>> df.select(nw.col("a", "b").std(ddof=0)) ┌─────────────────────┠| Narwhals DataFrame | |---------------------| | a b| |0 17.79513 1.265789| └─────────────────────┘ cóF•—‰j|«j‰¬«S©Nr)rFÚstd©r>rr@s €€rBrfzExpr.std..öó ø€˜×/Ñ/°Ó4×8Ñ8¸dÐ8ÓC€rDry©r@rs``rBrzExpr.stdáóù€ð(×%Ñ%Ü Có ð rDcó0‡‡—‰jˆˆfd„«S)u>Get variance. Arguments: 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: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [20, 25, 60], "b": [1.5, 1, -1.4]}) >>> df = nw.from_native(df_native) >>> df.select(nw.col("a", "b").var(ddof=0)) ┌───────────────────────┠| Narwhals DataFrame | |-----------------------| | a b| |0 316.666667 1.602222| └───────────────────────┘ cóF•—‰j|«j‰¬«Sr)rFÚvarr s €€rBrfzExpr.var..r rDryr s``rBrzExpr.varùr rD)Úreturns_scalarcód‡‡‡‡—dˆˆˆˆfd„ }‰r‰j|«S‰j|«S)u»Apply a custom python function to a whole Series or sequence of Series. The output of this custom function is presumed to be either a Series, or a NumPy array (in which case it will be automatically converted into a Series). Arguments: function: Function to apply to Series. return_dtype: Dtype of the output Series. If not set, the dtype will be inferred based on the first non-null value that is returned by the function. returns_scalar: If the function returns a scalar, by default it will be wrapped in a list in the output, since the assumption is that the function always returns something Series-like. If you want to keep the result as a scalar, set this argument to True. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]}) >>> df = nw.from_native(df_native) >>> df.with_columns( ... nw.col("a", "b") ... .map_batches(lambda s: s.to_numpy() + 1, return_dtype=nw.Float64) ... .name.suffix("_mapped") ... ) ┌───────────────────────────┠| Narwhals DataFrame | |---------------------------| | a b a_mapped b_mapped| |0 1 4 2.0 5.0| |1 2 5 3.0 6.0| |2 3 6 4.0 7.0| └───────────────────────────┘ cóJ•—‰j|«j‰‰‰¬«S)N)rÚ return_dtyper)rFÚ map_batches)r>rrrr@s €€€€rBÚcompliant_exprz(Expr.map_batches..compliant_expr<s/ø€Ø×*Ñ*¨3Ó/×;Ñ;Ø!Ø)Ø-ð<óð rD©r>rrEr)rSr_)r@rrrrs```` rBrzExpr.map_batchess5û€÷V ð ñ Ø×3Ñ3°NÓCÐ Cà×.Ñ.¨~Ó>Ð>rDcó,‡—‰jˆfd„«S)ubCalculate the sample skewness of a column. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [1, 2, 3, 4, 5], "b": [1, 1, 2, 10, 100]}) >>> df = nw.from_native(df_native) >>> df.select(nw.col("a", "b").skew()) ┌──────────────────┠|Narwhals DataFrame| |------------------| | a b | | 0 0.0 1.472427 | └──────────────────┘ cóB•—‰j|«j«Sr;)rFÚskewrxs €rBrfzExpr.skew..XrýrDryrms`rBrz Expr.skewHrþrDcó,‡—‰jˆfd„«S)uLCompute the kurtosis (Fisher's definition) without bias correction. Kurtosis is the fourth central moment divided by the square of the variance. The Fisher's definition is used where 3.0 is subtracted from the result to give 0.0 for a normal distribution. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [1, 2, 3, 4, 5], "b": [1, 1, 2, 10, 100]}) >>> df = nw.from_native(df_native) >>> df.select(nw.col("a", "b").kurtosis()) ┌──────────────────┠|Narwhals DataFrame| |------------------| | a b | | 0 -1.3 0.210657 | └──────────────────┘ cóB•—‰j|«j«Sr;)rFÚkurtosisrxs €rBrfzExpr.kurtosis..móø€°$×2IÑ2IÈ#Ó2N×2WÑ2WÓ2Y€rDryrms`rBrz Expr.kurtosisZsø€ð&×%Ñ%Ó&YÓZÐZrDcó,‡—‰jˆfd„«S)uReturn the sum value. If there are no non-null elements, the result is zero. Examples: >>> import duckdb >>> import narwhals as nw >>> df_native = duckdb.sql("SELECT * FROM VALUES (5, 50), (10, 100) df(a, b)") >>> df = nw.from_native(df_native) >>> df.select(nw.col("a", "b").sum()) ┌───────────────────┠|Narwhals LazyFrame | |-------------------| |┌────────┬────────â”| |│ a │ b │| |│ int128 │ int128 │| |├────────┼────────┤| |│ 15 │ 150 │| |└────────┴────────┘| └───────────────────┘ cóB•—‰j|«j«Sr;)rFrwrxs €rBrfzExpr.sum..…rèrDryrms`rBrwzExpr.sumosø€ð,×%Ñ%Ó&TÓUÐUrDcó,‡—‰jˆfd„«S)uJReturns the minimum value(s) from a column(s). Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [1, 2], "b": [4, 3]}) >>> df = nw.from_native(df_native) >>> df.select(nw.min("a", "b")) ┌──────────────────┠|Narwhals DataFrame| |------------------| | a b | | 0 1 3 | └──────────────────┘ cóB•—‰j|«j«Sr;)rFÚminrxs €rBrfzExpr.min..—rèrDryrms`rBr"zExpr.min‡óø€ð ×%Ñ%Ó&TÓUÐUrDcó,‡—‰jˆfd„«S)uOReturns the maximum value(s) from a column(s). Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [10, 20], "b": [50, 100]}) >>> df = nw.from_native(df_native) >>> df.select(nw.max("a", "b")) ┌──────────────────┠|Narwhals DataFrame| |------------------| | a b | | 0 20 100 | └──────────────────┘ cóB•—‰j|«j«Sr;)rFÚmaxrxs €rBrfzExpr.max..©rèrDryrms`rBr&zExpr.max™r#rDcó,‡—‰jˆfd„«S)u[Returns the number of non-null elements in the column. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [1, 2, 3], "b": [None, 4, 4]}) >>> df = nw.from_native(df_native) >>> df.select(nw.all().count()) ┌──────────────────┠|Narwhals DataFrame| |------------------| | a b | | 0 3 2 | └──────────────────┘ cóB•—‰j|«j«Sr;)rFÚcountrxs €rBrfzExpr.count..»sø€°$×2IÑ2IÈ#Ó2N×2TÑ2TÓ2V€rDryrms`rBr)z Expr.count«sø€ð ×%Ñ%Ó&VÓWÐWrDcó,‡—‰jˆfd„«S)uXReturns count of unique values. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [1, 2, 3, 4, 5], "b": [1, 1, 3, 3, 5]}) >>> df = nw.from_native(df_native) >>> df.select(nw.col("a", "b").n_unique()) ┌──────────────────┠|Narwhals DataFrame| |------------------| | a b | | 0 5 3 | └──────────────────┘ cóB•—‰j|«j«Sr;)rFÚn_uniquerxs €rBrfzExpr.n_unique..ÍrrDryrms`rBr,z Expr.n_unique½sø€ð ×%Ñ%Ó&YÓZÐZrDcó,‡—‰jˆfd„«S)ueReturn unique values of this expression. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [1, 1, 3, 5, 5], "b": [2, 4, 4, 6, 6]}) >>> df = nw.from_native(df_native) >>> df.select(nw.col("a", "b").unique().sum()) ┌──────────────────┠|Narwhals DataFrame| |------------------| | a b | | 0 9 12 | └──────────────────┘ cóB•—‰j|«j«Sr;)rFÚuniquerxs €rBrfzExpr.unique..ßsø€°×1HÑ1HÈÓ1M×1TÑ1TÓ1V€rD©r\rms`rBr/z Expr.uniqueÏsø€ð ×$Ñ$Ó%VÓWÐWrDcó,‡—‰jˆfd„«S)u¦Return absolute value of each element. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [1, -2], "b": [-3, 4]}) >>> df = nw.from_native(df_native) >>> df.with_columns(nw.col("a", "b").abs().name.suffix("_abs")) ┌─────────────────────┠| Narwhals DataFrame | |---------------------| | a b a_abs b_abs| |0 1 -3 1 3| |1 -2 4 2 4| └─────────────────────┘ cóB•—‰j|«j«Sr;)rFrvrxs €rBrfzExpr.abs..òrèrDrärms`rBrvzExpr.absásø€ð"×%Ñ%Ó&TÓUÐUrD©Úreversecó0‡‡—‰jˆˆfd„«S)uÙReturn cumulative sum. Info: For lazy backends, this operation must be followed by `Expr.over` with `order_by` specified, see [order-dependence](../concepts/order_dependence.md). Arguments: reverse: reverse the operation Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [1, 1, 3, 5, 5], "b": [2, 4, 4, 6, 6]}) >>> df = nw.from_native(df_native) >>> df.with_columns(a_cum_sum=nw.col("a").cum_sum()) ┌──────────────────┠|Narwhals DataFrame| |------------------| | a b a_cum_sum| |0 1 2 1| |1 1 4 2| |2 3 4 5| |3 5 6 10| |4 5 6 15| └──────────────────┘ cóF•—‰j|«j‰¬«S©Nr3)rFÚcum_sum©r>r4r@s €€rBrfzExpr.cum_sum..ó ø€˜×/Ñ/°Ó4×<Ñ<ÀWÐ<ÓM€rDrù©r@r4s``rBr8z Expr.cum_sumôsù€ð6×*Ñ*Ü Mó ð rDcó,‡—‰jˆfd„«S)uªReturns the difference between each element and the previous one. Info: For lazy backends, this operation must be followed by `Expr.over` with `order_by` specified, see [order-dependence](../concepts/order_dependence.md). 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: nw.col("a").diff().fill_null(0).cast(nw.Int64) Examples: >>> import polars as pl >>> import narwhals as nw >>> df_native = pl.DataFrame({"a": [1, 1, 3, 5, 5]}) >>> df = nw.from_native(df_native) >>> df.with_columns(a_diff=nw.col("a").diff()) ┌──────────────────┠|Narwhals DataFrame| |------------------| | shape: (5, 2) | | ┌─────┬────────┠| | │ a ┆ a_diff │ | | │ --- ┆ --- │ | | │ i64 ┆ i64 │ | | â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•¡ | | │ 1 ┆ null │ | | │ 1 ┆ 0 │ | | │ 3 ┆ 2 │ | | │ 5 ┆ 2 │ | | │ 5 ┆ 0 │ | | └─────┴────────┘ | └──────────────────┘ cóB•—‰j|«j«Sr;)rFÚdiffrxs €rBrfzExpr.diff..;sø€˜×/Ñ/°Ó4×9Ñ9Ó;€rDrùrms`rBr>z Expr.diffsø€ðN×*Ñ*Û ;ó ð rDcóT‡‡—t‰td¬«‰jˆˆfd„«S)uÒShift values by `n` positions. Info: For lazy backends, this operation must be followed by `Expr.over` with `order_by` specified, see [order-dependence](../concepts/order_dependence.md). Arguments: n: Number of positions to shift values by. 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: nw.col("a").shift(1).fill_null(0).cast(nw.Int64) Examples: >>> import polars as pl >>> import narwhals as nw >>> df_native = pl.DataFrame({"a": [1, 1, 3, 5, 5]}) >>> df = nw.from_native(df_native) >>> df.with_columns(a_shift=nw.col("a").shift(n=1)) ┌──────────────────┠|Narwhals DataFrame| |------------------| |shape: (5, 2) | |┌─────┬─────────┠| |│ a ┆ a_shift │ | |│ --- ┆ --- │ | |│ i64 ┆ i64 │ | |â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•¡ | |│ 1 ┆ null │ | |│ 1 ┆ 1 │ | |│ 3 ┆ 1 │ | |│ 5 ┆ 3 │ | |│ 5 ┆ 5 │ | |└─────┴─────────┘ | └──────────────────┘ Ún)Ú param_namecóD•—‰j|«j‰«Sr;)rFÚshift)r>r@r@s €€rBrfzExpr.shift..ksø€˜×/Ñ/°Ó4×:Ñ:¸1Ó=€rD)rÚintrV)r@r@s``rBrCz Expr.shift>s(ù€ôT A”s sÕ+à×*Ñ*Ü =ó ð rD©rcóÚ‡‡‡‡—‰€Ot‰t«s d}t|«‚t‰j ««Št‰j ««Š‰j ˆˆˆˆfd„«S)uòReplace 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_strict(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. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [3, 0, 1, 2]}) >>> df = nw.from_native(df_native) >>> df.with_columns( ... b=nw.col("a").replace_strict( ... [0, 1, 2, 3], ... ["zero", "one", "two", "three"], ... return_dtype=nw.String, ... ) ... ) ┌──────────────────┠|Narwhals DataFrame| |------------------| | a b | | 0 3 three | | 1 0 zero | | 2 1 one | | 3 2 two | └──────────────────┘ zB`new` argument is required if `old` argument is not a Mapping typecóJ•—‰j|«j‰‰‰¬«S)NrE)rFÚreplace_strict)r>ÚnewÚoldrr@s €€€€rBrfz%Expr.replace_strict..¡s*ø€˜×/Ñ/°Ó4×CÑCØS |ðDó€rD)Ú isinstancerrqÚlistÚvaluesÚkeysrM)r@rJrIrrrs```` rBrHzExpr.replace_strictns\û€ðT ˆ;ܘc¤7Ô+ØZÜ “nÐ$äs—z‘z“|Ó$ˆCÜs—x‘x“zÓ"ˆCà×%Ñ%ö ó ð rDcó0‡—|jˆfd„||«S)uCheck if this expression is between the given lower and upper bounds. Arguments: lower_bound: Lower bound value. String literals are interpreted as column names. upper_bound: Upper bound value. String literals are interpreted as column names. closed: Define which sides of the interval are closed (inclusive). Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [1, 2, 3, 4, 5]}) >>> df = nw.from_native(df_native) >>> df.with_columns(b=nw.col("a").is_between(2, 4, "right")) ┌──────────────────┠|Narwhals DataFrame| |------------------| | a b | | 0 1 False | | 1 2 False | | 2 3 True | | 3 4 True | | 4 5 False | └──────────────────┘ có,•—|j||‰¬«S)N)Úclosed)Ú is_between)ÚexprÚlbÚubrQs €rBrfz!Expr.is_between..Æsø€ §¡°°RÀ Ó!G€rD©rj)r@Ú lower_boundÚ upper_boundrQs `rBrRzExpr.is_between§sø€ð<‰Û GØ Ø ó ð rDc󖇇—t‰t«r+t‰ttf«s‰j ˆˆfd„«Sd}t |«‚)uCheck if elements of this expression are present in the other iterable. Arguments: other: iterable Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [1, 2, 9, 10]}) >>> df = nw.from_native(df_native) >>> df.with_columns(b=nw.col("a").is_in([1, 2])) ┌──────────────────┠|Narwhals DataFrame| |------------------| | a b | | 0 1 True | | 1 2 True | | 2 9 False | | 3 10 False | └──────────────────┘ cóZ•—‰j|«jt‰d¬««S)NT)Ú pass_through)rFÚis_inr)r>r‹r@s €€rBrfzExpr.is_in..ãs'ø€˜D×3Ñ3°CÓ8×>Ñ>ܘe°$Ô7ó€rDzyNarwhals `is_in` doesn't accept expressions as an argument, as opposed to Polars. You should provide an iterable instead.)rKrÚstrÚbytesrMÚNotImplementedError)r@r‹rrs`` rBr\z Expr.is_inËsGù€ô, eœXÔ &¬z¸%Ä#ÄuÀÔ/NØ×)Ñ)ôóð ð JˆÜ! #Ó&Ð&rDc󆇇—t|«Št‰g‰¢­ddddœŽj«}‰jˆˆfd„|«S)u¹Filters elements based on a condition, returning a new expression. Arguments: predicates: Conditions to filter by (which get AND-ed together). Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame( ... {"a": [2, 3, 4, 5, 6, 7], "b": [10, 11, 12, 13, 14, 15]} ... ) >>> df = nw.from_native(df_native) >>> df.select( ... nw.col("a").filter(nw.col("a") > 4), ... nw.col("b").filter(nw.col("b") < 13), ... ) ┌──────────────────┠|Narwhals DataFrame| |------------------| | a b | | 3 5 10 | | 4 6 11 | | 5 7 12 | └──────────────────┘ FTrgcó(•—t|d„‰g‰¢­ddiŽS)Ncó,—|dj|ddŽS©Nrrí)Úfilter)Úexprss rBrfz/Expr.filter....s€˜˜u Q™xŸ™°°a°b° Ð:€rDrbFrc)r>Úflat_predicatesr@s €€rBrfzExpr.filter.. s*ø€Ô-ØÙ:Øðð!ò ð !ñ €rD)rr r[rJ)r@Ú predicatesrGrfs` @rBrdz Expr.filterês^ù€ô4" *Ó-ˆÜ#Ø ð à ñ ðØ#Ø"ò  ÷ ‰/Ó ð ð~‰~ô ð ó  ð rDcó,‡—‰jˆfd„«S)u×Returns a boolean Series indicating which values are null. Notes: pandas handles null values differently from Polars and PyArrow. See [null_handling](../concepts/null_handling.md/) for reference. Examples: >>> import duckdb >>> import narwhals as nw >>> df_native = duckdb.sql( ... "SELECT * FROM VALUES (null, CAST('NaN' AS DOUBLE)), (2, 2.) df(a, b)" ... ) >>> df = nw.from_native(df_native) >>> df.with_columns( ... a_is_null=nw.col("a").is_null(), b_is_null=nw.col("b").is_null() ... ) ┌──────────────────────────────────────────┠| Narwhals LazyFrame | |------------------------------------------| |┌───────┬────────┬───────────┬───────────â”| |│ a │ b │ a_is_null │ b_is_null │| |│ int32 │ double │ boolean │ boolean │| |├───────┼────────┼───────────┼───────────┤| |│ NULL │ nan │ true │ false │| |│ 2 │ 2.0 │ false │ false │| |└───────┴────────┴───────────┴───────────┘| └──────────────────────────────────────────┘ cóB•—‰j|«j«Sr;)rFÚis_nullrxs €rBrfzExpr.is_null..4sø€°$×2IÑ2IÈ#Ó2N×2VÑ2VÓ2X€rDrärms`rBrjz Expr.is_nullsø€ð:×%Ñ%Ó&XÓYÐYrDcó,‡—‰jˆfd„«S)uIndicate which values are NaN. Notes: pandas handles null values differently from Polars and PyArrow. See [null_handling](../concepts/null_handling.md/) for reference. Examples: >>> import duckdb >>> import narwhals as nw >>> df_native = duckdb.sql( ... "SELECT * FROM VALUES (null, CAST('NaN' AS DOUBLE)), (2, 2.) df(a, b)" ... ) >>> df = nw.from_native(df_native) >>> df.with_columns( ... a_is_nan=nw.col("a").is_nan(), b_is_nan=nw.col("b").is_nan() ... ) ┌────────────────────────────────────────┠| Narwhals LazyFrame | |----------------------------------------| |┌───────┬────────┬──────────┬──────────â”| |│ a │ b │ a_is_nan │ b_is_nan │| |│ int32 │ double │ boolean │ boolean │| |├───────┼────────┼──────────┼──────────┤| |│ NULL │ nan │ NULL │ true │| |│ 2 │ 2.0 │ false │ false │| |└───────┴────────┴──────────┴──────────┘| └────────────────────────────────────────┘ cóB•—‰j|«j«Sr;)rFÚis_nanrxs €rBrfzExpr.is_nan..SrrDrärms`rBrmz Expr.is_nan6sø€ð:×%Ñ%Ó&WÓXÐXrDcóþ‡‡‡‡—‰‰ d}t|«‚‰€‰€ d}t|«‚‰‰dvrd‰›}t|«‚‰jˆˆˆˆfd„‰‰jj««S‰j«S)u¸Fill null values with given value. Arguments: value: Value or expression 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 other libraries. See [null_handling](../concepts/null_handling.md/) for reference. - For pandas Series of `object` dtype, `fill_null` will not automatically change the Series' dtype as pandas used to do. Explicitly call `cast` if you want the dtype to change. Examples: >>> import polars as pl >>> import narwhals as nw >>> df_native = pl.DataFrame( ... { ... "a": [2, None, None, 3], ... "b": [2.0, float("nan"), float("nan"), 3.0], ... "c": [1, 2, 3, 4], ... } ... ) >>> df = nw.from_native(df_native) >>> df.with_columns( ... nw.col("a", "b").fill_null(0).name.suffix("_filled"), ... nw.col("a").fill_null(nw.col("c")).name.suffix("_filled_with_c"), ... ) ┌────────────────────────────────────────────────────────────┠| Narwhals DataFrame | |------------------------------------------------------------| |shape: (4, 6) | |┌──────┬─────┬─────┬──────────┬──────────┬─────────────────â”| |│ a ┆ b ┆ c ┆ a_filled ┆ b_filled ┆ a_filled_with_c │| |│ --- ┆ --- ┆ --- ┆ --- ┆ --- ┆ --- │| |│ i64 ┆ f64 ┆ i64 ┆ i64 ┆ f64 ┆ i64 │| |â•žâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡| |│ 2 ┆ 2.0 ┆ 1 ┆ 2 ┆ 2.0 ┆ 2 │| |│ null ┆ NaN ┆ 2 ┆ 0 ┆ NaN ┆ 2 │| |│ null ┆ NaN ┆ 3 ┆ 0 ┆ NaN ┆ 3 │| |│ 3 ┆ 3.0 ┆ 4 ┆ 3 ┆ 3.0 ┆ 3 │| |└──────┴─────┴─────┴──────────┴──────────┴─────────────────┘| └────────────────────────────────────────────────────────────┘ Using a strategy: >>> df.select( ... nw.col("a", "b"), ... nw.col("a", "b") ... .fill_null(strategy="forward", limit=1) ... .name.suffix("_nulls_forward_filled"), ... ) ┌────────────────────────────────────────────────────────────────┠| Narwhals DataFrame | |----------------------------------------------------------------| |shape: (4, 4) | |┌──────┬─────┬────────────────────────┬────────────────────────â”| |│ a ┆ b ┆ a_nulls_forward_filled ┆ b_nulls_forward_filled │| |│ --- ┆ --- ┆ --- ┆ --- │| |│ i64 ┆ f64 ┆ i64 ┆ f64 │| |â•žâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡| |│ 2 ┆ 2.0 ┆ 2 ┆ 2.0 │| |│ null ┆ NaN ┆ 2 ┆ NaN │| |│ null ┆ NaN ┆ null ┆ NaN │| |│ 3 ┆ 3.0 ┆ 3 ┆ 3.0 │| |└──────┴─────┴────────────────────────┴────────────────────────┘| └────────────────────────────────────────────────────────────────┘ z*cannot specify both `value` and `strategy`z0must specify either a fill `value` or `strategy`>ÚforwardÚbackwardzstrategy not supported: có,•—t|ˆˆfd„‰‰d¬«S)Ncó8•—|dj|d‰‰¬«S)Nrrí)ÚstrategyÚlimit)Ú fill_null)rertrss €€rBrfz2Expr.fill_null....­s&ø€˜u Q™x×1Ñ1ؘ!‘H x°uð 2ó €rDTrˆrc)r>rtr@rsÚvalues €€€€rBrfz Expr.fill_null..«s ø€Ô-ØôðØØô€rD)Ú ValueErrorrJr=rU)r@rvrsrtrrs```` rBruzExpr.fill_nullUs û€ðV Ð  Ð!5Ø>ˆCܘS“/Ð !Ø ˆ=˜XÐ-ØDˆCܘS“/Ð !Ø Ð  HÐ4KÑ$KØ,¨X¨JÐ7ˆCܘS“/Ð !à~‰~ö ðÐ#ð N‰N× 0Ñ 0Ó 2ó  ð ð—‘ó  ð rDcó0‡‡—‰jˆˆfd„«S)uâFill floating point NaN values with given value. Arguments: value: Value used to fill NaN values. Notes: This function only fills `'NaN'` values, not null ones, except for pandas which doesn't distinguish between them. See [null_handling](../concepts/null_handling.md/) for reference. Examples: >>> import duckdb >>> import narwhals as nw >>> df_native = duckdb.sql( ... "SELECT * FROM VALUES (5.::DOUBLE, 50.::DOUBLE), ('NaN', null) df(a, b)" ... ) >>> df = nw.from_native(df_native) >>> df.with_columns(nw.col("a", "b").fill_nan(0).name.suffix("_nans_filled")) ┌───────────────────────────────────────────────────┠| Narwhals LazyFrame | |---------------------------------------------------| |┌────────┬────────┬───────────────┬───────────────â”| |│ a │ b │ a_nans_filled │ b_nans_filled │| |│ double │ double │ double │ double │| |├────────┼────────┼───────────────┼───────────────┤| |│ 5.0 │ 50.0 │ 5.0 │ 50.0 │| |│ nan │ NULL │ 0.0 │ NULL │| |└────────┴────────┴───────────────┴───────────────┘| └───────────────────────────────────────────────────┘ cóD•—‰j|«j‰«Sr;)rFÚfill_nan)r>r@rvs €€rBrfzExpr.fill_nan..Ùsø€˜×/Ñ/°Ó4×=Ñ=¸eÓD€rDrä)r@rvs``rBrzz Expr.fill_nan¹sù€ð>×%Ñ%Ü Dó ð rDcó,‡—‰jˆfd„«S)uˆDrop null values. Notes: pandas handles null values differently from Polars and PyArrow. See [null_handling](../concepts/null_handling.md/) for reference. Examples: >>> import polars as pl >>> import narwhals as nw >>> df_native = pl.DataFrame({"a": [2.0, 4.0, float("nan"), 3.0, None, 5.0]}) >>> df = nw.from_native(df_native) >>> df.select(nw.col("a").drop_nulls()) ┌──────────────────┠|Narwhals DataFrame| |------------------| | shape: (5, 1) | | ┌─────┠| | │ a │ | | │ --- │ | | │ f64 │ | | â•žâ•â•â•â•â•â•¡ | | │ 2.0 │ | | │ 4.0 │ | | │ NaN │ | | │ 3.0 │ | | │ 5.0 │ | | └─────┘ | └──────────────────┘ cóB•—‰j|«j«Sr;)rFÚ drop_nullsrxs €rBrfz!Expr.drop_nulls..ürãrDr0rms`rBr}zExpr.drop_nullsÝsø€ð<×$Ñ$Û Aó ð rD)Úorder_byc󇇇—t|«Št|t«r|gn|xsgŠ‰s‰s d}t|«‚‰j}‰r|j «}n‰s d}t |«‚|j«}‰jˆˆˆfd„|«S)u›Compute expressions over the given groups (optionally with given order). Arguments: partition_by: Names of columns to compute window expression over. Must be names of columns, as opposed to expressions - so, this is a bit less flexible than Polars' `Expr.over`. order_by: Column(s) to order window functions by. For lazy backends, this argument is required when `over` is applied to order-dependent functions, see [order-dependence](../concepts/order_dependence.md). Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [1, 2, 4], "b": ["x", "x", "y"]}) >>> df = nw.from_native(df_native) >>> df.with_columns(a_min_per_group=nw.col("a").min().over("b")) ┌────────────────────────┠| Narwhals DataFrame | |------------------------| | a b a_min_per_group| |0 1 x 1| |1 2 x 1| |2 4 y 4| └────────────────────────┘ Cumulative operations are also supported, but (currently) only for pandas and Polars: >>> df.with_columns(a_cum_sum_per_group=nw.col("a").cum_sum().over("b")) ┌────────────────────────────┠| Narwhals DataFrame | |----------------------------| | a b a_cum_sum_per_group| |0 1 x 1| |1 2 x 3| |2 4 y 4| └────────────────────────────┘ z?At least one of `partition_by` or `order_by` must be specified.cóF•—‰j|«j‰‰«Sr;)rFÚover)r>Ú flat_order_byÚflat_partition_byr@s €€€rBrfzExpr.over..:s"ø€˜×/Ñ/°Ó4×9Ñ9Ø! =ó€rD) rrKr]rwr=Úwith_ordered_overrÚwith_partitioned_overrJ)r@r~Ú partition_byrrÚ current_metaÚ next_metar‚rƒs` @@rBrz Expr.overÿs’ú€ôV$ LÓ1ÐÜ&0°¼3Ô&?˜™ ÀhÂnÐRTˆ Ù ©ØSˆCܘS“/Ð !à—~‘~ˆ Ù Ø$×6Ñ6Ó8‰IÙ"ØSˆCÜ'¨Ó,Ð ,à$×:Ñ:Ó<ˆIà~‰~õ ð ó  ð rDcó,‡—‰jˆfd„«S)uReturn a boolean mask indicating duplicated values. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [1, 2, 3, 1], "b": ["a", "a", "b", "c"]}) >>> df = nw.from_native(df_native) >>> df.with_columns(nw.all().is_duplicated().name.suffix("_is_duplicated")) ┌─────────────────────────────────────────┠| Narwhals DataFrame | |-----------------------------------------| | a b a_is_duplicated b_is_duplicated| |0 1 a True True| |1 2 a False True| |2 3 b False False| |3 1 c True False| └─────────────────────────────────────────┘ cóB•—‰j|«j«Sr;)rFÚ is_duplicatedrxs €rBrfz$Expr.is_duplicated..Ssø€¨T×-DÑ-DÀSÓ-I×-WÑ-WÓ-Y€rD©rYrms`rBr‹zExpr.is_duplicated@sø€ð&× Ñ Ó!YÓZÐZrDcó,‡—‰jˆfd„«S)u©Return a boolean mask indicating unique values. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [1, 2, 3, 1], "b": ["a", "a", "b", "c"]}) >>> df = nw.from_native(df_native) >>> df.with_columns(nw.all().is_unique().name.suffix("_is_unique")) ┌─────────────────────────────────┠| Narwhals DataFrame | |---------------------------------| | a b a_is_unique b_is_unique| |0 1 a False False| |1 2 a True False| |2 3 b True True| |3 1 c False True| └─────────────────────────────────┘ cóB•—‰j|«j«Sr;)rFÚ is_uniquerxs €rBrfz Expr.is_unique..hsø€¨T×-DÑ-DÀSÓ-I×-SÑ-SÓ-U€rDrŒrms`rBrzExpr.is_uniqueUsø€ð&× Ñ Ó!UÓVÐVrDcó,‡—‰jˆfd„«S)uCount null values. Notes: pandas handles null values differently from Polars and PyArrow. See [null_handling](../concepts/null_handling.md/) for reference. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame( ... {"a": [1, 2, None, 1], "b": ["a", None, "b", None]} ... ) >>> df = nw.from_native(df_native) >>> df.select(nw.all().null_count()) ┌──────────────────┠|Narwhals DataFrame| |------------------| | a b | | 0 1 2 | └──────────────────┘ cóB•—‰j|«j«Sr;)rFÚ null_countrxs €rBrfz!Expr.null_count..rãrDryrms`rBr’zExpr.null_countjsø€ð,×%Ñ%Û Aó ð rDcó,‡—‰jˆfd„«S)uŠReturn a boolean mask indicating the first occurrence of each distinct value. Info: For lazy backends, this operation must be followed by `Expr.over` with `order_by` specified, see [order-dependence](../concepts/order_dependence.md). Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [1, 2, 3, 1], "b": ["a", "a", "b", "c"]}) >>> df = nw.from_native(df_native) >>> df.with_columns( ... nw.all().is_first_distinct().name.suffix("_is_first_distinct") ... ) ┌─────────────────────────────────────────────────┠| Narwhals DataFrame | |-------------------------------------------------| | a b a_is_first_distinct b_is_first_distinct| |0 1 a True True| |1 2 a True False| |2 3 b True True| |3 1 c False True| └─────────────────────────────────────────────────┘ cóB•—‰j|«j«Sr;)rFÚis_first_distinctrxs €rBrfz(Expr.is_first_distinct..žsø€˜×/Ñ/°Ó4×FÑFÓH€rDrùrms`rBr•zExpr.is_first_distinct„sø€ð2×*Ñ*Û Hó ð rDcó,‡—‰jˆfd„«S)umReturn a boolean mask indicating the last occurrence of each distinct value. Info: For lazy backends, this operation must be followed by `Expr.over` with `order_by` specified, see [order-dependence](../concepts/order_dependence.md). Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [1, 2, 3, 1], "b": ["a", "a", "b", "c"]}) >>> df = nw.from_native(df_native) >>> df.with_columns( ... nw.all().is_last_distinct().name.suffix("_is_last_distinct") ... ) ┌───────────────────────────────────────────────┠| Narwhals DataFrame | |-----------------------------------------------| | a b a_is_last_distinct b_is_last_distinct| |0 1 a False False| |1 2 a True True| |2 3 b True True| |3 1 c True True| └───────────────────────────────────────────────┘ cóB•—‰j|«j«Sr;)rFÚis_last_distinctrxs €rBrfz'Expr.is_last_distinct..»sø€˜×/Ñ/°Ó4×EÑEÓG€rDrùrms`rBr˜zExpr.is_last_distinct¡sø€ð2×*Ñ*Û Gó ð rDcó4‡‡‡—‰jˆˆˆfd„«S)uØGet quantile value. Arguments: quantile: Quantile between 0.0 and 1.0. interpolation: Interpolation method. Note: - pandas and Polars may have implementation differences for a given interpolation method. - [dask](https://docs.dask.org/en/stable/generated/dask.dataframe.Series.quantile.html) has its own method to approximate quantile and it doesn't implement 'nearest', 'higher', 'lower', 'midpoint' as interpolation method - use 'linear' which is closest to the native 'dask' - method. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame( ... {"a": list(range(50)), "b": list(range(50, 100))} ... ) >>> df = nw.from_native(df_native) >>> df.select(nw.col("a", "b").quantile(0.5, interpolation="linear")) ┌──────────────────┠|Narwhals DataFrame| |------------------| | a b | | 0 24.5 74.5 | └──────────────────┘ cóF•—‰j|«j‰‰«Sr;)rFÚquantile)r>Ú interpolationr›r@s €€€rBrfzExpr.quantile..Þsø€˜×/Ñ/°Ó4×=Ñ=¸hÈ ÓV€rDry)r@r›rœs```rBr›z Expr.quantile¾sú€ð>×%Ñ%Ý Vó ð rDcó0‡‡—‰jˆˆfd„«S)uÀRound underlying floating point data by `decimals` digits. Arguments: decimals: Number of decimals to round by. 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 pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [1.12345, 2.56789, 3.901234]}) >>> df = nw.from_native(df_native) >>> df.with_columns(a_rounded=nw.col("a").round(1)) ┌──────────────────────┠| Narwhals DataFrame | |----------------------| | a a_rounded| |0 1.123450 1.1| |1 2.567890 2.6| |2 3.901234 3.9| └──────────────────────┘ cóD•—‰j|«j‰«Sr;)rFÚround)r>Údecimalsr@s €€rBrfzExpr.round..sø€˜×/Ñ/°Ó4×:Ñ:¸8ÓD€rDrä)r@r s``rBrŸz Expr.roundásù€ð<×%Ñ%Ü Dó ð rDcó,‡—‰jˆfd„«S)uReturn the number of elements in the column. Null values count towards the total. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": ["x", "y", "z"], "b": [1, 2, 1]}) >>> df = nw.from_native(df_native) >>> df.select( ... nw.col("a").filter(nw.col("b") == 1).len().alias("a1"), ... nw.col("a").filter(nw.col("b") == 2).len().alias("a2"), ... ) ┌──────────────────┠|Narwhals DataFrame| |------------------| | a1 a2 | | 0 2 1 | └──────────────────┘ cóB•—‰j|«j«Sr;)rFÚlenrxs €rBrfzExpr.len..rèrDryrms`rBr£zExpr.lenóø€ð*×%Ñ%Ó&TÓUÐUrDcó4‡‡—|jˆˆfd„‰‰«S)uKClip values in the Series. Arguments: lower_bound: Lower bound value. String literals are treated as column names. upper_bound: Upper bound value. String literals are treated as column names. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [1, 2, 3]}) >>> df = nw.from_native(df_native) >>> df.with_columns(a_clipped=nw.col("a").clip(-1, 3)) ┌──────────────────┠|Narwhals DataFrame| |------------------| | a a_clipped | | 0 1 1 | | 1 2 2 | | 2 3 3 | └──────────────────┘ cóR•—|dj‰|dnd‰ |d«Sd«S)Nrríé)Úclip)rerWrXs €€rBrfzExpr.clip..5s8ø€˜5 ™8Ÿ=™=Ø'Ð3a’¸Ø'Ð3a‘ó€à9=ó€rDrV)r@rWrXs ``rBr¨z Expr.clips#ù€ð4‰ô ð Ø ó  ð rDrì©Úkeepc󖇇—d}‰|vrd|›d‰›d}t|«‚dˆˆfd„ }‰dk(r‰j|«S‰j|«S)u%Compute the most occurring value(s). Can return multiple values. Arguments: keep: Whether to keep all modes or any mode found. Remark that `keep='any'` is not deterministic for multimodal values. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [1, 1, 2, 3], "b": [1, 1, 2, 2]}) >>> df = nw.from_native(df_native) >>> df.select(nw.col("a").mode()).sort("a") ┌──────────────────┠|Narwhals DataFrame| |------------------| | a | | 0 1 | └──────────────────┘ )rìrçz`keep` must be one of z , found 'ú'cóF•—‰j|«j‰¬«S)Nr©)rFÚmode)r>rªr@s €€rBrz!Expr.mode..compliant_exprXs"ø€Ø×*Ñ*¨3Ó/×4Ñ4¸$Ð4Ó?Ð ?rDrçr)rwrPr\)r@rªÚ_supported_keep_valuesrrrs`` rBr®z Expr.mode=sfù€ð,"0ÐØ Ð-Ñ -Ø*Ð+AÐ*BÀ)ÈDÈ6ÐQRÐSˆCܘS“/Ð !ö @ð 5Š=Ø×)Ñ)¨.Ó9Ð 9Ø×$Ñ$ ^Ó4Ð4rDcó,‡—‰jˆfd„«S)u2Returns boolean values indicating which original values are finite. Warning: pandas handles null values differently from Polars and PyArrow. See [null_handling](../concepts/null_handling.md/) for reference. `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. Examples: >>> import polars as pl >>> import narwhals as nw >>> df_native = pl.DataFrame({"a": [float("nan"), float("inf"), 2.0, None]}) >>> df = nw.from_native(df_native) >>> df.with_columns(a_is_finite=nw.col("a").is_finite()) ┌──────────────────────┠| Narwhals DataFrame | |----------------------| |shape: (4, 2) | |┌──────┬─────────────â”| |│ a ┆ a_is_finite │| |│ --- ┆ --- │| |│ f64 ┆ bool │| |â•žâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•¡| |│ NaN ┆ false │| |│ inf ┆ false │| |│ 2.0 ┆ true │| |│ null ┆ null │| |└──────┴─────────────┘| └──────────────────────┘ cóB•—‰j|«j«Sr;)rFÚ is_finiterxs €rBrfz Expr.is_finite..€sø€˜×/Ñ/°Ó4×>Ñ>Ó@€rDrärms`rBr²zExpr.is_finite_sø€ð@×%Ñ%Û @ó ð rDcó0‡‡—‰jˆˆfd„«S)uˆReturn the cumulative count of the non-null values in the column. Info: For lazy backends, this operation must be followed by `Expr.over` with `order_by` specified, see [order-dependence](../concepts/order_dependence.md). Arguments: reverse: reverse the operation Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": ["x", "k", None, "d"]}) >>> df = nw.from_native(df_native) >>> df.with_columns( ... nw.col("a").cum_count().alias("a_cum_count"), ... nw.col("a").cum_count(reverse=True).alias("a_cum_count_reverse"), ... ) ┌─────────────────────────────────────────┠| Narwhals DataFrame | |-----------------------------------------| | a a_cum_count a_cum_count_reverse| |0 x 1 3| |1 k 2 2| |2 None 2 1| |3 d 3 1| └─────────────────────────────────────────┘ cóF•—‰j|«j‰¬«Sr7)rFÚ cum_countr9s €€rBrfz Expr.cum_count..¡s ø€˜×/Ñ/°Ó4×>Ñ>ÀwÐ>ÓO€rDrùr;s``rBrµzExpr.cum_countƒsù€ð:×*Ñ*Ü Oó ð rDcó0‡‡—‰jˆˆfd„«S)u7Return the cumulative min of the non-null values in the column. Info: For lazy backends, this operation must be followed by `Expr.over` with `order_by` specified, see [order-dependence](../concepts/order_dependence.md). Arguments: reverse: reverse the operation Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [3, 1, None, 2]}) >>> df = nw.from_native(df_native) >>> df.with_columns( ... nw.col("a").cum_min().alias("a_cum_min"), ... nw.col("a").cum_min(reverse=True).alias("a_cum_min_reverse"), ... ) ┌────────────────────────────────────┠| Narwhals DataFrame | |------------------------------------| | a a_cum_min a_cum_min_reverse| |0 3.0 3.0 1.0| |1 1.0 1.0 1.0| |2 NaN NaN NaN| |3 2.0 1.0 2.0| └────────────────────────────────────┘ cóF•—‰j|«j‰¬«Sr7)rFÚcum_minr9s €€rBrfzExpr.cum_min..Âr:rDrùr;s``rBr¸z Expr.cum_min¤óù€ð:×*Ñ*Ü Mó ð rDcó0‡‡—‰jˆˆfd„«S)u7Return the cumulative max of the non-null values in the column. Info: For lazy backends, this operation must be followed by `Expr.over` with `order_by` specified, see [order-dependence](../concepts/order_dependence.md). Arguments: reverse: reverse the operation Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [1, 3, None, 2]}) >>> df = nw.from_native(df_native) >>> df.with_columns( ... nw.col("a").cum_max().alias("a_cum_max"), ... nw.col("a").cum_max(reverse=True).alias("a_cum_max_reverse"), ... ) ┌────────────────────────────────────┠| Narwhals DataFrame | |------------------------------------| | a a_cum_max a_cum_max_reverse| |0 1.0 1.0 3.0| |1 3.0 3.0 3.0| |2 NaN NaN NaN| |3 2.0 3.0 2.0| └────────────────────────────────────┘ cóF•—‰j|«j‰¬«Sr7)rFÚcum_maxr9s €€rBrfzExpr.cum_max..ãr:rDrùr;s``rBr¼z Expr.cum_maxÅr¹rDcó0‡‡—‰jˆˆfd„«S)uYReturn the cumulative product of the non-null values in the column. Info: For lazy backends, this operation must be followed by `Expr.over` with `order_by` specified, see [order-dependence](../concepts/order_dependence.md). Arguments: reverse: reverse the operation Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [1, 3, None, 2]}) >>> df = nw.from_native(df_native) >>> df.with_columns( ... nw.col("a").cum_prod().alias("a_cum_prod"), ... nw.col("a").cum_prod(reverse=True).alias("a_cum_prod_reverse"), ... ) ┌──────────────────────────────────────┠| Narwhals DataFrame | |--------------------------------------| | a a_cum_prod a_cum_prod_reverse| |0 1.0 1.0 6.0| |1 3.0 3.0 6.0| |2 NaN NaN NaN| |3 2.0 6.0 2.0| └──────────────────────────────────────┘ cóF•—‰j|«j‰¬«Sr7)rFÚcum_prodr9s €€rBrfzExpr.cum_prod..s ø€˜×/Ñ/°Ó4×=Ñ=ÀgÐ=ÓN€rDrùr;s``rBr¿z Expr.cum_prodæsù€ð:×*Ñ*Ü Nó ð rD)rôÚcentercóX‡‡‡‡—t‰|¬«\ŠŠ‰jˆˆˆˆfd„«S)uApply 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. Info: For lazy backends, this operation must be followed by `Expr.over` with `order_by` specified, see [order-dependence](../concepts/order_dependence.md). 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. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [1.0, 2.0, None, 4.0]}) >>> df = nw.from_native(df_native) >>> df.with_columns( ... a_rolling_sum=nw.col("a").rolling_sum(window_size=3, min_samples=1) ... ) ┌─────────────────────┠| Narwhals DataFrame | |---------------------| | a a_rolling_sum| |0 1.0 1.0| |1 2.0 3.0| |2 NaN 3.0| |3 4.0 6.0| └─────────────────────┘ ©Ú window_sizerôcóJ•—‰j|«j‰‰‰¬«S©N)rÃrôrÀ)rFÚ rolling_sum)r>rÀÚmin_samples_intr@rÃs €€€€rBrfz"Expr.rolling_sum..6s*ø€˜×/Ñ/°Ó4×@Ñ@Ø'°_ÈVðAó€rD©r rV)r@rÃrôrÀrÇs`` `@rBrÆzExpr.rolling_sums5û€ôT(CØ#°ô( Ñ$ˆ _ð×*Ñ*ö ó ð rDcóX‡‡‡‡—t‰‰¬«\ŠŠ‰jˆˆˆˆfd„«S)uApply 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. Info: For lazy backends, this operation must be followed by `Expr.over` with `order_by` specified, see [order-dependence](../concepts/order_dependence.md). 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. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [1.0, 2.0, None, 4.0]}) >>> df = nw.from_native(df_native) >>> df.with_columns( ... a_rolling_mean=nw.col("a").rolling_mean(window_size=3, min_samples=1) ... ) ┌──────────────────────┠| Narwhals DataFrame | |----------------------| | a a_rolling_mean| |0 1.0 1.0| |1 2.0 1.5| |2 NaN 1.5| |3 4.0 3.0| └──────────────────────┘ rÂcóJ•—‰j|«j‰‰‰¬«SrÅ)rFÚ rolling_mean)r>rÀrôr@rÃs €€€€rBrfz#Expr.rolling_mean..js*ø€˜×/Ñ/°Ó4×AÑAØ'°[ÈðBó€rDrÈ)r@rÃrôrÀs````rBrËzExpr.rolling_mean;s4û€ôT$?Ø#°ô$ Ñ ˆ [ð×*Ñ*ö ó ð rD)rôrÀrcó\‡‡‡‡‡—t‰‰¬«\ŠŠ‰jˆˆˆˆˆfd„«S)ukApply 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. Info: For lazy backends, this operation must be followed by `Expr.over` with `order_by` specified, see [order-dependence](../concepts/order_dependence.md). 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. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [1.0, 2.0, None, 4.0]}) >>> df = nw.from_native(df_native) >>> df.with_columns( ... a_rolling_var=nw.col("a").rolling_var(window_size=3, min_samples=1) ... ) ┌─────────────────────┠| Narwhals DataFrame | |---------------------| | a a_rolling_var| |0 1.0 NaN| |1 2.0 0.5| |2 NaN 0.5| |3 4.0 2.0| └─────────────────────┘ rÂcóL•—‰j|«j‰‰‰‰¬«S©N)rÃrôrÀr)rFÚ rolling_var©r>rÀrrôr@rÃs €€€€€rBrfz"Expr.rolling_var..¤ó-ø€˜×/Ñ/°Ó4×@Ñ@Ø'°[ÈÐVZðAó€rDrÈ©r@rÃrôrÀrs`````rBrÏzExpr.rolling_varoó4ü€ô`$?Ø#°ô$ Ñ ˆ [ð×*Ñ*÷ ó ð rDcó\‡‡‡‡‡—t‰‰¬«\ŠŠ‰jˆˆˆˆˆfd„«S)u‰Apply 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. Info: For lazy backends, this operation must be followed by `Expr.over` with `order_by` specified, see [order-dependence](../concepts/order_dependence.md). 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. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [1.0, 2.0, None, 4.0]}) >>> df = nw.from_native(df_native) >>> df.with_columns( ... a_rolling_std=nw.col("a").rolling_std(window_size=3, min_samples=1) ... ) ┌─────────────────────┠| Narwhals DataFrame | |---------------------| | a a_rolling_std| |0 1.0 NaN| |1 2.0 0.707107| |2 NaN 0.707107| |3 4.0 1.414214| └─────────────────────┘ rÂcóL•—‰j|«j‰‰‰‰¬«SrÎ)rFÚ rolling_stdrÐs €€€€€rBrfz"Expr.rolling_std..ÞrÑrDrÈrÒs`````rBrÖzExpr.rolling_std©rÓrD)Ú descendingcóf‡‡‡—hd£}‰|vrd‰›d}t|«‚‰jˆˆˆfd„«S)uPAssign ranks to data, dealing with ties appropriately. Notes: The resulting dtype may differ between backends. Info: For lazy backends, this operation must be followed by `Expr.over` with `order_by` specified, see [order-dependence](../concepts/order_dependence.md). 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. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [3, 6, 1, 1, 6]}) >>> df = nw.from_native(df_native) >>> result = df.with_columns(rank=nw.col("a").rank(method="dense")) >>> result ┌──────────────────┠|Narwhals DataFrame| |------------------| | a rank | | 0 3 2.0 | | 1 6 3.0 | | 2 1 1.0 | | 3 1 1.0 | | 4 6 3.0 | └──────────────────┘ >r&r"ÚdenseÚaverageÚordinalzTRanking method must be one of {'average', 'min', 'max', 'dense', 'ordinal'}. Found 'r¬cóH•—‰j|«j‰‰¬«S)N)Úmethodr×)rFÚrank)r>r×rÝr@s €€€rBrfzExpr.rank..s'ø€˜×/Ñ/°Ó4×9Ñ9ب*ð:ó€rD)rwrY)r@rÝr×Úsupported_rank_methodsrrs``` rBrÞz Expr.rankãsPú€ò\"OÐØ Ð/Ñ /ðØ ˜ ð$ð ô˜S“/Ð !à× Ñ õ ó ð rDcó0‡‡—‰jˆˆfd„«S)uœCompute the logarithm to a given base. Arguments: base: Given base, defaults to `e` Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> df_native = pa.table({"values": [1, 2, 4]}) >>> df = nw.from_native(df_native) >>> result = df.with_columns( ... log=nw.col("values").log(), log_2=nw.col("values").log(base=2) ... ) >>> result ┌────────────────────────────────────────────────┠| Narwhals DataFrame | |------------------------------------------------| |pyarrow.Table | |values: int64 | |log: double | |log_2: double | |---- | |values: [[1,2,4]] | |log: [[0,0.6931471805599453,1.3862943611198906]]| |log_2: [[0,1,2]] | └────────────────────────────────────────────────┘ cóF•—‰j|«j‰¬«S)N)Úbase)rFÚlog)r>râr@s €€rBrfzExpr.log..<r rDrä)r@râs``rBrãzExpr.logsù€ð8×%Ñ%Ü Có ð rDcó,‡—‰jˆfd„«S)u‚Compute the exponent. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> df_native = pa.table({"values": [-1, 0, 1]}) >>> df = nw.from_native(df_native) >>> result = df.with_columns(exp=nw.col("values").exp()) >>> result ┌────────────────────────────────────────────────┠| Narwhals DataFrame | |------------------------------------------------| |pyarrow.Table | |values: int64 | |exp: double | |---- | |values: [[-1,0,1]] | |exp: [[0.36787944117144233,1,2.718281828459045]]| └────────────────────────────────────────────────┘ cóB•—‰j|«j«Sr;)rFÚexprxs €rBrfzExpr.exp..TrèrDrärms`rBræzExpr.exp?r¤rDcó,‡—‰jˆfd„«S)uâCompute the square root. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> df_native = pa.table({"values": [1, 4, 9]}) >>> df = nw.from_native(df_native) >>> result = df.with_columns(sqrt=nw.col("values").sqrt()) >>> result ┌──────────────────┠|Narwhals DataFrame| |------------------| |pyarrow.Table | |values: int64 | |sqrt: double | |---- | |values: [[1,4,9]] | |sqrt: [[1,2,3]] | └──────────────────┘ cóB•—‰j|«j«Sr;)rFÚsqrtrxs €rBrfzExpr.sqrt..krýrDrärms`rBréz Expr.sqrtVsø€ð*×%Ñ%Ó&UÓVÐVrDgg•Ö&è .>©Úabs_tolÚrel_tolÚ nans_equalc󞇗|dkrd|›}t|«‚d|cxkrdksnd|›}t|«‚|||dœŠ|jˆfd„|«S)uB Check if this expression is close, i.e. almost equal, to the other expression. Two values `a` and `b` are considered close if the following condition holds: $$ |a-b| \le max \{ \text{rel\_tol} \cdot max \{ |a|, |b| \}, \text{abs\_tol} \} $$ Arguments: other: Values to compare with. abs_tol: Absolute tolerance. This is the maximum allowed absolute difference between two values. Must be non-negative. rel_tol: Relative tolerance. This is the maximum allowed difference between two values, relative to the larger absolute value. Must be in the range [0, 1). nans_equal: Whether NaN values should be considered equal. Notes: The implementation of this method is symmetric and mirrors the behavior of `math.isclose`. Specifically note that this behavior is different to `numpy.isclose`. Examples: >>> import duckdb >>> import pyarrow as pa >>> import narwhals as nw >>> >>> data = { ... "x": [1.0, float("inf"), 1.41, None, float("nan")], ... "y": [1.2, float("inf"), 1.40, None, float("nan")], ... } >>> _table = pa.table(data) >>> df_native = duckdb.table("_table") >>> df = nw.from_native(df_native) >>> df.with_columns( ... is_close=nw.col("x").is_close( ... nw.col("y"), abs_tol=0.1, nans_equal=True ... ) ... ) ┌──────────────────────────────┠| Narwhals LazyFrame | |------------------------------| |┌────────┬────────┬──────────â”| |│ x │ y │ is_close │| |│ double │ double │ boolean │| |├────────┼────────┼──────────┤| |│ 1.0 │ 1.2 │ false │| |│ inf │ inf │ true │| |│ 1.41 │ 1.4 │ true │| |│ NULL │ NULL │ NULL │| |│ nan │ nan │ true │| |└────────┴────────┴──────────┘| └──────────────────────────────┘ rz'`abs_tol` must be non-negative but got ríz.`rel_tol` must be in the range [0, 1) but got rêcó6•—|dj|dfi‰¤ŽSrc)Úis_close)rer‚s €rBrfzExpr.is_close..µs"ø€Ð,˜5 ™8×,Ñ,¨U°1©XÑ@¸Ñ@€rD)rrj)r@r‹rërìrírrr‚s @rBrðz Expr.is_closemsjø€ð| QŠ;Ø;¸G¸9ÐEˆCܘsÓ#Ð #àWÔ ˜qÔ ØBÀ7À)ÐLˆCܘsÓ#Ð #à$°È ÑSˆØ‰Û @À%ó ð rDcó—t|«Sr;rrms rBr]zExpr.str¸ó €ä" 4Ó(Ð(rDcó—t|«Sr;rrms rBÚdtzExpr.dt¼s €ä$ TÓ*Ð*rDcó—t|«Sr;rrms rBÚcatzExpr.catÀs €ä Ó%Ð%rDcó—t|«Sr;rrms rBr~z Expr.nameÄó €ä  Ó&Ð&rDcó—t|«Sr;rrms rBrLz Expr.listÈrørDcó—t|«Sr;rrms rBÚstructz Expr.structÌròrD)rAr6rGr rEÚNone)rAzCallable[[Any], Any]rEr$)rezCallable[..., Any]rdz&IntoExpr | NonNestedLiteral | _1DArrayrEr$)rEr])rEr )rEr$)r~r]rEr$)rz"Callable[Concatenate[Self, PS], R]rdzPS.argsr‚z PS.kwargsrEr5)r‡r+rEr$)rzCallable[[Any, Any], Any]r‹ú Self | AnyrbÚboolrEr$)r‹rýrEr$)r‹rrEr$)rïú float | NonerðrÿrñrÿròrÿrórþrôrDrõrþrEr$)rrDrEr$r;)rz(Callable[[Any], CompliantExpr[Any, Any]]rz DType | NonerrþrEr$)rEr8)r4rþrEr$)r@rDrEr$)rJz!Sequence[Any] | Mapping[Any, Any]rIzSequence[Any] | NonerzIntoDType | NonerEr$)Úboth)rWúAny | IntoExprrXrrQr)rEr$)rgrrEr$)NNN)rvzExpr | NonNestedLiteralrszFillNullStrategy | Nonertú int | NonerEr$)rvrÿrEr$)r†zstr | Sequence[str]r~zstr | Sequence[str] | NonerEr$)r›Úfloatrœr1rEr$)r)r rDrEr$)NN)rWú2IntoExpr | NumericLiteral | TemporalLiteral | NonerXrrEr$)rªr-rEr$)rÃrDrôrrÀrþrEr$) rÃrDrôrrÀrþrrDrEr$)rÚ)rÝr0r×rþrEr$)rârrEr$) r‹zSelf | NumericLiteralrërrìrrírþrEr$)rEzExprStringNamespace[Self])rEzExprDateTimeNamespace[Self])rEzExprCatNamespace[Self])rEzExprNameNamespace[Self])rEzExprListNamespace[Self])rEzExprStructNamespace[Self])kÚ__name__Ú __module__Ú __qualname__rHrMrPrSrVrYr\r_rjrnrsrzr}rƒr†rr’r–r™ržr¢r¥r¨rªr­r°r¹r¼r¿rÁrÄrÇrÊrÍrÐrÓrÖrÙrÜrßrârçrìrørürrrrrrrwr"r&r)r,r/rvr8r>rCrHrRr\rdrjrmrurzr}rr‹rr’r•r˜r›rŸr£r¨r®r²rµr¸r¼r¿rÆrËrÏrÖrÞÚmathÚerãrærérðÚpropertyr]rôrör~rLrûr€rDrBr8r84sé„ó"óWóTð Ø!5ð à ó óYóOóSó ð  à*ð ð6ð ð ó  ó$>ó ó ó ð2/à4ð/ðð/ðð /ð ó /ó> ð@ ñ  à+ð  ðð  ð ð  ð ó  ó/ó/ó1ó/ó0ó/ó0ó/ó0óDó4óHó0ó/ó/ó/ó/ó/ó0óDó5óIó0óDó ó Vó(Vð.!Ø!Ø"&Ø"ØØØ"ñ] ðð] ðð ] ð  ð ] ð ð ] ðð] ðð] ðð] ð ó] ó~Wó$Yð*"#õ ð0"#õ ð6&*ð5?ð %ñ 5?à:ð5?ð#ð5?ð ð 5?ð ó 5?ónWó$[ó*Vó0Vó$Vó$Xó$[ó$Xó$Vð&*/õ ó>) óV. ðf%)ð6 ð *.ñ 6 à .ð6 ð"ð6 ð 'ð 6 ð ó 6 ðz"(ð " à#ð" ð$ð" ðð " ð ó " óH'ó>+ óZZó>YðB*.Ø,0Ø ð b à&ðb ð*ðb ðð b ð ó b óH! óH  ðJ04ñ? à*ð? ð-ð? ð ó ? óB[ó*Wó* ó4 ó: ð:! Øð! Ø.Hð! à ó! ôF  óDVð2KOØJNð! àGð! ðHð! ð ó ! ðF05õ 5óD" ðH,1õ ðB*/õ ðB*/õ ðB+0õ ðD>BÐRWñ2 Øð2 Ø0:ð2 ØKOð2 à ó2 ðj>BÐRWñ2 Øð2 Ø0:ð2 ØKOð2 à ó2 ðp#'ØØñ 8 àð8 ð ð 8 ð ð 8 ð ð 8 ð ó8 ð|#'ØØñ 8 àð8 ð ð 8 ð ð 8 ð ð 8 ð ó8 ðt: Èõ: ðx!%§¡ô ó@Vó.Wð6ØØ ñ I à$ðI ðð I ð ð I ð ð I ð óI ðVò)óð)ðò+óð+ðò&óð&ðò'óð'ðò'óð'ðò)óñ)rDr8)EÚ __future__rrÚoperatorrÚcollections.abcrrrÚtypingrrr Únarwhals._expression_parsingr r r Únarwhals._utilsr rrÚnarwhals.dtypesrÚnarwhals.exceptionsrrÚnarwhals.expr_catrÚnarwhals.expr_dtrÚnarwhals.expr_listrÚnarwhals.expr_namerÚnarwhals.expr_strrÚnarwhals.expr_structrÚnarwhals.translaterr r!Útyping_extensionsr"r#r$r%Únarwhals._compliantr&r'r(Únarwhals.typingr)r*r+r,r-r.r/r0r1r2r3r4r5r6Ú__annotations__r8Ú__all__r€rDrBúrsÇðÞ"ã Ûß7Ñ7ß/Ñ/÷ñ÷ NÑMÝ+ßCÝ.Ý2Ý0Ý0Ý1Ý4Ý(áß(çIÓIçEÝ%÷ ÷ ÷ ñ ñ 4‹€BÙ‹ €AØ&Ø ˜C ˜HÑ %Ð&¨ °c¸3°hÑ(?Ð?ñ€L)ó÷ Z")ñZ")ðzD ˆ(rD