ó œþöh£—ãóR•SSKJr SSKJrJrJr SSKJr SSK J r SSK J r \(a`SSK r SSKJr SSKJr SS KJr SS KJrJrJrJrJrJr \ R4S :¼aSS KJr OSS KJr \ R4S :¼aSSKJ r OSSKJ r "SS5r"SS5r"SS5r g)é)Ú annotations)Ú TYPE_CHECKINGÚAnyÚCallable)Ú functions)Úparse_as_duration_string)Ú deprecatedN)ÚIterable)Ú timedelta)Ú DataFrame)ÚClosedIntervalÚIntoExprÚLabelÚQuantileMethodÚ SchemaDictÚStartBy)éé )ÚSelf)ré có(•\rSrSrSrSSjrSSjrSSjrSSjrSSjr SSSjjr SSS jjr S S jr S!S"S jjr \"S 5S Sj5rS SjrS SjrS SjrS SjrS SjrS SjrS SjrS#S$SjjrS SjrSrg )%ÚGroupByé#zStarts a new GroupBy operation.có4•XlX0lX@lX lg)a: Utility class for performing a group by operation over the given DataFrame. Generated by calling `df.group_by(...)`. Parameters ---------- df DataFrame to perform the group by operation over. *by Column or columns to group by. Accepts expression input. Strings are parsed as column names. maintain_order Ensure that the order of the groups is consistent with the input data. This is slower than a default group by. **named_by Additional column(s) to group by, specified as keyword arguments. The columns will be named as the keyword used. N)ÚdfÚbyÚnamed_byÚmaintain_order)Úselfrrrrs ÚS/home/james-whalen/.local/lib/python3.13/site-packages/polars/dataframe/group_by.pyÚ__init__ÚGroupBy.__init__&s€ð4ŒØŒØ Œ Ø,Õócó‚•SSKJn URR5UlSnURR 5R "UR 0URDSUR0D6R[R"5R5RU55RUR5S9nUR![R""5R%U55R'5UlUR!U5R+5UlSUlU$)uK Allows iteration over the groups of the group by operation. Each group is represented by a tuple of `(name, data)`. The group names are tuples of the distinct group values that identify each group. Examples -------- >>> df = pl.DataFrame({"foo": ["a", "a", "b"], "bar": [1, 2, 3]}) >>> for name, data in df.group_by("foo"): # doctest: +SKIP ... print(name) ... print(data) (a,) shape: (2, 2) ┌─────┬─────┠│ foo ┆ bar │ │ --- ┆ --- │ │ str ┆ i64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ a ┆ 1 │ │ a ┆ 2 │ └─────┴─────┘ (b,) shape: (1, 2) ┌─────┬─────┠│ foo ┆ bar │ │ --- ┆ --- │ │ str ┆ i64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ b ┆ 3 │ └─────┴─────┘ r©Ú QueryOptFlagsÚ__POLARS_GB_GROUP_INDICESr©Ú optimizations)Úpolars.lazyframe.opt_flagsr&rÚrechunkÚlazyÚgroup_byrrrÚaggÚFÚfirstÚ agg_groupsÚaliasÚcollectÚnoneÚselectÚallÚexcludeÚ iter_rowsÚ _group_namesÚ to_seriesÚ_group_indicesÚ_current_index©rr&Útemp_colÚ groups_dfs r Ú__iter__ÚGroupBy.__iter__Esó€õD =à—'‘'—/‘/Ó#ˆŒØ.ˆà G‰GL‰L‹Nß ‰Xð Ø—w‘wð UØ"&§-¡-ñ UØ@D×@SÑ@Sò Uç ‰S”—’“×%Ñ%Ó'×-Ñ-¨hÓ7Ó 8ß ‰W =×#5Ñ#5Ó#7ˆWÐ 8ð ð&×,Ñ,¬Q¯UªU«W¯_©_¸XÓ-FÓG×QÑQÓSˆÔØ'×.Ñ.¨xÓ8×BÑBÓDˆÔ؈Ôàˆ r#có•UR[UR5:¼a[e[ UR 5nUR URURSS24nU=RS- slX4$©Né©r<Úlenr;Ú StopIterationÚnextr9r©rÚ group_nameÚ group_datas r Ú__next__ÚGroupBy.__next__xóo€Ø × Ñ ¤# d×&9Ñ&9Ó":Ó :ÜÐ ä˜$×+Ñ+Ó,ˆ Ø—W‘W˜T×0Ñ0°×1DÑ1DÑEÂqÐHÑIˆ Ø ×Ò˜qÑ ÕàÐ%Ð%r#cóü•SSKJn URR5R"UR 0UR DSUR0D6R"U0UD6RUR5S9$)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. >>> df = pl.DataFrame( ... { ... "a": ["a", "b", "a", "b", "c"], ... "b": [1, 2, 1, 3, 3], ... "c": [5, 4, 3, 2, 1], ... } ... ) >>> df.group_by("a").agg(pl.col("b"), pl.col("c")) # 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. >>> df.group_by("a").agg(pl.col("b").sum()) # 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. >>> df.group_by("a").agg([pl.sum("b"), pl.mean("c")]) # 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. >>> df.group_by("a").agg( ... pl.sum("b").name.suffix("_sum"), ... (pl.col("c") ** 2).mean().name.suffix("_mean_squared"), ... ) # 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. >>> df.group_by("a").agg( ... b_sum=pl.sum("b"), ... c_mean_squared=(pl.col("c") ** 2).mean(), ... ) # 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 │ └─────┴───────┴────────────────┘ rr%rr() r*r&rr,r-rrrr.r3r4©rÚaggsÚ named_aggsr&s r r.Ú GroupBy.agg‚s€€õR =ð G‰GL‰L‹Nß ‰Xð Ø—w‘wð UØ"&§-¡-ñ UØ@D×@SÑ@Sò Uç ‰Sð àð &à$ñ &÷‰W =×#5Ñ#5Ó#7ˆWÐ 8ð  r#cóX•UR(a Sn[U5e[SUR55(d Sn[U5eURnURR R URRRX1UR55$)u© Apply a custom/user-defined function (UDF) over the groups as a sub-DataFrame. .. warning:: This method is much slower than the native expressions API. Only use it if you cannot implement your logic otherwise. Implementing logic using a Python function is almost always *significantly* slower and more memory intensive than implementing the same logic using the native expression API because: - The native expression engine runs in Rust; UDFs run in Python. - Use of Python UDFs forces the DataFrame to be materialized in memory. - Polars-native expressions can be parallelised (UDFs cannot). - Polars-native expressions can be logically optimised (UDFs cannot). Wherever possible you should strongly prefer the native expression API to achieve the best performance. Parameters ---------- function Custom function that receives a DataFrame and returns a DataFrame. Returns ------- DataFrame 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.group_by("color").map_groups( ... lambda group_df: group_df.sample(2) ... ) # 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.filter( ... pl.int_range(pl.len()).shuffle().over("color") < 2 ... ) # doctest: +IGNORE_RESULT z;cannot call `map_groups` when grouping by named expressionsc3óB# •UHn[U[5v• M g7f©N)Ú isinstanceÚstr)Ú.0Úcs r Ú Ú%GroupBy.map_groups..4sé€Ð7ªw¨!”:˜a¤×%Ð%ªwùs‚z7cannot call `map_groups` when grouping by an expression) rÚ TypeErrorr6rrÚ __class__Ú _from_pydfÚ_dfÚgroup_by_map_groupsr)rÚfunctionÚmsgÚby_strss r Ú map_groupsÚGroupBy.map_groupsôsƒ€ðz ==ØOˆCܘC“.Ð ÜÑ7¨t¯wªwÓ7×7Ñ7ØKˆCܘC“.Ð à!ŸW™Wˆàw‰w× Ñ ×+Ñ+Ø G‰GK‰K× +Ñ +¨G¸t×?RÑ?RÓ Só ð r#cóú•SSKJn URR5R"UR 0UR DSUR0D6RU5RUR5S9$)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 │ └─────────┴─────┘ rr%rr() r*r&rr,r-rrrÚheadr3Ú_eager©rÚnr&s r rhÚ GroupBy.head>sm€õZ =ð G‰GL‰L‹Nß ‰Xð Ø—w‘wð UØ"&§-¡-ñ UØ@D×@SÑ@Sò Uç ‰T!‹Wß ‰W =×#7Ñ#7Ó#9ˆWÐ :ð  r#cóú•SSKJn URR5R"UR 0UR DSUR0D6RU5RUR5S9$)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 │ └─────────┴─────┘ rr%rr() r*r&rr,r-rrrÚtailr3r4rjs r rnÚ GroupBy.tailtsm€õZ =ð G‰GL‰L‹Nß ‰Xð Ø—w‘wð UØ"&§-¡-ñ UØ@D×@SÑ@Sò Uç ‰T!‹Wß ‰W =×#5Ñ#5Ó#7ˆWÐ 8ð  r#cóJ•UR[R"55$)uò Aggregate the groups into Series. Examples -------- >>> df = pl.DataFrame({"a": ["one", "two", "one", "two"], "b": [1, 2, 3, 4]}) >>> df.group_by("a", maintain_order=True).all() shape: (2, 2) ┌─────┬───────────┠│ a ┆ b │ │ --- ┆ --- │ │ str ┆ list[i64] │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•¡ │ one ┆ [1, 3] │ │ two ┆ [2, 4] │ └─────┴───────────┘ )r.r/r6©rs r r6Ú GroupBy.allªs€ð$x‰xœŸš›Ó Ð r#Ncó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 -------- >>> df = pl.DataFrame({"a": ["Apple", "Apple", "Orange"], "b": [1, None, 2]}) >>> df.group_by("a").len() # doctest: +IGNORE_RESULT shape: (2, 2) ┌────────┬─────┠│ a ┆ len │ │ --- ┆ --- │ │ str ┆ u32 │ â•žâ•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ Apple ┆ 2 │ │ Orange ┆ 1 │ └────────┴─────┘ >>> df.group_by("a").len(name="n") # doctest: +IGNORE_RESULT shape: (2, 2) ┌────────┬─────┠│ a ┆ n │ │ --- ┆ --- │ │ str ┆ u32 │ â•žâ•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ Apple ┆ 2 │ │ Orange ┆ 1 │ └────────┴─────┘ )r/rFr2r.)rÚnameÚlen_exprs r rFÚ GroupBy.len¾s3€ôB—5’5“7ˆØ Ñ Ø—~‘~ dÓ+ˆHØx‰x˜Ó!Ð!r#z6`GroupBy.count` was renamed; use `GroupBy.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:`GroupBy.len`. Rows containing null values count towards the total. Examples -------- >>> df = pl.DataFrame( ... { ... "a": ["Apple", "Apple", "Orange"], ... "b": [1, None, 2], ... } ... ) >>> df.group_by("a").count() # doctest: +SKIP shape: (2, 2) ┌────────┬───────┠│ a ┆ count │ │ --- ┆ --- │ │ str ┆ u32 │ â•žâ•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•¡ │ Apple ┆ 2 │ │ Orange ┆ 1 │ └────────┴───────┘ Úcount)r.r/rFr2rqs r rxÚ GroupBy.countäs"€ð:x‰xœŸš›Ÿ ™  gÓ.Ó/Ð/r#cóf•UR[R"5R55$)uš Aggregate the first values in the group. Examples -------- >>> df = 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"], ... } ... ) >>> df.group_by("d", maintain_order=True).first() 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/r6r0rqs r r0Ú GroupBy.firsts€ð4x‰xœŸš›Ÿ ™ ›Ó(Ð(r#cóf•UR[R"5R55$)u˜ Aggregate the last values in the group. Examples -------- >>> df = 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"], ... } ... ) >>> df.group_by("d", maintain_order=True).last() 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/r6Úlastrqs r r}Ú GroupBy.lastó€ð4x‰xœŸš›Ÿ ™ ›Ó'Ð'r#cóf•UR[R"5R55$)uˆ Reduce the groups to the maximal value. Examples -------- >>> df = 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"], ... } ... ) >>> df.group_by("d", maintain_order=True).max() 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/r6Úmaxrqs r rÚ GroupBy.max;ó€ð4x‰xœŸš›Ÿ ™ › Ó&Ð&r#cóf•UR[R"5R55$)uÿ Reduce the groups to the mean values. Examples -------- >>> df = 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"], ... } ... ) >>> df.group_by("d", maintain_order=True).mean() 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/r6Úmeanrqs r r…Ú GroupBy.meanWrr#cóf•UR[R"5R55$)u² Return the median per group. Examples -------- >>> df = 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"], ... } ... ) >>> df.group_by("d", maintain_order=True).median() shape: (2, 3) ┌────────┬─────┬──────┠│ d ┆ a ┆ b │ │ --- ┆ --- ┆ --- │ │ str ┆ f64 ┆ f64 │ â•žâ•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•¡ │ Apple ┆ 2.0 ┆ 4.0 │ │ Banana ┆ 4.0 ┆ 13.0 │ └────────┴─────┴──────┘ )r.r/r6Úmedianrqs r rˆÚGroupBy.medianss €ð0x‰xœŸš›Ÿ™Ó(Ó)Ð)r#cóf•UR[R"5R55$)u— Reduce the groups to the minimal value. Examples -------- >>> df = 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"], ... } ... ) >>> df.group_by("d", maintain_order=True).min() 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/r6Úminrqs r r‹Ú GroupBy.minrƒr#cóf•UR[R"5R55$)u® Count the unique values per group. Examples -------- >>> df = 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"], ... } ... ) >>> df.group_by("d", maintain_order=True).n_unique() shape: (2, 3) ┌────────┬─────┬─────┠│ d ┆ a ┆ b │ │ --- ┆ --- ┆ --- │ │ str ┆ u32 ┆ u32 │ â•žâ•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ Apple ┆ 2 ┆ 2 │ │ Banana ┆ 3 ┆ 3 │ └────────┴─────┴─────┘ )r.r/r6Ún_uniquerqs r rŽÚGroupBy.n_unique©s"€ð0x‰xœŸš›×(Ñ(Ó*Ó+Ð+r#có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 -------- >>> df = 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"], ... } ... ) >>> df.group_by("d", maintain_order=True).quantile(1) 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/r6Úquantile)rr’r‘s r r’ÚGroupBy.quantileÃs(€ðDx‰xœŸš›×(Ñ(¨Ð(ÐOÓPÐPr#cóf•UR[R"5R55$)uo Reduce the groups to the sum. Examples -------- >>> df = 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"], ... } ... ) >>> df.group_by("d", maintain_order=True).sum() 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/r6Úsumrqs r r•Ú GroupBy.sumçrƒr#)r<r;r9rrrr) rr rúIntoExpr | Iterable[IntoExpr]rÚboolrrÚreturnÚNone©r™r)r™z!tuple[tuple[Any, ...], DataFrame]©rQr—rRrr™r )rbú Callable[[DataFrame], DataFrame]r™r )é)rkÚintr™r )r™r rV)rtz str | Noner™r )Únearest)r’Úfloatr‘rr™r )Ú__name__Ú __module__Ú __qualname__Ú__firstlineno__Ú__doc__r!r@rLr.rerhrnr6rFr rxr0r}rr…rˆr‹rŽr’r•Ú__static_attributes__©r#r rr#sõ†Ù)ð-à ð-ð+ð-ðð -ð ð -ð ô -ô>1ôf&ðp à,ðp ððp ð ô p ôdH öT4 öl4 ôl!ö($"ñLÐHÓIó0óJð0ô<)ô8(ô8'ô8(ô8*ô4'ô8,ð6@Ið"QØð"QØ.<ð"Qà õ"Q÷H'r#rcó~•\rSrSrSrS SjrS SjrS SjrS SjrSSjr Sr g )ÚRollingGroupByizy A rolling grouper. This has an `.agg` method which will allow you to run all polars expressions in a group by context. cóx•[U5n[U5nXlX lX0lX@lXPlX`lgrV)rrÚ time_columnÚperiodÚoffsetÚclosedr-)rrÚ index_columnr­r®r¯r-s r r!ÚRollingGroupBy.__init__ s7€ô*¨&Ó1ˆÜ)¨&Ó1ˆàŒØ'ÔØŒ ØŒ ØŒ Ø r#cóf•SSKJn SnURR5R UR UR URURURS9R[R"5R5RU55RUR!5S9nUR#[R$"5R'U55R)5UlUR#U5R-5UlSUlU$)Nrr%r'©r°r­r®r¯r-r()r*r&rr,Úrollingr¬r­r®r¯r-r.r/r0r1r2r3r4r5r6r7r8r9r:r;r<r=s r r@ÚRollingGroupBy.__iter__ sá€Ý<à.ˆà G‰GL‰L‹Nß ‰WØ!×-Ñ-Ø—{‘{Ø—{‘{Ø—{‘{ØŸ™ð ð÷‰S”—’“×%Ñ%Ó'×-Ñ-¨hÓ7Ó 8ß ‰W =×#5Ñ#5Ó#7ˆWÐ 8ð ð&×,Ñ,¬Q¯UªU«W¯_©_¸XÓ-FÓG×QÑQÓSˆÔØ'×.Ñ.¨xÓ8×BÑBÓDˆÔ؈Ôàˆ r#có•UR[UR5:¼a[e[ UR 5nUR URURSS24nU=RS- slX4$rCrErIs r rLÚRollingGroupBy.__next__7rNr#có•SSKJn URR5R UR UR URURURS9R"U0UD6RUR5S9$)á“ 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. rr%r³r() r*r&rr,r´r¬r­r®r¯r-r.r3r4rPs r r.ÚRollingGroupBy.aggAs†€õ$ =ð G‰GL‰L‹Nß ‰WØ!×-Ñ-Ø—{‘{Ø—{‘{Ø—{‘{ØŸ™ð ð÷‰Sð ðð &ð%ñ &÷‰W =×#5Ñ#5Ó#7ˆWÐ 8ð r#có•SSKJn URR5R UR UR URURURS9RX5RUR5S9$)áf Apply a custom/user-defined function (UDF) over the groups as a new DataFrame. 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]).map_elements(lambda struct_series: ..)` Parameters ---------- function Function to apply over each group of the `LazyFrame`; it receives a DataFrame and should return a DataFrame. 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. rr%r³r() r*r&rr,r´r¬r­r®r¯r-rer3r4©rrbÚschemar&s r reÚRollingGroupBy.map_groupsbsp€õ: =ð G‰GL‰L‹Nß ‰WØ!×-Ñ-Ø—{‘{Ø—{‘{Ø—{‘{ØŸ™ð ð÷‰Z˜Ó )ß ‰W =×#5Ñ#5Ó#7ˆWÐ 8ð r#) r<r;r9r¯rr-r®r­r¬N)rr r°rr­ústr | timedeltar®ústr | timedelta | Noner¯r r-ú$IntoExpr | Iterable[IntoExpr] | Noner™ršr›©r™z$tuple[tuple[object, ...], DataFrame]rœ©rbrr¾zSchemaDict | Noner™r © r¢r£r¤r¥r¦r!r@rLr.rer§r¨r#r rªrªs†ñð!à ð!ðð!ð  ð !ð 'ð !ðð!ð7ð!ð ô!ô(ô.&ð à,ð ðð ð ô  ðB* à2ð* ð"ð* ð ÷ * r#rªcóŽ•\rSrSrSrS SjrS SjrS SjrS SjrSSjr Sr g )ÚDynamicGroupByizu A dynamic grouper. This has an `.agg` method which allows you to run all polars expressions in a group by context. có¾•[U5n[U5n[U5nXlX lX0lX@lXPlX€lX`lXplXl X l grV) rrr¬Úeveryr­r®ÚlabelÚinclude_boundariesr¯r-Ústart_by) rrr°rÉr­r®rËr¯rÊr-rÌs r r!ÚDynamicGroupBy.__init__—sV€ô)¨Ó/ˆÜ)¨&Ó1ˆÜ)¨&Ó1ˆàŒØ'ÔØŒ ØŒ ØŒ ØŒ Ø"4ÔØŒ Ø Œ Ø r#c ó¾•SSKJn SnURR5R UR UR URURURURURURURS9 R[R "5R#5R%U55R'UR)5S9nUR+[R,"5R/U55R15UlUR+U5R55UlSUlU$)Nrr%r'© r°rÉr­r®rÊrËr¯r-rÌr()r*r&rr,Úgroup_by_dynamicr¬rÉr­r®rÊrËr¯r-rÌr.r/r0r1r2r3r4r5r6r7r8r9r:r;r<r=s r r@ÚDynamicGroupBy.__iter__´s€Ý<à.ˆà G‰GL‰L‹Nß Ñ Ø!×-Ñ-Ø—j‘jØ—{‘{Ø—{‘{Ø—j‘jØ#'×#:Ñ#:Ø—{‘{ØŸ™ØŸ™ðð ÷‰S”—’“×%Ñ%Ó'×-Ñ-¨hÓ7Ó 8ß ‰W =×#5Ñ#5Ó#7ˆWÐ 8ð ð"&×,Ñ,¬Q¯UªU«W¯_©_¸XÓ-FÓG×QÑQÓSˆÔØ'×.Ñ.¨xÓ8×BÑBÓDˆÔ؈Ôàˆ r#có•UR[UR5:¼a[e[ UR 5nUR URURSS24nU=RS- slX4$rCrErIs r rLÚDynamicGroupBy.__next__ÏrNr#c óv•SSKJn URR5R UR UR URURURURURURURS9 R"U0UD6RUR!5S9$)r¹rr%rÏr()r*r&rr,rÐr¬rÉr­r®rÊrËr¯r-rÌr.r3r4rPs r r.ÚDynamicGroupBy.aggÙs¥€õ$ =ð G‰GL‰L‹Nß Ñ Ø!×-Ñ-Ø—j‘jØ—{‘{Ø—{‘{Ø—j‘jØ#'×#:Ñ#:Ø—{‘{ØŸ™ØŸ™ðð ÷‰Sð ðð &ð%ñ &÷‰W =×#5Ñ#5Ó#7ˆWÐ 8ð r#c ó^•SSKJn URR5R UR UR URURURURURURS9RX5RUR5S9$)r¼rr%)r°rÉr­r®rËr¯r-rÌr()r*r&rr,rÐr¬rÉr­r®rËr¯r-rÌrer3r4r½s r reÚDynamicGroupBy.map_groupsþsˆ€õ: =ð G‰GL‰L‹Nß Ñ Ø!×-Ñ-Ø—j‘jØ—{‘{Ø—{‘{Ø#'×#:Ñ#:Ø—{‘{ØŸ™ØŸ™ðð ÷‰Z˜Ó )ß ‰W =×#5Ñ#5Ó#7ˆWÐ 8ð r#) r<r;r9r¯rrÉr-rËrÊr®r­rÌr¬N)rr r°rrÉrÀr­rÁr®rÁrËr˜r¯r rÊrr-rÂrÌrr™ršr›rÃrœrÄrÅr¨r#r rÇrÇsņñð!à ð!ðð!ð ð !ð 'ð !ð'ð!ð!ð!ðð!ðð!ð7ð!ðð!ð ô!ô:ô6&ð# à,ð# ðð# ð ô # ðJ- à2ð- ð"ð- ð ÷ - r#rÇ)!Ú __future__rÚtypingrrrÚpolarsrr/Úpolars._utils.convertrÚpolars._utils.deprecationr ÚsysÚcollections.abcr Údatetimer r Úpolars._typingr rrrrrÚ version_inforÚtyping_extensionsÚwarningsrrªrÇr¨r#r Úräs€ðÝ"ç/Ñ/å!Ý:Ý0æÛÝ(Ý"å ÷÷ð ×ј7Ó"Þå*à ×ј7Ó"Þ'å0÷^ 'ñ^ '÷BH ñH ÷V\ ò\ r#