§ q-Ph—ãóD—ddlmZddlmZmZddlmZddlm Z ddl m Z erVddl Z ddl mZddlmZdd lmZdd lmZmZmZmZmZmZe jd krdd lmZndd lmZe jd krddlm Z nddlm Z Gd„d¦«ZGd„d¦«ZGd„d¦«ZdS)é)Ú annotations)Ú TYPE_CHECKINGÚCallable)Ú functions)Úparse_as_duration_string)Ú deprecatedN)ÚIterable)Ú timedelta)Ú DataFrame)ÚClosedIntervalÚIntoExprÚLabelÚQuantileMethodÚ SchemaDictÚStartBy)éé )ÚSelf)ré cóÖ—eZdZdZd1d „Zd2d„Zd3d„Zd4d„Zd5d„Zd6d7d„Z d6d7d„Z d8d„Z d9d:d „Z e d!¦«d8d"„¦«Zd8d#„Zd8d$„Zd8d%„Zd8d&„Zd8d'„Zd8d(„Zd8d)„Z d;d—||_||_||_||_dS)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)rrrr)Úselfrrrrs úY/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/polars/dataframe/group_by.pyÚ__init__zGroupBy.__init__&s'€ð4ˆŒØˆŒØ ˆŒ Ø,ˆÔÐÐórcó¤—ddlm}|j ¦«|_d}|j ¦«j|ji|j¤d|ji¤Ž  tj ¦«  ¦«  |¦«¦« | ¦«¬¦«}| tj¦« |¦«¦« ¦«|_| |¦« ¦«|_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©r!r'Útemp_colÚ groups_dfs r"Ú__iter__zGroupBy.__iter__Es(€ðD =Ð<Ð<Ð<Ð<Ð<à”'—/’/Ñ#Ô#ˆŒØ.ˆð ˆDŒGLŠL‰NŒNÜ t”wð UØ"&¤-ð Uð UØ@DÔ@Sð Uð Uð Uç ŠS•”‘”×%Ò%Ñ'Ô'×-Ò-¨hÑ7Ô7Ñ 8Ô 8ß ŠW =×#5Ò#5Ñ#7Ô#7ˆWÑ 8Ô 8ð ð&×,Ò,­Q¬U©W¬W¯_ª_¸XÑ-FÔ-FÑGÔG×QÒQÑSÔSˆÔØ'×.Ò.¨xÑ8Ô8×BÒBÑDÔDˆÔ؈Ôàˆ r$ú$tuple[tuple[object, ...], DataFrame]cóÜ—|jt|j¦«krt‚t |j¦«}|j|j|jdd…f}|xjdz c_||fS©Né©r=Úlenr<Ú StopIterationÚnextr:r©r!Ú group_nameÚ group_datas r"Ú__next__zGroupBy.__next__xóp€Ø Ô ¥# dÔ&9Ñ":Ô":Ò :Ð :ÝÐ å˜$Ô+Ñ,Ô,ˆ Ø”W˜TÔ0°Ô1DÔEÀqÀqÀqÐHÔIˆ Ø ÐÔ˜qÑ ÐÔà˜:Ð%Ð%r$ÚaggsÚ named_aggscóÞ—ddlm}|j ¦«j|ji|j¤d|ji¤Žj|i|¤Ž  |  ¦«¬¦«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/r4r5©r!rOrPr's r"r/z GroupBy.agg‚sœ€ðR =Ð<Ð<Ð<Ð<Ð<ð ð ˆDŒGLŠL‰NŒNÜ t”wð UØ"&¤-ð Uð UØ@DÔ@Sð Uð Uð Uä $ð &à$ð &ð &÷ŠW =×#5Ò#5Ñ#7Ô#7ˆWÑ 8Ô 8ð  r$Úfunctionú Callable[[DataFrame], DataFrame]có:—|jrd}t|¦«‚td„|jD¦«¦«sd}t|¦«‚|jj |jj t|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¦«V—ŒdS©N)Ú isinstanceÚstr)Ú.0Úcs r"ú z%GroupBy.map_groups..4s,èè€Ð7Ð7¨!•:˜a¥Ñ%Ô%Ð7Ð7Ð7Ð7Ð7Ð7r$z7cannot call `map_groups` when grouping by an expression) rÚ TypeErrorr7rrÚ __class__Ú _from_pydfÚ_dfÚgroup_by_map_groupsÚlistr)r!rSÚmsgs r"Ú map_groupszGroupBy.map_groupsôs˜€ðz Œ=ð !ØOˆCݘC‘.”.Ð ÝÐ7Ð7¨t¬wÐ7Ñ7Ô7Ñ7Ô7ð !ØKˆCݘC‘.”.Ð àŒwÔ ×+Ò+Ø ŒGŒK× +Ò +ÝT”W‘ ” ˜x¨Ô)<ñ ô ñ ô ð r$éÚnÚintcóî—ddlm}|j ¦«j|ji|j¤d|ji¤Ž |¦«  |  ¦«¬¦«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Úheadr4r5©r!rfr's r"riz GroupBy.head>ó‰€ðZ =Ð<Ð<Ð<Ð<Ð<ð ˆDŒGLŠL‰NŒNÜ t”wð UØ"&¤-ð Uð UØ@DÔ@Sð Uð Uð Uç ŠT!‰WŒWß ŠW =×#5Ò#5Ñ#7Ô#7ˆWÑ 8Ô 8ð  r$cóî—ddlm}|j ¦«j|ji|j¤d|ji¤Ž |¦«  |  ¦«¬¦«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Útailr4r5rjs r"rmz GroupBy.tailtrkr$cóN—| tj¦«¦«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/r0r7©r!s r"r7z GroupBy.allªs€ð$xŠxœ™œÑ Ô Ð r$NÚnameú str | Nonecó€—tj¦«}|| |¦«}| |¦«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 │ └────────┴─────┘ )r0rGr3r/)r!rpÚlen_exprs r"rGz GroupBy.len¾s9€õB”5‘7”7ˆØ Ð Ø—~’~ dÑ+Ô+ˆHØxŠx˜Ñ!Ô!Ð!r$z6`GroupBy.count` was renamed; use `GroupBy.len` insteadcót—| tj¦« d¦«¦«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/r0rGr3ros r"ruz GroupBy.countäs(€ð:xŠxœ™œŸ š  gÑ.Ô.Ñ/Ô/Ð/r$cór—| tj¦« ¦«¦«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/r0r7r1ros r"r1z GroupBy.firsts$€ð4xŠxœ™œŸ š ™œÑ(Ô(Ð(r$cór—| tj¦« ¦«¦«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/r0r7Úlastros r"rxz GroupBy.lastó$€ð4xŠxœ™œŸ š ™œÑ'Ô'Ð'r$cór—| tj¦« ¦«¦«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/r0r7Úmaxros r"r{z GroupBy.max;ó$€ð4xŠxœ™œŸ š ™ œ Ñ&Ô&Ð&r$cór—| tj¦« ¦«¦«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/r0r7Úmeanros r"r~z GroupBy.meanWryr$cór—| tj¦« ¦«¦«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/r0r7Úmedianros r"r€zGroupBy.medianss&€ð0xŠxœ™œŸšÑ(Ô(Ñ)Ô)Ð)r$cór—| tj¦« ¦«¦«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/r0r7Úminros r"r‚z GroupBy.minr|r$cór—| tj¦« ¦«¦«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/r0r7Ún_uniqueros r"r„zGroupBy.n_unique©s(€ð0xŠxœ™œ×(Ò(Ñ*Ô*Ñ+Ô+Ð+r$ÚnearestÚquantileÚfloatÚ interpolationrcóx—| tj¦« ||¬¦«¦«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 │ └────────┴─────┴──────┘ )rˆ)r/r0r7r†)r!r†rˆs r"r†zGroupBy.quantileÃs0€ðDxŠxœ™œ×(Ò(¨ÀÐ(ÑOÔOÑPÔPÐPr$cór—| tj¦« ¦«¦«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/r0r7Úsumros r"r‹z GroupBy.sumçr|r$) rr rrrrrr rr©rr©rrB©rOrrPr rr )rSrTrr )re)rfrgrr )rr rW)rprqrr )r…)r†r‡rˆrrr )Ú__name__Ú __module__Ú __qualname__Ú__doc__r#rArMr/rdrirmr7rGrrur1rxr{r~r€r‚r„r†r‹©r$r"rr#sÞ€€€€€Ø)Ð)ð-ð-ð-ð-ð>1ð1ð1ð1ðf&ð&ð&ð&ðp ðp ðp ðp ðdH ðH ðH ðH ðT4 ð4 ð4 ð4 ð4 ðl4 ð4 ð4 ð4 ð4 ðl!ð!ð!ð!ð($"ð$"ð$"ð$"ð$"ðL€ZÐHÑIÔIð0ð0ð0ñJÔIð0ð<)ð)ð)ð)ð8(ð(ð(ð(ð8'ð'ð'ð'ð8(ð(ð(ð(ð8*ð*ð*ð*ð4'ð'ð'ð'ð8,ð,ð,ð,ð6@Ið"Qð"Qð"Qð"Qð"QðH'ð'ð'ð'ð'ð'r$rcó:—eZdZdZdd„Zd d„Zd!d„Zd"d„Zd#d„ZdS)$ÚRollingGroupByz‰ A rolling grouper. This has an `.agg` method which will allow you to run all polars expressions in a group by context. rr Ú index_columnr Úperiodústr | timedeltaÚoffsetústr | timedelta | NoneÚclosedr r.ú$IntoExpr | Iterable[IntoExpr] | Nonerrcó–—t|¦«}t|¦«}||_||_||_||_||_||_dSrW)rrÚ time_columnr—r™r›r.)r!rr–r—r™r›r.s r"r#zRollingGroupBy.__init__ sM€õ*¨&Ñ1Ô1ˆÝ)¨&Ñ1Ô1ˆàˆŒØ'ˆÔ؈Œ ؈Œ ؈Œ Ø ˆŒ ˆ ˆ r$rcóŽ—ddlm}d}|j ¦« |j|j|j|j|j ¬¦«  tj ¦«  ¦« |¦«¦« | ¦«¬¦«}| tj¦« |¦«¦« ¦«|_| |¦« ¦«|_d|_|S)Nrr&r(©r–r—r™r›r.r))r+r'rr-Úrollingržr—r™r›r.r/r0r1r2r3r4r5r6r7r8r9r:r;r<r=r>s r"rAzRollingGroupBy.__iter__ s€Ø<Ð<Ð<Ð<Ð<Ð<à.ˆà ŒGLŠL‰NŒNß ŠWØ!Ô-Ø”{Ø”{Ø”{Øœð ñô÷ŠS•”‘”×%Ò%Ñ'Ô'×-Ò-¨hÑ7Ô7Ñ 8Ô 8ß ŠW =×#5Ò#5Ñ#7Ô#7ˆWÑ 8Ô 8ð ð&×,Ò,­Q¬U©W¬W¯_ª_¸XÑ-FÔ-FÑGÔG×QÒQÑSÔSˆÔØ'×.Ò.¨xÑ8Ô8×BÒBÑDÔDˆÔ؈Ôàˆ r$rBcóÜ—|jt|j¦«krt‚t |j¦«}|j|j|jdd…f}|xjdz c_||fSrDrFrJs r"rMzRollingGroupBy.__next__7rNr$rOrrPcó—ddlm}|j ¦« |j|j|j|j|j ¬¦«j |i|¤Ž  |  ¦«¬¦«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/r4r5rRs r"r/zRollingGroupBy.aggAs’€ð$ =Ð<Ð<Ð<Ð<Ð<ð ˆDŒGLŠL‰NŒNß ŠWØ!Ô-Ø”{Ø”{Ø”{Øœð ñôô$ð &ð%ð &ð &÷ŠW =×#5Ò#5Ñ#7Ô#7ˆWÑ 8Ô 8ð r$rSrTÚschemaúSchemaDict | Nonecó—ddlm}|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.rdr4r5©r!rSr¥r's r"rdzRollingGroupBy.map_groupsbs„€ð: =Ð<Ð<Ð<Ð<Ð<ð ŒGLŠL‰NŒNß ŠWØ!Ô-Ø”{Ø”{Ø”{Øœð ñô÷ŠZ˜ &Ñ )Ô )ß ŠW =×#5Ò#5Ñ#7Ô#7ˆWÑ 8Ô 8ð r$N)rr r–r r—r˜r™ršr›r r.rœrrrŒrrŽ©rSrTr¥r¦rr © rrr‘r’r#rArMr/rdr“r$r"r•r•sƒ€€€€€ððð!ð!ð!ð!ð(ðððð.&ð&ð&ð&ð ð ð ð ðB* ð* ð* ð* ð* ð* r$r•có:—eZdZdZd&d„Zd'd„Zd(d„Zd)d„Zd*d$„Zd%S)+ÚDynamicGroupByz… A dynamic grouper. This has an `.agg` method which allows you to run all polars expressions in a group by context. rr r–r Úeveryr˜r—ršr™Úinclude_boundariesrr›r Úlabelrr.rœÚstart_byrrrcóì—t|¦«}t|¦«}t|¦«}||_||_||_||_||_||_||_||_| |_ | |_ dSrW) rrržr®r—r™r°r¯r›r.r±) r!rr–r®r—r™r¯r›r°r.r±s r"r#zDynamicGroupBy.__init__—sw€õ)¨Ñ/Ô/ˆÝ)¨&Ñ1Ô1ˆÝ)¨&Ñ1Ô1ˆàˆŒØ'ˆÔ؈Œ ؈Œ ؈Œ ؈Œ Ø"4ˆÔ؈Œ Ø ˆŒ Ø ˆŒ ˆ ˆ r$rc ó¾—ddlm}d}|j ¦« |j|j|j|j|j |j |j |j |j ¬¦ «  tj¦« ¦« |¦«¦« | ¦«¬¦«}| tj¦« |¦«¦« ¦«|_| |¦« ¦«|_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/r0r1r2r3r4r5r6r7r8r9r:r;r<r=r>s r"rAzDynamicGroupBy.__iter__´s€Ø<Ð<Ð<Ð<Ð<Ð<à.ˆà ŒGLŠL‰NŒNß Ò Ø!Ô-Ø”jØ”{Ø”{Ø”jØ#'Ô#:Ø”{؜؜ðñ ô ÷ŠS•”‘”×%Ò%Ñ'Ô'×-Ò-¨hÑ7Ô7Ñ 8Ô 8ß ŠW =×#5Ò#5Ñ#7Ô#7ˆWÑ 8Ô 8ð ð"&×,Ò,­Q¬U©W¬W¯_ª_¸XÑ-FÔ-FÑGÔG×QÒQÑSÔSˆÔØ'×.Ò.¨xÑ8Ô8×BÒBÑDÔDˆÔ؈Ôàˆ r$rBcóÜ—|jt|j¦«krt‚t |j¦«}|j|j|jdd…f}|xjdz c_||fSrDrFrJs r"rMzDynamicGroupBy.__next__ÏrNr$rOrrPc ó4—ddlm}|j ¦« |j|j|j|j|j |j |j |j |j ¬¦ « j|i|¤Ž | ¦«¬¦«S)r¤rr&r´r))r+r'rr-rµržr®r—r™r°r¯r›r.r±r/r4r5rRs r"r/zDynamicGroupBy.aggÙs¨€ð$ =Ð<Ð<Ð<Ð<Ð<ð ˆDŒGLŠL‰NŒNß Ò Ø!Ô-Ø”jØ”{Ø”{Ø”jØ#'Ô#:Ø”{؜؜ðñ ô ô$ð &ð%ð &ð &÷ŠW =×#5Ò#5Ñ#7Ô#7ˆWÑ 8Ô 8ð r$rSrTr¥r¦c ó:—ddlm}|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±rdr4r5r©s r"rdzDynamicGroupBy.map_groupsþs•€ð: =Ð<Ð<Ð<Ð<Ð<ð ŒGLŠL‰NŒNß Ò Ø!Ô-Ø”jØ”{Ø”{Ø#'Ô#:Ø”{؜؜ðñ ô ÷ŠZ˜ &Ñ )Ô )ß ŠW =×#5Ò#5Ñ#7Ô#7ˆWÑ 8Ô 8ð r$N)rr r–r r®r˜r—ršr™ršr¯rr›r r°rr.rœr±rrrrŒrrŽrªr«r“r$r"r­r­sƒ€€€€€ððð!ð!ð!ð!ð:ðððð6&ð&ð&ð&ð# ð# ð# ð# ðJ- ð- ð- ð- ð- ð- r$r­) Ú __future__rÚtypingrrÚpolarsrr0Ú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Ð0Ð0Ð0Ð0Ð0àð1Ø€J€J€JØ(Ð(Ð(Ð(Ð(Ð(Ø"Ð"Ð"Ð"Ð"Ð"à Ð Ð Ð Ð Ð ððððððððððððððððð Ô˜7Ò"Ð"ØÐÐÐÐÐÐà*Ð*Ð*Ð*Ð*Ð*à Ô˜7Ò"Ð"Ø'Ð'Ð'Ð'Ð'Ð'Ð'à0Ð0Ð0Ð0Ð0Ð0ð^ 'ð^ 'ð^ 'ð^ 'ð^ 'ñ^ 'ô^ 'ð^ 'ðBH ðH ðH ðH ðH ñH ôH ðH ðV\ ð\ ð\ ð\ ð\ ñ\ ô\ ð\ ð\ ð\ r$