Struct polars::frame::DataFrame

pub struct DataFrame { /* fields omitted */ }

Implementations

impl DataFrame

pub fn groupby(&self, by: &str) -> Result<GroupBy>

Group DataFrame using a Series column.

Example

use polars::prelude::*;
fn groupby_sum(df: &DataFrame) -> Result<DataFrame> {
    df.groupby("column_name")?
    .select("agg_column_name")
    .sum()
}

impl DataFrame

pub fn inner_join(
    &self,
    other: &DataFrame,
    left_on: &str,
    right_on: &str
) -> Result<DataFrame>

Perform an inner join on two DataFrames.

Example

use polars::prelude::*;
fn join_dfs(left: &DataFrame, right: &DataFrame) -> Result<DataFrame> {
    left.inner_join(right, "join_column_left", "join_column_right")
}

pub fn left_join(
    &self,
    other: &DataFrame,
    left_on: &str,
    right_on: &str
) -> Result<DataFrame>

Perform a left join on two DataFrames

Example

use polars::prelude::*;
fn join_dfs(left: &DataFrame, right: &DataFrame) -> Result<DataFrame> {
    left.left_join(right, "join_column_left", "join_column_right")
}

pub fn outer_join(
    &self,
    other: &DataFrame,
    left_on: &str,
    right_on: &str
) -> Result<DataFrame>

Perform an outer join on two DataFrames

Example

use polars::prelude::*;
fn join_dfs(left: &DataFrame, right: &DataFrame) -> Result<DataFrame> {
    left.outer_join(right, "join_column_left", "join_column_right")
}

impl DataFrame

pub fn new(columns: Vec<Series>) -> Result<Self>

Create a DataFrame from a Vector of Series.

Example

use polars::prelude::*;
let s0 = Series::new("days", [0, 1, 2].as_ref());
let s1 = Series::new("temp", [22.1, 19.9, 7.].as_ref());
let df = DataFrame::new(vec![s0, s1]).unwrap();

pub fn schema(&self) -> &Arc<Schema>

Get a reference to the DataFrame schema.

pub fn get_columns(&self) -> &Vec<Series>

Get a reference to the DataFrame columns.

pub fn columns(&self) -> Vec<&str>

Get the column labels of the DataFrame.

pub fn n_chunks(&self) -> Result<usize>

The number of chunks per column

pub fn fields(&self) -> &Vec<Field>

Get a reference the schema fields of the DataFrame.

pub fn shape(&self) -> (usize, usize)

Get (width x height)

Example

use polars::prelude::*;
fn assert_shape(df: &DataFrame, shape: (usize, usize)) {
    assert_eq!(df.shape(), shape)
}

pub fn width(&self) -> usize

Get width of DataFrame

Example

use polars::prelude::*;
fn assert_width(df: &DataFrame, width: usize) {
    assert_eq!(df.width(), width)
}

pub fn height(&self) -> usize

Get height of DataFrame

Example

use polars::prelude::*;
fn assert_height(df: &DataFrame, height: usize) {
    assert_eq!(df.height(), height)
}

pub fn hstack(&mut self, columns: &[Series]) -> Result<()>

Add series column to DataFrame

Example

use polars::prelude::*;
fn stack(df: &mut DataFrame, columns: &[Series]) {
    df.hstack(columns);
}

pub fn drop_in_place(&mut self, name: &str) -> Result<Series>

Remove column by name

Example

use polars::prelude::*;
fn drop_column(df: &mut DataFrame, name: &str) -> Result<Series> {
    df.drop_in_place(name)
}

pub fn drop(&self, name: &str) -> Result<DataFrame>

Drop a column by name. This is a pure method and will return a new DataFrame instead of modifying the current one in place.

pub fn get(&self, idx: usize) -> Option<Vec<AnyType>>

Get a row in the dataframe. Beware this is slow.

Example

use polars::prelude::*;
fn example(df: &mut DataFrame, idx: usize) -> Option<Vec<AnyType>> {
    df.get(idx)
}

pub fn select_idx(&self, idx: usize) -> Option<&Series>

Select a series by index.

pub fn f_select_idx(&self, idx: usize) -> &Series

Force select.

pub fn select_idx_mut(&mut self, idx: usize) -> Option<&mut Series>

Select a mutable series by index.

pub fn f_select_idx_mut(&mut self, idx: usize) -> &mut Series

Force select.

pub fn find_idx_by_name(&self, name: &str) -> Option<usize>

Get column index of a series by name.

pub fn column(&self, name: &str) -> Option<&Series>

Select a single column by name.

pub fn f_column(&self, name: &str) -> &Series

Force select a single column.

pub fn select<'a, S>(&self, selection: S) -> Result<DataFrame> where
    S: Selection<'a>, 

Select column(s) from this DataFrame.

Examples

use polars::prelude::*;

fn example(df: &DataFrame, possible: &str) -> Result<DataFrame> {
    match possible {
        "by_str" => df.select("my-column"),
        "by_tuple" => df.select(("col_1", "col_2")),
        "by_vec" => df.select(vec!["col_a", "col_b"]),
         _ => unimplemented!()
    }
}

pub fn select_mut(&mut self, name: &str) -> Option<&mut Series>

Select a mutable series by name.

pub fn f_select_mut(&mut self, name: &str) -> &mut Series

Force select.

pub fn filter(&self, mask: &BooleanChunked) -> Result<Self>

Take DataFrame rows by a boolean mask.

pub fn f_filter(&self, mask: &BooleanChunked) -> Self

Force filter

pub fn take_iter<I>(&self, iter: I, capacity: Option<usize>) -> Result<Self> where
    I: Iterator<Item = usize> + Clone + Sync, 

Take DataFrame value by indexes from an iterator.

Example

use polars::prelude::*;
fn example(df: &DataFrame) -> Result<DataFrame> {
    let iterator = (0..9).into_iter();
    df.take_iter(iterator, None)
}

pub fn take_opt_iter<I>(&self, iter: I, capacity: Option<usize>) -> Result<Self> where
    I: Iterator<Item = Option<usize>> + Clone + Sync, 

pub fn take<T: TakeIndex + Sync>(&self, indices: &T) -> Result<Self>

Take DataFrame rows by index values.

Example

use polars::prelude::*;
fn example(df: &DataFrame) -> Result<DataFrame> {
    let idx = vec![0, 1, 9];
    df.take(&idx)
}

pub fn f_take<T: TakeIndex + Sync>(&self, indices: &T) -> Self

Force take

pub fn rename(&mut self, column: &str, name: &str) -> Result<()>

Rename a column in the DataFrame

Example

use polars::prelude::*;
fn example(df: &mut DataFrame) -> Result<()> {
    let original_name = "foo";
    let new_name = "bar";
    df.rename(original_name, new_name)
}

pub fn sort_in_place(&mut self, by_column: &str, reverse: bool) -> Result<()>

Sort DataFrame in place by a column.

pub fn sort(&self, by_column: &str, reverse: bool) -> Result<Self>

pub fn replace(&mut self, column: &str, new_col: Series) -> Result<()>

Replace a column with a series.

pub fn slice(&self, offset: usize, length: usize) -> Result<Self>

Slice the DataFrame along the rows.

pub fn head(&self, length: Option<usize>) -> Self

Get the head of the DataFrame

pub fn tail(&self, length: Option<usize>) -> Self

Get the tail of the DataFrame

pub fn as_record_batches(&self) -> Result<Vec<RecordBatch>>

Transform the underlying chunks in the DataFrame to Arrow RecordBatches

pub fn reverse(&self) -> Self

Get a DataFrame with all the columns in reversed order

impl DataFrame

pub fn frame_equal(&self, other: &DataFrame) -> bool

Trait Implementations

impl Clone for DataFrame

fn clone(&self) -> DataFrame

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for DataFrame

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Display for DataFrame

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.