o ¹­§iý°ã@s8ddlmZddlmZddlmZmZddlmZ ddl m Z ddl m Z ddlmZer€ddlZdd lmZmZdd lmZdd lmZdd lmZmZmZmZmZmZdd lmZej dkrhddlm!Z!nddl"m!Z!ej dkrzddl#m Z nddl"m Z Gdd„dƒZ$Gdd„dƒZ%Gdd„dƒZ&ddd„Z'dS) é)Ú annotations)Úchain)Ú TYPE_CHECKINGÚAny)Ú functions)Úparse_as_duration_string)Ú deprecated)Ú_parse_inputs_as_iterableN)ÚCallableÚIterable)Ú timedelta)Ú DataFrame)ÚClosedIntervalÚIntoExprÚLabelÚQuantileMethodÚ SchemaDictÚStartBy)Ú LazyGroupBy)éé )ÚSelf)ré c@seZdZdZdNdd„ZdOdd„ZdPdd„ZdQdd„ZdRdd„ZdSdd„Z dTd!d"„Z dUdVd&d'„Z dUdVd(d)„Z dWd*d+„Z dXdYd/d0„Zed1ƒdWd2d3„ƒZd4d5œdZd7d8„Zd4d5œdZd9d:„ZdWd;d<„ZdWd=d>„ZdWd?d@„ZdWdAdB„ZdWdCdD„Z Ed[d\dJdK„ZdWdLdM„Zd,S)]ÚGroupByzStarts a new GroupBy operation.Údfr ÚbyúIntoExpr | Iterable[IntoExpr]Úmaintain_orderÚboolÚ predicatesúIterable[Any] | NoneÚnamed_byrÚreturnÚNonecOs"||_||_||_||_||_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. predicates Predicate expressions to filter groups after aggregation. **named_by Additional column(s) to group by, specified as keyword arguments. The columns will be named as the keyword used. N)rrr!rr)Úselfrrrrr!©r%úP/home/app/Keep/.python/lib/python3.10/site-packages/polars/dataframe/group_by.pyÚ__init__)s  zGroupBy.__init__rcCs:|j ¡j|ji|j¤d|ji¤Ž}|jr| |j¡S|S)Nr)rÚlazyÚgroup_byrr!rrÚhaving)r$r)r%r%r&Ú_lgbLs ÿÿÿ z GroupBy._lgbrcCs–ddlm}|j ¡|_d}|j ¡ d¡j|ji|j¤d|j i¤Ž  t   ¡  |¡¡j| ¡d}| t  ¡ |¡¡ ¡|_| |¡ ¡|_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_INDICESÚ__POLARS_GB_ROW_INDEXr©Z optimizations)Úpolars.lazyframe.opt_flagsr-rZrechunkr(Úwith_row_indexr)rr!rÚaggÚFÚfirstÚaliasÚcollectÚnoneÚselectÚallÚexcludeÚ iter_rowsÚ _group_namesÚ to_seriesÚ_group_indicesÚ_current_index©r$r-Ztemp_colZ groups_dfr%r%r&Ú__iter__Ts& " þþþüÿzGroupBy.__iter__ú!tuple[tuple[Any, ...], DataFrame]cCóN|jt|jƒkr t‚t|jƒ}|j|j|jdd…f}|jd7_||fS©Né©r@Úlenr?Ú StopIterationÚnextr=r©r$Ú group_nameZ group_datar%r%r&Ú__next__ˆó  zGroupBy.__next__cGs,t|jg|j¢R|jt|j|ƒdœ|j¤ŽS)u( Filter groups with a list of predicates after aggregation. Using this method is equivalent to adding the predicates to the aggregation and filtering afterwards. This method can be chained and all conditions will be combined using `&`. Parameters ---------- *predicates Expressions that evaluate to a boolean value for each group. Typically, this requires the use of an aggregation function. Multiple predicates are combined using `&`. Examples -------- Only keep groups that contain more than one element. >>> df = pl.DataFrame( ... { ... "a": ["a", "b", "a", "b", "c"], ... } ... ) >>> df.group_by("a").having(pl.len() > 1).agg() # doctest: +IGNORE_RESULT shape: (2, 1) ┌─────┠│ a │ │ --- │ │ str │ â•žâ•â•â•â•â•â•¡ │ b │ │ a │ └─────┘ )rr)rrrrÚ_chain_predicatesrr!©r$rr%r%r&r*’s$ÿþ üûzGroupBy.havingÚaggsÚ named_aggscOs,ddlm}| ¡j|i|¤Žj| ¡dS)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,r0)r1r-r+r3r7r8)r$rQrRr-r%r%r&r3¾s gÿÿþÿz GroupBy.aggÚfunctionú Callable[[DataFrame], DataFrame]cCsh|jr d}t|ƒ‚|jrd}t|ƒ‚tdd„|jDƒƒs"d}t|ƒ‚|j}|jj |jj  |||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 úps€z%GroupBy.map_groups..z7cannot call `map_groups` when grouping by an expression) rÚ TypeErrorr!r:rrÚ __class__Z _from_pydfZ_dfZgroup_by_map_groupsr)r$rSÚmsgZby_strsr%r%r&Ú map_groups-s=ÿzGroupBy.map_groupséÚnÚintcCó&ddlm}| ¡ |¡j| ¡dS)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,r0)r1r-r+Úheadr7Z_eager©r$rar-r%r%r&rdzó -z GroupBy.headcCrc)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,r0)r1r-r+Útailr7r8rer%r%r&rg«rfz GroupBy.tailcCs| t ¡¡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] │ └─────┴───────────┘ )r3r4r:©r$r%r%r&r:Üsz GroupBy.allNÚnameú str | NonecCs$t ¡}|dur | |¡}| |¡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 │ └────────┴─────┘ N)r4rHr6r3)r$riZlen_exprr%r%r&rHðs!  z GroupBy.lenz6`GroupBy.count` was renamed; use `GroupBy.len` insteadcCs| t ¡ 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)r3r4rHr6rhr%r%r&rksz GroupBy.countF©Ú ignore_nullsrmcCó| t ¡j|d¡S)u Aggregate the first values in the group. Parameters ---------- ignore_nulls Ignore null values (default `False`). If set to `True`, the first non-null value for each aggregation is returned, otherwise `None` is returned if no non-null value exists. Examples -------- >>> df = pl.DataFrame( ... { ... "a": [1, 2, 2, 3, 4, 5], ... "b": [0.5, 0.5, 4, 10, 13, 14], ... "c": [None, 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 ┆ null │ │ Orange ┆ 2 ┆ 0.5 ┆ true │ │ Banana ┆ 4 ┆ 13.0 ┆ false │ └────────┴─────┴──────┴───────┘ >>> df.group_by("d", maintain_order=True).first(ignore_nulls=True) 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 │ └────────┴─────┴──────┴───────┘ rl)r3r4r:r5©r$rmr%r%r&r55ó,z GroupBy.firstcCrn)uø Aggregate the last values in the group. Parameters ---------- ignore_nulls Ignore null values (default `False`). If set to `True`, the last non-null value for each column is returned, otherwise `None` is returned if no non-null value exists. Examples -------- >>> df = pl.DataFrame( ... { ... "a": [1, 2, 2, 3, 4, 5], ... "b": [0.5, 0.5, 4, 10, 14, None], ... "c": [True, True, True, None, 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 ┆ null │ │ Orange ┆ 2 ┆ 0.5 ┆ true │ │ Banana ┆ 5 ┆ null ┆ true │ └────────┴─────┴──────┴──────┘ >>> df.group_by("d", maintain_order=True).last(ignore_nulls=True) 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 │ └────────┴─────┴──────┴──────┘ rl)r3r4r:Úlastror%r%r&rqcrpz GroupBy.lastcCó| t ¡ ¡¡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 │ └────────┴─────┴──────┴──────┘ )r3r4r:Úmaxrhr%r%r&rs‘óz GroupBy.maxcCrr)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 │ └────────┴─────┴──────────┴──────────┘ )r3r4r:Úmeanrhr%r%r&ru­rtz GroupBy.meancCrr)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 │ └────────┴─────┴──────┘ )r3r4r:Úmedianrhr%r%r&rvÉózGroupBy.mediancCrr)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 │ └────────┴─────┴──────┴───────┘ )r3r4r:Úminrhr%r%r&rxãrtz GroupBy.mincCrr)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 │ └────────┴─────┴─────┘ )r3r4r:Ún_uniquerhr%r%r&ryÿrwzGroupBy.n_uniqueÚnearestÚquantileÚfloatÚ interpolationrcCs| t ¡j||d¡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})r3r4r:r{)r$r{r}r%r%r&r{s"zGroupBy.quantilecCrr)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 │ └────────┴─────┴──────┴─────┘ )r3r4r:Úsumrhr%r%r&r~=rtz GroupBy.sum) rr rrrrrr r!rr"r#)r"r©r"r)r"rC)rrr"r©rQrrRrr"r )rSrTr"r )r`)rarbr"r )r"r rV)rirjr"r )rmrr"r )rz)r{r|r}rr"r )Ú__name__Ú __module__Ú __qualname__Ú__doc__r'r+rBrMr*r3r_rdrgr:rHrrkr5rqrsrurvrxryr{r~r%r%r%r&r&s2  #  4 , o M 1 1 & . .     ÿ$rc@sLeZdZdZd(dd„Zd)dd„Zd*dd„Zd+dd„Zd,dd „Zd-d%d&„Z d'S).Ú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Úclosedrr)ú$IntoExpr | Iterable[IntoExpr] | Nonerr r"r#cCs>t|ƒ}t|ƒ}||_||_||_||_||_||_||_dSrV)rrÚ time_columnr‡r‰r‹r)r)r$rr†r‡r‰r‹r)rr%r%r&r'bs  zRollingGroupBy.__init__rcCsŠddlm}d}|j ¡ d¡j|j|j|j|j |j d  t   ¡ |¡¡j| ¡d}| t  ¡ |¡¡ ¡|_| |¡ ¡|_d|_|S)Nrr,r.r/©r†r‡r‰r‹r)r0)r1r-rr(r2Úrollingrr‡r‰r‹r)r3r4r5r6r7r8r9r:r;r<r=r>r?r@rAr%r%r&rBxs& ù öÿzRollingGroupBy.__iter__ú$tuple[tuple[object, ...], DataFrame]cCrDrErGrKr%r%r&rMrNzRollingGroupBy.__next__rc Gs*t|j|j|j|j|j|jt|j|ƒdS)á Filter groups with a list of predicates after aggregation. Using this method is equivalent to adding the predicates to the aggregation and filtering afterwards. This method can be chained and all conditions will be combined using `&`. Parameters ---------- *predicates Expressions that evaluate to a boolean value for each group. Typically, this requires the use of an aggregation function. Multiple predicates are combined using `&`. )r‡r‰r‹r)r) r…rrr‡r‰r‹r)rOrrPr%r%r&r*šs ùzRollingGroupBy.havingrQrRcOs^ddlm}|j ¡j|j|j|j|j|j d}|j r!|  |j ¡}|j |i|¤Žj | ¡dS)áë 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Žr0)r1r-rr(rrr‡r‰r‹r)rr*r3r7r8©r$rQrRr-r)r%r%r&r3´s  û ÿzRollingGroupBy.aggrSrTÚschemaúSchemaDict | NonecCsVddlm}|jrd}t|ƒ‚|j ¡j|j|j|j |j |j d  ||¡j | ¡dS)áö 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,rUrŽr0)r1r-rr\rr(rrr‡r‰r‹r)r_r7r8©r$rSr”r-r^r%r%r&r_Ös ú÷ÿzRollingGroupBy.map_groupsN)rr r†rr‡rˆr‰rŠr‹rr)rŒrr r"r#r©r"r)rrr"r…r€©rSrTr”r•r"r © rr‚rƒr„r'rBrMr*r3r_r%r%r%r&r…Zs    "r…c@sLeZdZdZd/dd„Zd0dd„Zd1dd „Zd2d"d#„Zd3d&d'„Zd4d,d-„Z d.S)5Ú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_byrrr r"r#c Cs^t|ƒ}t|ƒ}t|ƒ}||_||_||_||_||_||_||_||_| |_ | |_ | |_ dSrV) rrrrœr‡r‰ržrr‹r)rŸr) r$rr†rœr‡r‰rr‹ržr)rŸrr%r%r&r's zDynamicGroupBy.__init__rc Csšddlm}d}|j ¡ d¡j|j|j|j|j |j |j |j |j |jd  t ¡ |¡¡j| ¡d}| t ¡ |¡¡ ¡|_| |¡ ¡|_d|_|S)Nrr,r.r/© r†rœr‡r‰ržrr‹r)rŸr0)r1r-rr(r2Úgroup_by_dynamicrrœr‡r‰ržrr‹r)rŸr3r4r5r6r7r8r9r:r;r<r=r>r?r@rAr%r%r&rB.s. õ òÿzDynamicGroupBy.__iter__rcCrDrErGrKr%r%r&rMJrNzDynamicGroupBy.__next__rcGs:t|j|j|j|j|j|j|j|j|j |j t |j |ƒd S)r‘) rœr‡r‰rr‹ržr)rŸr) r›rrrœr‡r‰rr‹ržr)rŸrOrrPr%r%r&r*Ts õzDynamicGroupBy.havingrQrRc Osnddlm}|j ¡j|j|j|j|j|j |j |j |j |j d }|jr)| |j¡}|j|i|¤Žj| ¡dS)r’rr,r r0)r1r-rr(r¡rrœr‡r‰ržrr‹r)rŸrr*r3r7r8r“r%r%r&r3rs"  ÷ ÿzDynamicGroupBy.aggrSrTr”r•c Csbddlm}|jrd}t|ƒ‚|j ¡j|j|j|j |j |j |j |j |jd ||¡j| ¡dS)r–rr,rU)r†rœr‡r‰rr‹r)rŸr0)r1r-rr\rr(r¡rrœr‡r‰rr‹r)rŸr_r7r8r—r%r%r&r_˜s& ÷ ôÿzDynamicGroupBy.map_groupsN)rr r†rrœrˆr‡rŠr‰rŠrrr‹rržrr)rŒrŸrrr r"r#rr˜)rrr"r›r€r™ršr%r%r%r&r›s    &r›ÚlhsúIterable[IntoExpr] | NoneÚrhsú)tuple[IntoExpr | Iterable[IntoExpr], ...]r"ú Iterable[Any]cCs|dur t|t|ƒƒSt|ƒSrV)rr )r¢r¤r%r%r&rOÌs  ÿÿýrO)r¢r£r¤r¥r"r¦)(Ú __future__rÚ itertoolsrÚtypingrrZpolarsrr4Zpolars._utils.convertrZpolars._utils.deprecationrZpolars._utils.parse.exprr ÚsysÚcollections.abcr r Údatetimer r Zpolars._typingrrrrrrZpolars.lazyframe.group_byrÚ version_inforZtyping_extensionsÚwarningsrr…r›rOr%r%r%r&Ús@             :.F