Struct GroupBy 

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

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 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.