Struct GroupBy 

pub struct GroupBy<'a> {
    pub df: &'a DataFrame,
    /* private fields */
}

Available on crate feature algorithm_group_by only.

Returned by a group_by operation on a DataFrame. This struct supports several aggregations.

Until described otherwise, the examples in this struct are performed on the following DataFrame:

use polars_core::prelude::*;

let dates = &[
"2020-08-21",
"2020-08-21",
"2020-08-22",
"2020-08-23",
"2020-08-22",
];
// date format
let fmt = "%Y-%m-%d";
// create date series
let s0 = DateChunked::parse_from_str_slice("date", dates, fmt)
        .into_series();
// create temperature series
let s1 = Series::new("temp".into(), [20, 10, 7, 9, 1]);
// create rain series
let s2 = Series::new("rain".into(), [0.2, 0.1, 0.3, 0.1, 0.01]);
// create a new DataFrame
let df = DataFrame::new_infer_height(vec![s0, s1, s2]).unwrap();
println!("{:?}", df);

Outputs:

+------------+------+------+
| date       | temp | rain |
| ---        | ---  | ---  |
| Date       | i32  | f64  |
+============+======+======+
| 2020-08-21 | 20   | 0.2  |
+------------+------+------+
| 2020-08-21 | 10   | 0.1  |
+------------+------+------+
| 2020-08-22 | 7    | 0.3  |
+------------+------+------+
| 2020-08-23 | 9    | 0.1  |
+------------+------+------+
| 2020-08-22 | 1    | 0.01 |
+------------+------+------+

Fields

df: &'a DataFrame

Implementations

impl<'a> GroupBy<'a>

pub fn new( df: &'a DataFrame, by: Vec<Column>, groups: GroupPositions, selected_agg: Option<Vec<PlSmallStr>>, ) -> GroupBy<'a>

pub fn select<I, S>(self, selection: I) -> GroupBy<'a>

where I: IntoIterator<Item = S>, S: Into<PlSmallStr>,

Select the column(s) that should be aggregated. You can select a single column or a slice of columns.

Note that making a selection with this method is not required. If you skip it all columns (except for the keys) will be selected for aggregation.

pub fn get_groups(&self) -> &GroupPositions

Get the internal representation of the GroupBy operation. The Vec returned contains: (first_idx, Vec<indexes>) Where second value in the tuple is a vector with all matching indexes.

pub unsafe fn get_groups_mut(&mut self) -> &mut GroupPositions

Get the internal representation of the GroupBy operation. The Vec returned contains: (first_idx, Vec<indexes>) Where second value in the tuple is a vector with all matching indexes.

Safety

Groups should always be in bounds of the DataFrame hold by this GroupBy. If you mutate it, you must hold that invariant.

pub fn into_groups(self) -> GroupPositions

pub fn keys_sliced(&self, slice: Option<(i64, usize)>) -> Vec<Column>

pub fn keys(&self) -> Vec<Column>

pub fn count(&self) -> Result<DataFrame, PolarsError>

Aggregate grouped series and compute the number of values per group.

Example

fn example(df: DataFrame) -> PolarsResult<DataFrame> {
    df.group_by(["date"])?.select(["temp"]).count()
}

Returns:

+------------+------------+
| date       | temp_count |
| ---        | ---        |
| Date       | u32        |
+============+============+
| 2020-08-23 | 1          |
+------------+------------+
| 2020-08-22 | 2          |
+------------+------------+
| 2020-08-21 | 2          |
+------------+------------+

pub fn groups(&self) -> Result<DataFrame, PolarsError>

Get the group_by group indexes.

Example

fn example(df: DataFrame) -> PolarsResult<DataFrame> {
    df.group_by(["date"])?.groups()
}

Returns:

+--------------+------------+
| date         | groups     |
| ---          | ---        |
| Date(days)   | list [u32] |
+==============+============+
| 2020-08-23   | "[3]"      |
+--------------+------------+
| 2020-08-22   | "[2, 4]"   |
+--------------+------------+
| 2020-08-21   | "[0, 1]"   |
+--------------+------------+

pub fn apply<F>(&self, f: F) -> Result<DataFrame, PolarsError>

where F: FnMut(DataFrame) -> Result<DataFrame, PolarsError> + Send + Sync,

Apply a closure over the groups as a new DataFrame.

pub fn apply_sliced<F>( &self, slice: Option<(i64, usize)>, f: F, schema: Option<&Arc<Schema<DataType, ()>>>, ) -> Result<DataFrame, PolarsError>

where F: FnMut(DataFrame) -> Result<DataFrame, PolarsError> + Send + Sync,

pub fn sliced(self, slice: Option<(i64, usize)>) -> GroupBy<'a>

Trait Implementations

impl<'a> Clone for GroupBy<'a>

fn clone(&self) -> GroupBy<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for GroupBy<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.