Struct polars_lazy::frame::LazyGroupBy

pub struct LazyGroupBy {
    pub logical_plan: DslPlan,
    /* private fields */
}

Utility struct for lazy group_by operation.

Fields

logical_plan: DslPlan

Implementations

impl LazyGroupBy

pub fn agg<E: AsRef<[Expr]>>(self, aggs: E) -> LazyFrame

Group by and aggregate.

Select a column with col and choose an aggregation. If you want to aggregate all columns use col("*").

Example

use polars_core::prelude::*;
use polars_lazy::prelude::*;
use arrow::legacy::prelude::QuantileInterpolOptions;

fn example(df: DataFrame) -> LazyFrame {
      df.lazy()
       .group_by_stable([col("date")])
       .agg([
           col("rain").min().alias("min_rain"),
           col("rain").sum().alias("sum_rain"),
           col("rain").quantile(lit(0.5), QuantileInterpolOptions::Nearest).alias("median_rain"),
       ])
}

pub fn head(self, n: Option<usize>) -> LazyFrame

Return first n rows of each group

pub fn tail(self, n: Option<usize>) -> LazyFrame

Return last n rows of each group

pub fn apply<F>(self, f: F, schema: SchemaRef) -> LazyFrame

where F: 'static + Fn(DataFrame) -> PolarsResult<DataFrame> + Send + Sync,

Apply a function over the groups as a new DataFrame.

It is not recommended that you use this as materializing the DataFrame is very expensive.

Trait Implementations

impl Clone for LazyGroupBy

fn clone(&self) -> LazyGroupBy

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl From<LazyGroupBy> for LazyFrame

fn from(lgb: LazyGroupBy) -> Self

Converts to this type from the input type.