Ë èË€h—ãó@—ddlmZddlmZmZddlmZddlm Z ddl m Z er^ddl Z ddl mZddlmZdd lmZdd lmZmZmZmZmZmZe j2d k\rdd lmZndd lmZe j2d k\rddlm Z nddlm Z Gd„d«ZGd„d«ZGd„d«Zy)é)Ú annotations)Ú TYPE_CHECKINGÚCallable)Ú functions)Úparse_as_duration_string)Ú deprecatedN)ÚIterable)Ú timedelta)Ú DataFrame)ÚClosedIntervalÚIntoExprÚLabelÚQuantileMethodÚ SchemaDictÚStartBy)éé )ÚSelf)ré cóò—eZdZdZ dd„Zdd„Zdd„Z dd„Zdd„Zddd„Z ddd„Z dd „Z dd d „Z e d «dd „«Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„Z d! d"d„Zdd„Zy )#ÚGroupByzStarts a new GroupBy operation.có<—||_||_||_||_y)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 úu/var/www/html/wine-match-dev/backend/winematch-backend/venv/lib/python3.12/site-packages/polars/dataframe/group_by.pyÚ__init__zGroupBy.__init__&s!€ð4ˆŒØˆŒØ ˆŒ Ø,ˆÕócó„—ddlm}|jj«|_d}|jj «j |j i|j¤d|ji¤Žjtj«j«j|««j|j«¬«}|j!tj"«j%|««j'«|_|j!|«j+«|_d|_|S)u3 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__zGroupBy.__iter__Esñ€õD =à—'‘'—/‘/Ó#ˆŒØ.ˆð ˆDG‰GL‰L‹Nß ‰Xt—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ó—|jt|j«k\rt‚t |j «}|j |j|jdd…f}|xjdz c_||fS©Né©r9Úlenr8Ú StopIterationÚnextr6r©rÚ group_nameÚ group_datas rÚ__next__zGroupBy.__next__xóq€Ø × Ñ ¤# d×&9Ñ&9Ó":Ò :ÜÐ ä˜$×+Ñ+Ó,ˆ Ø—W‘W˜T×0Ñ0°×1DÑ1DÑEÂqÐHÑIˆ Ø ×Ò˜qÑ Õà˜:Ð%Ð%r có—ddlm}|jj«j|j i|j ¤d|ji¤Žj|i|¤Žj|j«¬«S)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+r0r1©rÚaggsÚ named_aggsr#s rr+z GroupBy.agg‚s{€õR =ð ð ˆDG‰GL‰L‹Nß ‰Xt—w‘wð UØ"&§-¡-ñ UØ@D×@SÑ@Sò Uç ‰S$ð &à$ñ &÷‰W =×#5Ñ#5Ó#7ˆWÓ 8ð  r cóT—|jr d}t|«‚td„|jD««s d}t|«‚|jj j |jjjt|j«||j««S)u1 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ó<K—|]}t|t«–—Œy­w©N)Ú isinstanceÚstr)Ú.0Úcs rú z%GroupBy.map_groups..4sèø€Ò7¨!”:˜a¤×%Ñ7ùs‚z7cannot call `map_groups` when grouping by an expression) rÚ TypeErrorr3rrÚ __class__Ú _from_pydfÚ_dfÚgroup_by_map_groupsÚlistr)rÚfunctionÚmsgs rÚ map_groupszGroupBy.map_groupsôs„€ðz =Š=ØOˆCܘC“.Ð ÜÑ7¨t¯w©wÔ7Ô7ØKˆCܘC“.Ð àw‰w× Ñ ×+Ñ+Ø G‰GK‰K× +Ñ +ÜT—W‘W“ ˜x¨×)<Ñ)<ó ó ð r có—ddlm}|jj«j|j i|j ¤d|ji¤Žj|«j|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 │ └─────────┴─────┘ rr"rr%) r'r#rr)r*rrrÚheadr0r1©rÚnr#s rr`z GroupBy.head>ói€õZ =ð ˆDG‰GL‰L‹Nß ‰Xt—w‘wð UØ"&§-¡-ñ UØ@D×@SÑ@Sò Uç ‰T!‹Wß ‰W =×#5Ñ#5Ó#7ˆWÓ 8ð  r có—ddlm}|jj«j|j i|j ¤d|ji¤Žj|«j|j«¬«S)um 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Útailr0r1ras rrez GroupBy.tailtrcr cóH—|jtj««S)uj 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,r3©rs rr3z GroupBy.allªs€ð$x‰xœŸ™›Ó Ð r Ncór—tj«}||j|«}|j|«S)us 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,rBr/r+)rÚnameÚlen_exprs rrBz GroupBy.len¾s3€ôB—5‘5“7ˆØ Ð Ø—~‘~ dÓ+ˆHØx‰x˜Ó!Ð!r z6`GroupBy.count` was renamed; use `GroupBy.len` insteadcóf—|jtj«jd««S)uZ 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,rBr/rgs rrlz GroupBy.countäs"€ð:x‰xœŸ™›Ÿ ™  gÓ.Ó/Ð/r cód—|jtj«j««S)uR 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,r3r-rgs rr-z GroupBy.firsts€ð4x‰xœŸ™›Ÿ ™ ›Ó(Ð(r cód—|jtj«j««S)uP 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,r3Úlastrgs rroz GroupBy.lastó€ð4x‰xœŸ™›Ÿ ™ ›Ó'Ð'r cód—|jtj«j««S)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,r3Úmaxrgs rrrz GroupBy.max;ó€ð4x‰xœŸ™›Ÿ ™ › Ó&Ð&r cód—|jtj«j««S)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,r3Úmeanrgs rruz GroupBy.meanWrpr cód—|jtj«j««S)uZ 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,r3Úmedianrgs rrwzGroupBy.medianss €ð0x‰xœŸ™›Ÿ™Ó(Ó)Ð)r cód—|jtj«j««S)uO 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,r3Úminrgs rryz GroupBy.minrsr cód—|jtj«j««S)uV 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,r3Ún_uniquergs rr{zGroupBy.n_unique©s"€ð0x‰xœŸ™›×(Ñ(Ó*Ó+Ð+r cój—|jtj«j||¬««S)ui 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,r3Úquantile)rr~r}s rr~zGroupBy.quantileÃs*€ðDx‰xœŸ™›×(Ñ(¨ÀÐ(ÓOÓPÐPr cód—|jtj«j««S)u' 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,r3Úsumrgs rr€z GroupBy.sumçrsr ) rr rúIntoExpr | Iterable[IntoExpr]rÚboolrr ÚreturnÚNone©rƒr©rƒz$tuple[tuple[object, ...], DataFrame]©rLrrMr rƒr )r\ú Callable[[DataFrame], DataFrame]rƒr )é)rbÚintrƒr )rƒr rP)riz str | Nonerƒr )Únearest)r~Úfloatr}rrƒr )Ú__name__Ú __module__Ú __qualname__Ú__doc__rr=rHr+r^r`rer3rBrrlr-rorrrurwryr{r~r€©r rrr#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ól—eZdZdZ dd„Zd d„Zd d„Z d d„Z d d„Zy) ÚRollingGroupByz‰ A rolling grouper. This has an `.agg` method which will allow you to run all polars expressions in a group by context. có„—t|«}t|«}||_||_||_||_||_||_yrP)rrÚ time_columnÚperiodÚoffsetÚclosedr*)rrÚ index_columnr–r—r˜r*s rrzRollingGroupBy.__init__ sC€ô*¨&Ó1ˆÜ)¨&Ó1ˆàˆŒØ'ˆÔ؈Œ ؈Œ ؈Œ Ø ˆ r cón—ddlm}d}|jj«j |j |j |j|j|j¬«jtj«j«j|««j|j!«¬«}|j#tj$«j'|««j)«|_|j#|«j-«|_d|_|S)Nrr"r$©r™r–r—r˜r*r%)r'r#rr)Úrollingr•r–r—r˜r*r+r,r-r.r/r0r1r2r3r4r5r6r7r8r9r:s rr=zRollingGroupBy.__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ó—|jt|j«k\rt‚t |j «}|j |j|jdd…f}|xjdz c_||fSr?rArEs rrHzRollingGroupBy.__next__7rIr có*—ddlm}|jj«j |j |j |j|j|j¬«j|i|¤Žj|j«¬«S)áë 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+r0r1rKs rr+zRollingGroupBy.aggAs€€õ$ =ð ˆDG‰GL‰L‹Nß ‰WØ!×-Ñ-Ø—{‘{Ø—{‘{Ø—{‘{ØŸ™ð ó÷‰S$ð &ð%ñ &÷‰W =×#5Ñ#5Ó#7ˆWÓ 8ð r có*—ddlm}|jj«j |j |j |j|j|j¬«j||«j|j«¬«S)áö 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*r^r0r1©rr\Úschemar#s rr^zRollingGroupBy.map_groupsbsr€õ: =ð G‰GL‰L‹Nß ‰WØ!×-Ñ-Ø—{‘{Ø—{‘{Ø—{‘{ØŸ™ð ó÷‰Z˜ &Ó )ß ‰W =×#5Ñ#5Ó#7ˆWÓ 8ð r N)rr r™r r–ústr | timedeltar—ústr | timedelta | Noner˜r r*ú$IntoExpr | Iterable[IntoExpr] | Nonerƒr„r…r†r‡©r\rˆr£zSchemaDict | Nonerƒr © rrŽrrrr=rHr+r^r‘r rr“r“s„ñð!à ð!ðð!ð  ð !ð 'ð !ðð!ð7ð!ð ó!ó(ó.&ð à,ð ðð ð ó  ðB* à2ð* ð"ð* ð ô * r r“có|—eZdZdZ dd„Zd d„Zd d„Z d d„Z d d„Zy) ÚDynamicGroupByz… A dynamic grouper. This has an `.agg` method which allows you to run all polars expressions in a group by context. cóÒ—t|«}t|«}t|«}||_||_||_||_||_||_||_||_| |_ | |_ yrP) rrr•Úeveryr–r—ÚlabelÚinclude_boundariesr˜r*Ústart_by) rrr™r¬r–r—r®r˜r­r*r¯s rrzDynamicGroupBy.__init__—sj€ô)¨Ó/ˆÜ)¨&Ó1ˆÜ)¨&Ó1ˆàˆŒØ'ˆÔ؈Œ ؈Œ ؈Œ ؈Œ Ø"4ˆÔ؈Œ Ø ˆŒ Ø ˆ r c óÆ—ddlm}d}|jj«j |j |j |j|j|j|j|j|j|j¬« jtj «j#«j%|««j'|j)«¬«}|j+tj,«j/|««j1«|_|j+|«j5«|_d|_|S)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,r-r.r/r0r1r2r3r4r5r6r7r8r9r:s rr=zDynamicGroupBy.__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ó—|jt|j«k\rt‚t |j «}|j |j|jdd…f}|xjdz c_||fSr?rArEs rrHzDynamicGroupBy.__next__ÏrIr c ó‚—ddlm}|jj«j |j |j |j|j|j|j|j|j|j¬« j|i|¤Žj|j!«¬«S)rŸrr"r±r%)r'r#rr)r²r•r¬r–r—r­r®r˜r*r¯r+r0r1rKs rr+zDynamicGroupBy.aggÙsŸ€õ$ =ð ˆDG‰GL‰L‹Nß Ñ Ø!×-Ñ-Ø—j‘jØ—{‘{Ø—{‘{Ø—j‘jØ#'×#:Ñ#:Ø—{‘{ØŸ™ØŸ™ðó ÷‰S$ð &ð%ñ &÷‰W =×#5Ñ#5Ó#7ˆWÓ 8ð r c ól—ddlm}|jj«j |j |j |j|j|j|j|j|j¬«j||«j|j«¬«S)r¡rr")r™r¬r–r—r®r˜r*r¯r%)r'r#rr)r²r•r¬r–r—r®r˜r*r¯r^r0r1r¢s rr^zDynamicGroupBy.map_groupsþsŠ€õ: =ð G‰GL‰L‹Nß Ñ Ø!×-Ñ-Ø—j‘jØ—{‘{Ø—{‘{Ø#'×#:Ñ#:Ø—{‘{ØŸ™ØŸ™ðó ÷‰Z˜ &Ó )ß ‰W =×#5Ñ#5Ó#7ˆWÓ 8ð r N)rr r™r r¬r¤r–r¥r—r¥r®r‚r˜r r­rr*r¦r¯rrƒr„r…r†r‡r§r¨r‘r rrªrªsÅ„ñð!à ð!ðð!ð ð !ð 'ð !ð'ð!ð!ð!ðð!ðð!ð7ð!ðð!ð ó!ó:ó6&ð# à,ð# ðð# ð ó # ðJ- à2ð- ð"ð- ð ô - r rª) Ú __future__rÚtypingrrÚpolarsrr,Úpolars._utils.convertrÚpolars._utils.deprecationrÚsysÚcollections.abcr Údatetimer r Úpolars._typingr r rrrrÚ version_inforÚtyping_extensionsÚwarningsrr“rªr‘r rúrÂs}ðÝ"ç*å!Ý:Ý0áÛÝ(Ý"å ÷÷ð ×ј7Ò"Þå*à ×ј7Ò"Þ'å0÷^ 'ñ^ '÷BH ñH ÷V\ ò\ r