Struct DataFrame 

pub struct DataFrame<I>
where
    I: PartialOrd + PartialEq + BlackJackData,
{ /* private fields */ }

The container for Series<T> objects, allowing for additional functionality

Implementations

impl<I: PartialOrd + PartialEq + BlackJackData> DataFrame<I>

pub fn new() -> Self

Create a new DataFrame struct

Example

use blackjack::prelude::*;

let mut df: DataFrame<i32> = DataFrame::new();  // `i32` indicates index type of DataFrame

pub fn filter_by_row<F>(&mut self, condition: F)

where F: Fn(&Row<'_>) -> bool,

Filter the dataframe by iterating over its Rows.

Example

let mut s1 = Series::from(0..5);
s1.set_name("col1");

let mut s2 = Series::from(10..15);
s2.set_name("col2");

let mut s3 = Series::from_vec(vec![
    "foo".to_string(),
    "bar".to_string(),
    "foo".to_string(),
    "bar".to_string(),
    "foo".to_string(),
]);
s3.set_name("col3");

let mut df = DataFrame::new();
assert!(df.add_column(s1).is_ok());
assert!(df.add_column(s2).is_ok());
assert!(df.add_column(s3).is_ok());

// Before filtering, we're len 5
assert_eq!(df.len(), 5);

df.filter_by_row(|row| row["col1"] == Datum::I32(&0));

// After filtering, we're len 4 and first element of 'col1' is now 1
assert_eq!(df.len(), 4);

// Filter by string foo,
df.filter_by_row(|row| row["col3"] != Datum::STR(&"foo".to_string()));
assert_eq!(df.len(), 2);

pub fn drop_positions(&mut self, positions: impl Iterator<Item = usize>)

Drop positions within the Series

Example

let mut df = DataFrame::new();
assert!(df.add_column(Series::from(0..10)).is_ok());

assert_eq!(df.len(), 10);
df.drop_positions(0..5);  // Iterator of `usize` items
assert_eq!(df.len(), 5);

pub fn iter_rows(&self) -> impl Iterator<Item = Row<'_>>

Iterator over rows of a dataframe where each element contained is a reference

Example

let rows = df.iter_rows().collect::<Vec<Row>>();
assert_eq!(rows.len(), 4);  // Four rows
assert!(rows.iter().all(|r| r.data.len() == 2));  // Each row has two elements

pub fn iloc<Idx>(&self, idx: Idx) -> impl Iterator<Item = Row<'_>>

where Idx: IntoIterator<Item = usize>,

Select rows of the DataFrame based on positional index

Example

use blackjack::prelude::*;

let mut df = DataFrame::new();
 let s1 = Series::from_vec(vec![0, 1, 2, 3]);
 let s2 = Series::from_vec(vec![1, 2, 3, 4]);

 assert!(df.add_column(s1).is_ok());
 assert!(df.add_column(s2).is_ok());

 let rows = df.iloc(vec![1]).collect::<Vec<Row>>();

 // First column is s1, second element is 1
 if let Datum::I32(val) = rows[0].data[0].data {
     assert_eq!(val, &1);
 }

 // second column is s2, second element is 2
 if let Datum::I32(val) = rows[0].data[1].data {
     assert_eq!(val, &2);
 }

pub fn len(&self) -> usize

Length of the dataframe

Example

use blackjack::prelude::*;

let mut df = DataFrame::new();
assert_eq!(df.len(), 0);

let series: Series<i32> = Series::arange(0, 10);
df.add_column(series).unwrap();

assert_eq!(df.len(), 10);

pub fn is_empty(&self) -> bool

Quickly identify if the dataframe is empty.

pub fn add_column<T: BlackJackData + 'static>( &mut self, series: Series<T>, ) -> Result<(), BlackJackError>

where Vec<I>: FromIterator<i32>,

Add a column to this dataframe.

pub fn get_column_mut<'a, T>( &mut self, name: impl Into<&'a str>, ) -> Option<&mut Series<T>>

where T: BlackJackData + 'static,

Retrieves a mutable reference to the column

pub fn get_column<'a, T>(&self, name: impl Into<&'a str>) -> Option<&Series<T>>

where T: BlackJackData + 'static,

Retrieves a reference to a column

pub fn get_column_infer<'a>( &self, name: impl Into<&'a str>, ) -> Option<GenericSeriesContainer>

Get column, infer

pub fn columns(&self) -> impl Iterator<Item = &str>

Get a list of column names in this dataframe as an iterator

pub fn n_columns(&self) -> usize

Get the number of columns for this dataframe

pub fn groupby<T>(&self, keys: &Series<T>) -> DataFrameGroupBy<T>

where for<'de> T: BlackJackData + Deserialize<'de> + ToPrimitive + 'static,

Group by method for grouping Series in a DataFrame by key.

Trait Implementations

impl<I> Debug for DataFrame<I>

where I: PartialOrd + PartialEq + BlackJackData + Debug,

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

Formats the value using the given formatter.

impl<I> Default for DataFrame<I>

where I: PartialOrd + PartialEq + BlackJackData + Default,

fn default() -> DataFrame<I>

Returns the “default value” for a type.