§ q-Phidãóä—ddlmZddlmZmZddlmZddlm Z ddl m Z ddl m Z er:ddlZddlmZdd lmZmZdd lmZmZmZdd lmZejd krddlm Z nddlm Z Gd „d¦«ZdS)é)Ú annotations)Ú TYPE_CHECKINGÚCallable)Ú functions)Ú deprecated)Úparse_into_list_of_expressions)Úwrap_ldfN)ÚIterable)Ú DataFrameÚ LazyFrame)ÚIntoExprÚQuantileMethodÚ SchemaDict)Ú PyLazyGroupBy)éé cóÆ—eZdZdZd,d„Zd-d „Zd.d„Zd/d0d„Zd/d0d„Zd1d„Z d2d3d„Z e d¦«d1d„¦«Z d1d„Z d1d„Zd1d „Zd1d!„Zd1d"„Zd1d#„Zd1d$„Z d4d5d*„Zd1d+„ZdS)6Ú LazyGroupByz‡ Utility class for performing a group by operation over a lazy DataFrame. Generated by calling `df.lazy().group_by(...)`. ÚlgbrÚreturnÚNonecó—||_dS©N)r)Úselfrs úY/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/polars/lazyframe/group_by.pyÚ__init__zLazyGroupBy.__init__s €ØˆŒˆˆóÚaggsúIntoExpr | Iterable[IntoExpr]Ú named_aggsr r cóÄ—|r,t|dt¦«rd}t|¦«‚t|i|¤Ž}t |j |¦«¦«S)uu Compute aggregations for each group of a group by operation. Parameters ---------- *aggs Aggregations to compute for each group of the group by operation, specified as positional arguments. Accepts expression input. Strings are parsed as column names. **named_aggs Additional aggregations, specified as keyword arguments. The resulting columns will be renamed to the keyword used. Examples -------- Compute the aggregation of the columns for each group. >>> ldf = pl.DataFrame( ... { ... "a": ["a", "b", "a", "b", "c"], ... "b": [1, 2, 1, 3, 3], ... "c": [5, 4, 3, 2, 1], ... } ... ).lazy() >>> ldf.group_by("a").agg( ... [pl.col("b"), pl.col("c")] ... ).collect() # doctest: +IGNORE_RESULT shape: (3, 3) ┌─────┬───────────┬───────────┠│ a ┆ b ┆ c │ │ --- ┆ --- ┆ --- │ │ str ┆ list[i64] ┆ list[i64] │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•¡ │ a ┆ [1, 1] ┆ [5, 3] │ ├╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌┤ │ b ┆ [2, 3] ┆ [4, 2] │ ├╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌┤ │ c ┆ [3] ┆ [1] │ └─────┴───────────┴───────────┘ Compute the sum of a column for each group. >>> ldf.group_by("a").agg( ... pl.col("b").sum() ... ).collect() # doctest: +IGNORE_RESULT shape: (3, 2) ┌─────┬─────┠│ a ┆ b │ │ --- ┆ --- │ │ str ┆ i64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ a ┆ 2 │ │ b ┆ 5 │ │ c ┆ 3 │ └─────┴─────┘ Compute multiple aggregates at once by passing a list of expressions. >>> ldf.group_by("a").agg( ... [pl.sum("b"), pl.mean("c")] ... ).collect() # doctest: +IGNORE_RESULT shape: (3, 3) ┌─────┬─────┬─────┠│ a ┆ b ┆ c │ │ --- ┆ --- ┆ --- │ │ str ┆ i64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ c ┆ 3 ┆ 1.0 │ │ a ┆ 2 ┆ 4.0 │ │ b ┆ 5 ┆ 3.0 │ └─────┴─────┴─────┘ Or use positional arguments to compute multiple aggregations in the same way. >>> ldf.group_by("a").agg( ... pl.sum("b").name.suffix("_sum"), ... (pl.col("c") ** 2).mean().name.suffix("_mean_squared"), ... ).collect() # doctest: +IGNORE_RESULT shape: (3, 3) ┌─────┬───────┬────────────────┠│ a ┆ b_sum ┆ c_mean_squared │ │ --- ┆ --- ┆ --- │ │ str ┆ i64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ a ┆ 2 ┆ 17.0 │ │ c ┆ 3 ┆ 1.0 │ │ b ┆ 5 ┆ 10.0 │ └─────┴───────┴────────────────┘ Use keyword arguments to easily name your expression inputs. >>> ldf.group_by("a").agg( ... b_sum=pl.sum("b"), ... c_mean_squared=(pl.col("c") ** 2).mean(), ... ).collect() # doctest: +IGNORE_RESULT shape: (3, 3) ┌─────┬───────┬────────────────┠│ a ┆ b_sum ┆ c_mean_squared │ │ --- ┆ --- ┆ --- │ │ str ┆ i64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ a ┆ 2 ┆ 17.0 │ │ c ┆ 3 ┆ 1.0 │ │ b ┆ 5 ┆ 10.0 │ └─────┴───────┴────────────────┘ rz“specifying aggregations as a dictionary is not supported Try unpacking the dictionary to take advantage of the keyword syntax of the `agg` method.)Ú isinstanceÚdictÚ TypeErrorrr rÚagg)rrr ÚmsgÚpyexprss rr%zLazyGroupBy.agg"sh€ð^ ð !•J˜t Aœw­Ñ-Ô-ð !ð(ð õ ˜C‘.”.Ð å0°$ÐE¸*ÐEÐEˆÝ˜œŸ š  WÑ-Ô-Ñ.Ô.Ð.rÚfunctionú Callable[[DataFrame], DataFrame]ÚschemaúSchemaDict | NonecóR—t|j ||¦«¦«S)u­ Apply a custom/user-defined function (UDF) over the groups as a new DataFrame. .. warning:: This method is much slower than the native expressions API. Only use it if you cannot implement your logic otherwise. Using this is considered an anti-pattern as it will be very slow because: - it forces the engine to materialize the whole `DataFrames` for the groups. - it is not parallelized - it blocks optimizations as the passed python function is opaque to the optimizer The idiomatic way to apply custom functions over multiple columns is using: `pl.struct([my_columns]).apply(lambda struct_series: ..)` Parameters ---------- function Function to apply over each group of the `LazyFrame`. schema Schema of the output function. This has to be known statically. If the given schema is incorrect, this is a bug in the caller's query and may lead to errors. If set to None, polars assumes the schema is unchanged. Examples -------- For each color group sample two rows: >>> df = pl.DataFrame( ... { ... "id": [0, 1, 2, 3, 4], ... "color": ["red", "green", "green", "red", "red"], ... "shape": ["square", "triangle", "square", "triangle", "square"], ... } ... ) >>> ( ... df.lazy() ... .group_by("color") ... .map_groups(lambda group_df: group_df.sample(2), schema=None) ... .collect() ... ) # doctest: +IGNORE_RESULT shape: (4, 3) ┌─────┬───────┬──────────┠│ id ┆ color ┆ shape │ │ --- ┆ --- ┆ --- │ │ i64 ┆ str ┆ str │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•¡ │ 1 ┆ green ┆ triangle │ │ 2 ┆ green ┆ square │ │ 4 ┆ red ┆ square │ │ 3 ┆ red ┆ triangle │ └─────┴───────┴──────────┘ It is better to implement this with an expression: >>> df.lazy().filter( ... pl.int_range(pl.len()).shuffle().over("color") < 2 ... ).collect() # doctest: +IGNORE_RESULT )r rÚ map_groups)rr(r*s rr-zLazyGroupBy.map_groupsœs%€õF˜œ×+Ò+¨H°fÑ=Ô=Ñ>Ô>Ð>réÚnÚintcóP—t|j |¦«¦«S)un Get the first `n` rows of each group. Parameters ---------- n Number of rows to return. Examples -------- >>> df = pl.DataFrame( ... { ... "letters": ["c", "c", "a", "c", "a", "b"], ... "nrs": [1, 2, 3, 4, 5, 6], ... } ... ) >>> df shape: (6, 2) ┌─────────┬─────┠│ letters ┆ nrs │ │ --- ┆ --- │ │ str ┆ i64 │ â•žâ•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ c ┆ 1 │ │ c ┆ 2 │ │ a ┆ 3 │ │ c ┆ 4 │ │ a ┆ 5 │ │ b ┆ 6 │ └─────────┴─────┘ >>> df.group_by("letters").head(2).sort("letters") shape: (5, 2) ┌─────────┬─────┠│ letters ┆ nrs │ │ --- ┆ --- │ │ str ┆ i64 │ â•žâ•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ a ┆ 3 │ │ a ┆ 5 │ │ b ┆ 6 │ │ c ┆ 1 │ │ c ┆ 2 │ └─────────┴─────┘ )r rÚhead©rr/s rr2zLazyGroupBy.headáó!€õZ˜œŸ š  aÑ(Ô(Ñ)Ô)Ð)rcóP—t|j |¦«¦«S)un Get the last `n` rows of each group. Parameters ---------- n Number of rows to return. Examples -------- >>> df = pl.DataFrame( ... { ... "letters": ["c", "c", "a", "c", "a", "b"], ... "nrs": [1, 2, 3, 4, 5, 6], ... } ... ) >>> df shape: (6, 2) ┌─────────┬─────┠│ letters ┆ nrs │ │ --- ┆ --- │ │ str ┆ i64 │ â•žâ•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ c ┆ 1 │ │ c ┆ 2 │ │ a ┆ 3 │ │ c ┆ 4 │ │ a ┆ 5 │ │ b ┆ 6 │ └─────────┴─────┘ >>> df.group_by("letters").tail(2).sort("letters") shape: (5, 2) ┌─────────┬─────┠│ letters ┆ nrs │ │ --- ┆ --- │ │ str ┆ i64 │ â•žâ•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ a ┆ 3 │ │ a ┆ 5 │ │ b ┆ 6 │ │ c ┆ 2 │ │ c ┆ 4 │ └─────────┴─────┘ )r rÚtailr3s rr6zLazyGroupBy.tailr4rcóN—| tj¦«¦«S)uÖ Aggregate the groups into Series. Examples -------- >>> ldf = pl.DataFrame( ... { ... "a": ["one", "two", "one", "two"], ... "b": [1, 2, 3, 4], ... } ... ).lazy() >>> ldf.group_by("a", maintain_order=True).all().collect() shape: (2, 2) ┌─────┬───────────┠│ a ┆ b │ │ --- ┆ --- │ │ str ┆ list[i64] │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•¡ │ one ┆ [1, 3] │ │ two ┆ [2, 4] │ └─────┴───────────┘ )r%ÚFÚall©rs rr9zLazyGroupBy.all?s€ð.xŠxœ™œÑ Ô Ð rNÚnameú str | Nonecó€—tj¦«}|| |¦«}| |¦«S)u‡ Return the number of rows in each group. Parameters ---------- name Assign a name to the resulting column; if unset, defaults to "len". Examples -------- >>> lf = pl.LazyFrame({"a": ["Apple", "Apple", "Orange"], "b": [1, None, 2]}) >>> lf.group_by("a").len().collect() # doctest: +IGNORE_RESULT shape: (2, 2) ┌────────┬─────┠│ a ┆ len │ │ --- ┆ --- │ │ str ┆ u32 │ â•žâ•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ Apple ┆ 2 │ │ Orange ┆ 1 │ └────────┴─────┘ >>> lf.group_by("a").len(name="n").collect() # doctest: +IGNORE_RESULT shape: (2, 2) ┌────────┬─────┠│ a ┆ n │ │ --- ┆ --- │ │ str ┆ u32 │ â•žâ•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ Apple ┆ 2 │ │ Orange ┆ 1 │ └────────┴─────┘ )r8ÚlenÚaliasr%)rr;Úlen_exprs rr>zLazyGroupBy.lenXs9€õB”5‘7”7ˆØ Ð Ø—~’~ dÑ+Ô+ˆHØxŠx˜Ñ!Ô!Ð!rz&`count` was renamed; use `len` insteadcót—| tj¦« d¦«¦«S)uh Return the number of rows in each group. .. deprecated:: 0.20.5 This method has been renamed to :func:`LazyGroupBy.len`. Rows containing null values count towards the total. Examples -------- >>> lf = pl.LazyFrame( ... { ... "a": ["Apple", "Apple", "Orange"], ... "b": [1, None, 2], ... } ... ) >>> lf.group_by("a").count().collect() # doctest: +SKIP shape: (2, 2) ┌────────┬───────┠│ a ┆ count │ │ --- ┆ --- │ │ str ┆ u32 │ â•žâ•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•¡ │ Apple ┆ 2 │ │ Orange ┆ 1 │ └────────┴───────┘ Úcount)r%r8r>r?r:s rrBzLazyGroupBy.count~s(€ð:xŠxœ™œŸ š  gÑ.Ô.Ñ/Ô/Ð/rcór—| tj¦« ¦«¦«S)ue Aggregate the first values in the group. Examples -------- >>> ldf = pl.DataFrame( ... { ... "a": [1, 2, 2, 3, 4, 5], ... "b": [0.5, 0.5, 4, 10, 13, 14], ... "c": [True, True, True, False, False, True], ... "d": ["Apple", "Orange", "Apple", "Apple", "Banana", "Banana"], ... } ... ).lazy() >>> ldf.group_by("d", maintain_order=True).first().collect() shape: (3, 4) ┌────────┬─────┬──────┬───────┠│ d ┆ a ┆ b ┆ c │ │ --- ┆ --- ┆ --- ┆ --- │ │ str ┆ i64 ┆ f64 ┆ bool │ â•žâ•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•¡ │ Apple ┆ 1 ┆ 0.5 ┆ true │ │ Orange ┆ 2 ┆ 0.5 ┆ true │ │ Banana ┆ 4 ┆ 13.0 ┆ false │ └────────┴─────┴──────┴───────┘ )r%r8r9Úfirstr:s rrDzLazyGroupBy.firsts$€ð4xŠxœ™œŸ š ™œÑ(Ô(Ð(rcór—| tj¦« ¦«¦«S)uc Aggregate the last values in the group. Examples -------- >>> ldf = pl.DataFrame( ... { ... "a": [1, 2, 2, 3, 4, 5], ... "b": [0.5, 0.5, 4, 10, 14, 13], ... "c": [True, True, True, False, False, True], ... "d": ["Apple", "Orange", "Apple", "Apple", "Banana", "Banana"], ... } ... ).lazy() >>> ldf.group_by("d", maintain_order=True).last().collect() shape: (3, 4) ┌────────┬─────┬──────┬───────┠│ d ┆ a ┆ b ┆ c │ │ --- ┆ --- ┆ --- ┆ --- │ │ str ┆ i64 ┆ f64 ┆ bool │ â•žâ•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•¡ │ Apple ┆ 3 ┆ 10.0 ┆ false │ │ Orange ┆ 2 ┆ 0.5 ┆ true │ │ Banana ┆ 5 ┆ 13.0 ┆ true │ └────────┴─────┴──────┴───────┘ )r%r8r9Úlastr:s rrFzLazyGroupBy.last¹ó$€ð4xŠxœ™œŸ š ™œÑ'Ô'Ð'rcór—| tj¦« ¦«¦«S)uS Reduce the groups to the maximal value. Examples -------- >>> ldf = pl.DataFrame( ... { ... "a": [1, 2, 2, 3, 4, 5], ... "b": [0.5, 0.5, 4, 10, 13, 14], ... "c": [True, True, True, False, False, True], ... "d": ["Apple", "Orange", "Apple", "Apple", "Banana", "Banana"], ... } ... ).lazy() >>> ldf.group_by("d", maintain_order=True).max().collect() shape: (3, 4) ┌────────┬─────┬──────┬──────┠│ d ┆ a ┆ b ┆ c │ │ --- ┆ --- ┆ --- ┆ --- │ │ str ┆ i64 ┆ f64 ┆ bool │ â•žâ•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•¡ │ Apple ┆ 3 ┆ 10.0 ┆ true │ │ Orange ┆ 2 ┆ 0.5 ┆ true │ │ Banana ┆ 5 ┆ 14.0 ┆ true │ └────────┴─────┴──────┴──────┘ )r%r8r9Úmaxr:s rrIzLazyGroupBy.maxÕó$€ð4xŠxœ™œŸ š ™ œ Ñ&Ô&Ð&rcór—| tj¦« ¦«¦«S)uÊ Reduce the groups to the mean values. Examples -------- >>> ldf = pl.DataFrame( ... { ... "a": [1, 2, 2, 3, 4, 5], ... "b": [0.5, 0.5, 4, 10, 13, 14], ... "c": [True, True, True, False, False, True], ... "d": ["Apple", "Orange", "Apple", "Apple", "Banana", "Banana"], ... } ... ).lazy() >>> ldf.group_by("d", maintain_order=True).mean().collect() shape: (3, 4) ┌────────┬─────┬──────────┬──────────┠│ d ┆ a ┆ b ┆ c │ │ --- ┆ --- ┆ --- ┆ --- │ │ str ┆ f64 ┆ f64 ┆ f64 │ â•žâ•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•¡ │ Apple ┆ 2.0 ┆ 4.833333 ┆ 0.666667 │ │ Orange ┆ 2.0 ┆ 0.5 ┆ 1.0 │ │ Banana ┆ 4.5 ┆ 13.5 ┆ 0.5 │ └────────┴─────┴──────────┴──────────┘ )r%r8r9Úmeanr:s rrLzLazyGroupBy.meanñrGrcór—| tj¦« ¦«¦«S)um Return the median per group. Examples -------- >>> ldf = pl.DataFrame( ... { ... "a": [1, 2, 2, 3, 4, 5], ... "b": [0.5, 0.5, 4, 10, 13, 14], ... "d": ["Apple", "Banana", "Apple", "Apple", "Banana", "Banana"], ... } ... ).lazy() >>> ldf.group_by("d", maintain_order=True).median().collect() shape: (2, 3) ┌────────┬─────┬──────┠│ d ┆ a ┆ b │ │ --- ┆ --- ┆ --- │ │ str ┆ f64 ┆ f64 │ â•žâ•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•¡ │ Apple ┆ 2.0 ┆ 4.0 │ │ Banana ┆ 4.0 ┆ 13.0 │ └────────┴─────┴──────┘ )r%r8r9Úmedianr:s rrNzLazyGroupBy.median s&€ð0xŠxœ™œŸšÑ(Ô(Ñ)Ô)Ð)rcór—| tj¦« ¦«¦«S)ub Reduce the groups to the minimal value. Examples -------- >>> ldf = pl.DataFrame( ... { ... "a": [1, 2, 2, 3, 4, 5], ... "b": [0.5, 0.5, 4, 10, 13, 14], ... "c": [True, True, True, False, False, True], ... "d": ["Apple", "Orange", "Apple", "Apple", "Banana", "Banana"], ... } ... ).lazy() >>> ldf.group_by("d", maintain_order=True).min().collect() shape: (3, 4) ┌────────┬─────┬──────┬───────┠│ d ┆ a ┆ b ┆ c │ │ --- ┆ --- ┆ --- ┆ --- │ │ str ┆ i64 ┆ f64 ┆ bool │ â•žâ•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•¡ │ Apple ┆ 1 ┆ 0.5 ┆ false │ │ Orange ┆ 2 ┆ 0.5 ┆ true │ │ Banana ┆ 4 ┆ 13.0 ┆ false │ └────────┴─────┴──────┴───────┘ )r%r8r9Úminr:s rrPzLazyGroupBy.min'rJrcór—| tj¦« ¦«¦«S)ui Count the unique values per group. Examples -------- >>> ldf = pl.DataFrame( ... { ... "a": [1, 2, 1, 3, 4, 5], ... "b": [0.5, 0.5, 0.5, 10, 13, 14], ... "d": ["Apple", "Banana", "Apple", "Apple", "Banana", "Banana"], ... } ... ).lazy() >>> ldf.group_by("d", maintain_order=True).n_unique().collect() shape: (2, 3) ┌────────┬─────┬─────┠│ d ┆ a ┆ b │ │ --- ┆ --- ┆ --- │ │ str ┆ u32 ┆ u32 │ â•žâ•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ Apple ┆ 2 ┆ 2 │ │ Banana ┆ 3 ┆ 3 │ └────────┴─────┴─────┘ )r%r8r9Ún_uniquer:s rrRzLazyGroupBy.n_uniqueCs(€ð0xŠxœ™œ×(Ò(Ñ*Ô*Ñ+Ô+Ð+rÚnearestÚquantileÚfloatÚ interpolationrcóx—| tj¦« ||¬¦«¦«S)u| Compute the quantile per group. Parameters ---------- quantile Quantile between 0.0 and 1.0. interpolation : {'nearest', 'higher', 'lower', 'midpoint', 'linear', 'equiprobable'} Interpolation method. Examples -------- >>> ldf = pl.DataFrame( ... { ... "a": [1, 2, 2, 3, 4, 5], ... "b": [0.5, 0.5, 4, 10, 13, 14], ... "d": ["Apple", "Orange", "Apple", "Apple", "Banana", "Banana"], ... } ... ).lazy() >>> ldf.group_by("d", maintain_order=True).quantile(1).collect() shape: (3, 3) ┌────────┬─────┬──────┠│ d ┆ a ┆ b │ │ --- ┆ --- ┆ --- │ │ str ┆ f64 ┆ f64 │ â•žâ•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•¡ │ Apple ┆ 3.0 ┆ 10.0 │ │ Orange ┆ 2.0 ┆ 0.5 │ │ Banana ┆ 5.0 ┆ 14.0 │ └────────┴─────┴──────┘ )rV)r%r8r9rT)rrTrVs rrTzLazyGroupBy.quantile]s0€ðDxŠxœ™œ×(Ò(¨ÀÐ(ÑOÔOÑPÔPÐPrcór—| tj¦« ¦«¦«S)u: Reduce the groups to the sum. Examples -------- >>> ldf = pl.DataFrame( ... { ... "a": [1, 2, 2, 3, 4, 5], ... "b": [0.5, 0.5, 4, 10, 13, 14], ... "c": [True, True, True, False, False, True], ... "d": ["Apple", "Orange", "Apple", "Apple", "Banana", "Banana"], ... } ... ).lazy() >>> ldf.group_by("d", maintain_order=True).sum().collect() shape: (3, 4) ┌────────┬─────┬──────┬─────┠│ d ┆ a ┆ b ┆ c │ │ --- ┆ --- ┆ --- ┆ --- │ │ str ┆ i64 ┆ f64 ┆ u32 │ â•žâ•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ Apple ┆ 6 ┆ 14.5 ┆ 2 │ │ Orange ┆ 2 ┆ 0.5 ┆ 1 │ │ Banana ┆ 9 ┆ 27.0 ┆ 1 │ └────────┴─────┴──────┴─────┘ )r%r8r9Úsumr:s rrYzLazyGroupBy.sumrJr)rrrr)rrr r rr )r(r)r*r+rr )r.)r/r0rr )rr r)r;r<rr )rS)rTrUrVrrr )Ú__name__Ú __module__Ú __qualname__Ú__doc__rr%r-r2r6r9r>rrBrDrFrIrLrNrPrRrTrY©rrrrs¸€€€€€ððð ððððx/ðx/ðx/ðx/ðtC?ðC?ðC?ðC?ðJ-*ð-*ð-*ð-*ð-*ð^-*ð-*ð-*ð-*ð-*ð^!ð!ð!ð!ð2$"ð$"ð$"ð$"ð$"ðL€ZÐ8Ñ9Ô9ð0ð0ð0ñ:Ô9ð0ð<)ð)ð)ð)ð8(ð(ð(ð(ð8'ð'ð'ð'ð8(ð(ð(ð(ð8*ð*ð*ð*ð4'ð'ð'ð'ð8,ð,ð,ð,ð6@Ið"Qð"Qð"Qð"Qð"QðH'ð'ð'ð'ð'ð'rr)Ú __future__rÚtypingrrÚpolarsrr8Úpolars._utils.deprecationrÚpolars._utils.parserÚpolars._utils.wrapr ÚsysÚcollections.abcr r r Úpolars._typingr rrÚ polars.polarsrÚ version_infoÚwarningsÚtyping_extensionsrr^rrúrlsSðØ"Ð"Ð"Ð"Ð"Ð"à*Ð*Ð*Ð*Ð*Ð*Ð*Ð*à!Ð!Ð!Ð!Ð!Ð!Ø0Ð0Ð0Ð0Ð0Ð0Ø>Ð>Ð>Ð>Ð>Ð>Ø'Ð'Ð'Ð'Ð'Ð'àð 1Ø€J€J€JØ(Ð(Ð(Ð(Ð(Ð(à+Ð+Ð+Ð+Ð+Ð+Ð+Ð+ØCÐCÐCÐCÐCÐCÐCÐCÐCÐCØ+Ð+Ð+Ð+Ð+Ð+à Ô˜7Ò"Ð"Ø'Ð'Ð'Ð'Ð'Ð'Ð'à0Ð0Ð0Ð0Ð0Ð0ðC 'ðC 'ðC 'ðC 'ðC 'ñC 'ôC 'ðC 'ðC 'ðC 'r