ó œþöh¢dãóô•SSKJr SSKJrJr SSKJr SSKJ r SSK J r SSK J r Jr \(a?SSKrSSKJr SS KJrJr SS KJr SS KJrJrJr \R4S :¼aSSKJ r OSSKJ r "S S5rg)é)Ú annotations)Ú TYPE_CHECKINGÚCallable)Ú functions)Ú deprecated)Úparse_into_list_of_expressions)Úwrap_dfÚwrap_ldfN)ÚIterable)Ú DataFrameÚ LazyFrame)Ú PyLazyGroupBy)ÚIntoExprÚQuantileMethodÚ SchemaDict)éé có •\rSrSrSrSSjrSSjrSSjrSSSjjrSSSjjr SSjr SSS jjr \ "S 5SS j5r SS jrSSjrSSjrSSjrSSjrSSjrSSjrSS SjjrSSjrSrg )!Ú LazyGroupByéz{ Utility class for performing a group by operation over a lazy DataFrame. Generated by calling `df.lazy().group_by(...)`. có•Xlg©N©Úlgb)Úselfrs ÚS/home/james-whalen/.local/lib/python3.13/site-packages/polars/lazyframe/group_by.pyÚ__init__ÚLazyGroupBy.__init__s€Øócó¸•U(a%[US[5(a Sn[U5e[U0UD6n[ UR R U55$)u… 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)rÚaggsÚ named_aggsÚmsgÚpyexprss rr$ÚLazyGroupBy.agg"sU€ö^ ”J˜t A™w¬×-Ñ-ð(ð ô ˜C“.Ð ä0°$ÐE¸*ÑEˆÜ˜Ÿ™Ÿ ™  WÓ-Ó.Ð.rcóV^•[URRU4SjU55$)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 có:>•T"[U55R$r)r Ú_df)ÚdfÚfunctions €rÚÚ(LazyGroupBy.map_groups..àsø€©8´G¸B³KÓ+@×+DÒ+Dr)r rÚ map_groups)rr.Úschemas ` rr1ÚLazyGroupBy.map_groupsœs(ø€ôFØ H‰H× Ñ Ô DÀfÓ Mó ð rcóJ•[URRU55$)u& 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©rÚns rr5ÚLazyGroupBy.headãó€ôZ˜Ÿ™Ÿ ™  aÓ(Ó)Ð)rcóJ•[URRU55$)u& 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Útailr6s rr;ÚLazyGroupBy.tailr9rcóJ•UR[R"55$)u6 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 rr?ÚLazyGroupBy.allAs€ð.x‰xœŸš›Ó Ð rNcóv•[R"5nUbURU5nURU5$)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 │ └────────┴─────┘ )r>ÚlenÚaliasr$)rÚnameÚlen_exprs rrCÚLazyGroupBy.lenZs3€ôB—5’5“7ˆØ Ñ Ø—~‘~ dÓ+ˆHØx‰x˜Ó!Ð!rz&`count` was renamed; use `len` insteadcóh•UR[R"5RS55$)u° 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$r>rCrDr@s rrIÚLazyGroupBy.count€s"€ð:x‰xœŸš›Ÿ ™  gÓ.Ó/Ð/rcóf•UR[R"5R55$)u­ 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$r>r?Úfirstr@s rrLÚLazyGroupBy.firstŸs€ð4x‰xœŸš›Ÿ ™ ›Ó(Ð(rcóf•UR[R"5R55$)u« 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$r>r?Úlastr@s rrOÚLazyGroupBy.last»ó€ð4x‰xœŸš›Ÿ ™ ›Ó'Ð'rcóf•UR[R"5R55$)u› 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$r>r?Úmaxr@s rrSÚLazyGroupBy.max×ó€ð4x‰xœŸš›Ÿ ™ › Ó&Ð&rcóf•UR[R"5R55$)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$r>r?Úmeanr@s rrWÚLazyGroupBy.meanórQrcóf•UR[R"5R55$)uÅ 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$r>r?Úmedianr@s rrZÚLazyGroupBy.medians €ð0x‰xœŸš›Ÿ™Ó(Ó)Ð)rcóf•UR[R"5R55$)uª 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$r>r?Úminr@s rr]ÚLazyGroupBy.min)rUrcóf•UR[R"5R55$)uÁ 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$r>r?Ún_uniquer@s rr`ÚLazyGroupBy.n_uniqueEs"€ð0x‰xœŸš›×(Ñ(Ó*Ó+Ð+rcód•UR[R"5RXS95$)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 │ └────────┴─────┴──────┘ )Ú interpolation)r$r>r?Úquantile)rrdrcs rrdÚLazyGroupBy.quantile_s(€ðDx‰xœŸš›×(Ñ(¨Ð(ÐOÓPÐPrcóf•UR[R"5R55$)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$r>r?Úsumr@s rrgÚLazyGroupBy.sumƒrUrr)rrÚreturnÚNone)r%zIntoExpr | Iterable[IntoExpr]r&rrir )r.z Callable[[DataFrame], DataFrame]r2zSchemaDict | Nonerir )é)r7Úintrir )rir r)rEz str | Nonerir )Únearest)rdÚfloatrcrrir )Ú__name__Ú __module__Ú __qualname__Ú__firstlineno__Ú__doc__rr$r1r5r;r?rCrrIrLrOrSrWrZr]r`rdrgÚ__static_attributes__©rrrrsÚ†ñô ðx/à,ðx/ððx/ð ô x/ðtE à2ðE ð"ðE ð ô E öN-*ö^-*ô^!ö2$"ñLÐ8Ó9ó0ó:ð0ô<)ô8(ô8'ô8(ô8*ô4'ô8,ð6@Ið"QØð"QØ.<ð"Qà õ"Q÷H'rr)Ú __future__rÚtypingrrÚpolarsrr>Úpolars._utils.deprecationrÚpolars._utils.parserÚpolars._utils.wrapr r ÚsysÚcollections.abcr r r Ú polars._plrrÚpolars._typingrrrÚ version_infoÚwarningsÚtyping_extensionsrrurrÚrƒsLðÝ"ç*å!Ý0Ý>ß0æÛÝ(ç+Ý)ßCÑCà ×ј7Ó"Þ'å0÷E 'òE 'r