[−][src]Struct polars::frame::DataFrame
Implementations
impl DataFrame
[src]
pub fn to_ndarray<N>(&self) -> Result<Array2<N::Native>> where
N: PolarsNumericType,
N::Native: Zero + Copy,
[src]
N: PolarsNumericType,
N::Native: Zero + Copy,
ndarray
only.Create a 2D ndarray::Array
from this DataFrame
. This requires all columns in the
DataFrame
to be non-null and numeric. They will be casted to the same data type
(if they aren't already).
use polars::prelude::*; let a = UInt32Chunked::new_from_slice("a", &[1, 2, 3]).into_series(); let b = Float64Chunked::new_from_slice("b", &[10., 8., 6.]).into_series(); let df = DataFrame::new(vec![a, b]).unwrap(); let ndarray = df.to_ndarray::<Float64Type>().unwrap(); println!("{:?}", ndarray);
Outputs:
[[1.0, 10.0],
[2.0, 8.0],
[3.0, 6.0]], shape=[3, 2], strides=[2, 1], layout=C (0x1), const ndim=2/
impl DataFrame
[src]
pub fn sample_n(&self, n: usize, with_replacement: bool) -> Result<Self>
[src]
random
only.Sample n datapoints from this DataFrame.
pub fn sample_frac(&self, frac: f64, with_replacement: bool) -> Result<Self>
[src]
random
only.Sample a fraction between 0.0-1.0 of this DataFrame.
impl DataFrame
[src]
pub fn explode<'a, J, S: Selection<'a, J>>(
&self,
columns: S
) -> Result<DataFrame>
[src]
&self,
columns: S
) -> Result<DataFrame>
Explode DataFrame
to long format by exploding a column with Lists.
Example
use polars::prelude::*; let s0 = Series::new("a", &[1i8, 2, 3]); let s1 = Series::new("b", &[1i8, 1, 1]); let s2 = Series::new("c", &[2i8, 2, 2]); let list = Series::new("foo", &[s0, s1, s2]); let s0 = Series::new("B", [1, 2, 3]); let s1 = Series::new("C", [1, 1, 1]); let df = DataFrame::new(vec![list, s0, s1]).unwrap(); let exploded = df.explode("foo").unwrap(); println!("{:?}", df); println!("{:?}", exploded);
Outputs:
+-------------+-----+-----+
| foo | B | C |
| --- | --- | --- |
| list [i8] | i32 | i32 |
+=============+=====+=====+
| "[1, 2, 3]" | 1 | 1 |
+-------------+-----+-----+
| "[1, 1, 1]" | 2 | 1 |
+-------------+-----+-----+
| "[2, 2, 2]" | 3 | 1 |
+-------------+-----+-----+
+-----+-----+-----+
| foo | B | C |
| --- | --- | --- |
| i8 | i32 | i32 |
+=====+=====+=====+
| 1 | 1 | 1 |
+-----+-----+-----+
| 2 | 1 | 1 |
+-----+-----+-----+
| 3 | 1 | 1 |
+-----+-----+-----+
| 1 | 2 | 1 |
+-----+-----+-----+
| 1 | 2 | 1 |
+-----+-----+-----+
| 1 | 2 | 1 |
+-----+-----+-----+
| 2 | 3 | 1 |
+-----+-----+-----+
| 2 | 3 | 1 |
+-----+-----+-----+
| 2 | 3 | 1 |
+-----+-----+-----+
pub fn melt<'a, 'b, J, K, SelId: Selection<'a, J>, SelValue: Selection<'b, K>>(
&self,
id_vars: SelId,
value_vars: SelValue
) -> Result<Self>
[src]
&self,
id_vars: SelId,
value_vars: SelValue
) -> Result<Self>
Unpivot a DataFrame
from wide to long format.
Example
Arguments
id_vars
- String slice that represent the columns to use as id variables.value_vars
- String slice that represent the columns to use as value variables.
use polars::prelude::*; let df = df!("A" => &["a", "b", "a"], "B" => &[1, 3, 5], "C" => &[10, 11, 12], "D" => &[2, 4, 6] ) .unwrap(); let melted = df.melt(&["A", "B"], &["C", "D"]).unwrap(); println!("{:?}", df); println!("{:?}", melted);
Outputs:
+-----+-----+-----+-----+
| A | B | C | D |
| --- | --- | --- | --- |
| str | i32 | i32 | i32 |
+=====+=====+=====+=====+
| "a" | 1 | 10 | 2 |
+-----+-----+-----+-----+
| "b" | 3 | 11 | 4 |
+-----+-----+-----+-----+
| "a" | 5 | 12 | 6 |
+-----+-----+-----+-----+
+-----+-----+----------+-------+
| A | B | variable | value |
| --- | --- | --- | --- |
| str | i32 | str | i32 |
+=====+=====+==========+=======+
| "a" | 1 | "C" | 10 |
+-----+-----+----------+-------+
| "b" | 3 | "C" | 11 |
+-----+-----+----------+-------+
| "a" | 5 | "C" | 12 |
+-----+-----+----------+-------+
| "a" | 1 | "D" | 2 |
+-----+-----+----------+-------+
| "b" | 3 | "D" | 4 |
+-----+-----+----------+-------+
| "a" | 5 | "D" | 6 |
+-----+-----+----------+-------+
impl DataFrame
[src]
pub fn groupby<'g, J, S: Selection<'g, J>>(
&self,
by: S
) -> Result<GroupBy<'_, '_>>
[src]
&self,
by: S
) -> 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
[src]
pub fn join<'a, J, S1: Selection<'a, J>, S2: Selection<'a, J>>(
&self,
other: &DataFrame,
left_on: S1,
right_on: S2,
how: JoinType
) -> Result<DataFrame>
[src]
&self,
other: &DataFrame,
left_on: S1,
right_on: S2,
how: JoinType
) -> Result<DataFrame>
Generic join method. Can be used to join on multiple columns.
pub fn inner_join(
&self,
other: &DataFrame,
left_on: &str,
right_on: &str
) -> Result<DataFrame>
[src]
&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>
[src]
&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>
[src]
&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
[src]
pub fn get_row(&self, idx: usize) -> Row<'_>
[src]
Get a row from a DataFrame. Use of this is discouraged as it will likely be slow.
pub fn get_row_amortized<'a>(&'a self, idx: usize, row: &mut Row<'a>)
[src]
Amortize allocations by reusing a row. The caller is responsible for the making sure the row has at least capacity for the number of columns in the DataFrame
pub unsafe fn get_row_amortized_unchecked<'a>(
&'a self,
idx: usize,
row: &mut Row<'a>
)
[src]
&'a self,
idx: usize,
row: &mut Row<'a>
)
Amortize allocations by reusing a row. The caller is responsible for the making sure the row has at least capacity for the number of columns in the DataFrame
Safety
Does not do any bounds checking.
impl DataFrame
[src]
pub fn new<S: IntoSeries>(columns: Vec<S>) -> Result<Self>
[src]
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 agg_chunks(&self) -> Self
[src]
Aggregate all chunks to contiguous memory.
pub fn as_single_chunk(&mut self) -> &mut Self
[src]
Aggregate all the chunks in the DataFrame to a single chunk.
pub fn rechunk(&mut self) -> Result<&mut Self>
[src]
Ensure all the chunks in the DataFrame are aligned.
pub fn schema(&self) -> Schema
[src]
Get a reference to the DataFrame schema.
pub fn get_columns(&self) -> &Vec<Series>
[src]
Get a reference to the DataFrame columns.
pub fn columns(&self) -> Vec<&str>
[src]
please use get_column_names
Get the column labels of the DataFrame.
pub fn get_column_names(&self) -> Vec<&str>
[src]
pub fn set_column_names<S: AsRef<str>>(&mut self, names: &[S]) -> Result<()>
[src]
Set the column names.
pub fn dtypes(&self) -> Vec<DataType>
[src]
Get the data types of the columns in the DataFrame.
pub fn n_chunks(&self) -> Result<usize>
[src]
The number of chunks per column
pub fn fields(&self) -> Vec<Field>
[src]
Get a reference to the schema fields of the DataFrame.
pub fn shape(&self) -> (usize, usize)
[src]
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
[src]
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
[src]
Get height of DataFrame
Example
use polars::prelude::*; fn assert_height(df: &DataFrame, height: usize) { assert_eq!(df.height(), height) }
pub fn hstack_mut(&mut self, columns: &[Series]) -> Result<&mut Self>
[src]
Add multiple Series to a DataFrame The added Series are required to have the same length.
Example
use polars::prelude::*; fn stack(df: &mut DataFrame, columns: &[Series]) { df.hstack_mut(columns); }
pub fn hstack(&self, columns: &[Series]) -> Result<Self>
[src]
Add multiple Series to a DataFrame The added Series are required to have the same length.
pub fn vstack(&self, columns: &DataFrame) -> Result<Self>
[src]
Concatenate a DataFrame to this DataFrame and return as newly allocated DataFrame
pub fn vstack_mut(&mut self, df: &DataFrame) -> Result<&mut Self>
[src]
Concatenate a DataFrame to this DataFrame
pub fn drop_in_place(&mut self, name: &str) -> Result<Series>
[src]
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_nulls(&self, subset: Option<&[String]>) -> Result<Self>
[src]
Return a new DataFrame where all null values are dropped
pub fn drop(&self, name: &str) -> Result<Self>
[src]
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 insert_at_idx<S: IntoSeries>(
&mut self,
index: usize,
column: S
) -> Result<&mut Self>
[src]
&mut self,
index: usize,
column: S
) -> Result<&mut Self>
Insert a new column at a given index
pub fn add_column<S: IntoSeries>(&mut self, column: S) -> Result<&mut Self>
[src]
Add a new column to this DataFrame
.
pub fn with_column<S: IntoSeries>(&self, column: S) -> Result<Self>
[src]
Create a new DataFrame
with the column added.
pub fn get(&self, idx: usize) -> Option<Vec<AnyValue<'_>>>
[src]
Get a row in the DataFrame
Beware this is slow.
Example
use polars::prelude::*; fn example(df: &mut DataFrame, idx: usize) -> Option<Vec<AnyValue>> { df.get(idx) }
pub fn select_at_idx(&self, idx: usize) -> Option<&Series>
[src]
Select a series by index.
pub fn find_idx_by_name(&self, name: &str) -> Option<usize>
[src]
Get column index of a series by name.
pub fn column(&self, name: &str) -> Result<&Series>
[src]
Select a single column by name.
pub fn select<'a, S, J>(&self, selection: S) -> Result<Self> where
S: Selection<'a, J>,
[src]
S: Selection<'a, J>,
Select column(s) from this DataFrame and return a new 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_series<'a, S, J>(&self, selection: S) -> Result<Vec<Series>> where
S: Selection<'a, J>,
[src]
S: Selection<'a, J>,
Select column(s) from this DataFrame and return them into a Vector.
pub fn filter(&self, mask: &BooleanChunked) -> Result<Self>
[src]
Take DataFrame rows by a boolean mask.
pub fn take_iter<I>(&self, iter: I, capacity: Option<usize>) -> Self where
I: Iterator<Item = usize> + Clone + Sync,
[src]
I: Iterator<Item = usize> + Clone + Sync,
Take DataFrame value by indexes from an iterator.
Example
use polars::prelude::*; fn example(df: &DataFrame) -> DataFrame { let iterator = (0..9).into_iter(); df.take_iter(iterator, None) }
Safety
Out of bounds access doesn't Error but will return a Null value
pub unsafe fn take_iter_unchecked<I>(
&self,
iter: I,
capacity: Option<usize>
) -> Self where
I: Iterator<Item = usize> + Clone + Sync,
[src]
&self,
iter: I,
capacity: Option<usize>
) -> Self where
I: Iterator<Item = usize> + Clone + Sync,
Take DataFrame values by indexes from an iterator.
Example
use polars::prelude::*; unsafe fn example(df: &DataFrame) -> DataFrame { let iterator = (0..9).into_iter(); df.take_iter_unchecked(iterator, None) }
Safety
This doesn't do any bound or null validity checking.
pub unsafe fn take_iter_unchecked_bounds<I>(
&self,
iter: I,
capacity: Option<usize>
) -> Self where
I: Iterator<Item = usize> + Clone + Sync,
[src]
&self,
iter: I,
capacity: Option<usize>
) -> Self where
I: Iterator<Item = usize> + Clone + Sync,
Take DataFrame values by indexes from an iterator.
Safety
This doesn't do any bound checking but checks null validity.
pub fn take_opt_iter<I>(&self, iter: I, capacity: Option<usize>) -> Self where
I: Iterator<Item = Option<usize>> + Clone + Sync,
[src]
I: Iterator<Item = Option<usize>> + Clone + Sync,
Take DataFrame values by indexes from an iterator that may contain None values.
Example
use polars::prelude::*; fn example(df: &DataFrame) -> DataFrame { let iterator = (0..9).into_iter().map(Some); df.take_opt_iter(iterator, None) }
Safety
This doesn't do any bound checking. Out of bounds may access uninitialized memory. Null validity is checked
pub unsafe fn take_opt_iter_unchecked_bounds<I>(
&self,
iter: I,
capacity: Option<usize>
) -> Self where
I: Iterator<Item = Option<usize>> + Clone + Sync,
[src]
&self,
iter: I,
capacity: Option<usize>
) -> Self where
I: Iterator<Item = Option<usize>> + Clone + Sync,
Take DataFrame values by indexes from an iterator that may contain None values.
Safety
This doesn't do any bound checking. Out of bounds may access uninitialized memory. Null validity is checked
pub unsafe fn take_opt_iter_unchecked<I>(
&self,
iter: I,
capacity: Option<usize>
) -> Self where
I: Iterator<Item = Option<usize>> + Clone + Sync,
[src]
&self,
iter: I,
capacity: Option<usize>
) -> Self where
I: Iterator<Item = Option<usize>> + Clone + Sync,
Take DataFrame values by indexes from an iterator that may contain None values.
Example
use polars::prelude::*; unsafe fn example(df: &DataFrame) -> DataFrame { let iterator = (0..9).into_iter().map(Some); df.take_opt_iter_unchecked(iterator, None) }
Safety
This doesn't do any bound or null validity checking.
pub fn take<T: AsTakeIndex + Sync>(&self, indices: &T) -> Self
[src]
Take DataFrame rows by index values.
Example
use polars::prelude::*; fn example(df: &DataFrame) -> DataFrame { let idx = vec![0, 1, 9]; df.take(&idx) }
Safety
Out of bounds access doesn't Error but will return a Null value
pub fn rename(&mut self, column: &str, name: &str) -> Result<&mut Self>
[src]
Rename a column in the DataFrame
Example
use polars::prelude::*; fn example(df: &mut DataFrame) -> Result<&mut DataFrame> { 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<&mut Self>
[src]
&mut self,
by_column: &str,
reverse: bool
) -> Result<&mut Self>
Sort DataFrame in place by a column.
pub fn sort(&self, by_column: &str, reverse: bool) -> Result<Self>
[src]
Return a sorted clone of this DataFrame.
pub fn replace<S: IntoSeries>(
&mut self,
column: &str,
new_col: S
) -> Result<&mut Self>
[src]
&mut self,
column: &str,
new_col: S
) -> Result<&mut Self>
Replace a column with a series.
pub fn replace_or_add<S: IntoSeries>(
&mut self,
column: &str,
new_col: S
) -> Result<&mut Self>
[src]
&mut self,
column: &str,
new_col: S
) -> Result<&mut Self>
Replace or update a column.
pub fn replace_at_idx<S: IntoSeries>(
&mut self,
idx: usize,
new_col: S
) -> Result<&mut Self>
[src]
&mut self,
idx: usize,
new_col: S
) -> Result<&mut Self>
Replace column at index idx
with a series.
Example
use polars::prelude::*; let s0 = Series::new("foo", &["ham", "spam", "egg"]); let s1 = Series::new("ascii", &[70, 79, 79]); let mut df = DataFrame::new(vec![s0, s1]).unwrap(); // Add 32 to get lowercase ascii values df.replace_at_idx(1, df.select_at_idx(1).unwrap() + 32);
pub fn apply<F, S>(&mut self, column: &str, f: F) -> Result<&mut Self> where
F: FnOnce(&Series) -> S,
S: IntoSeries,
[src]
F: FnOnce(&Series) -> S,
S: IntoSeries,
Apply a closure to a column. This is the recommended way to do in place modification.
Example
use polars::prelude::*; let s0 = Series::new("foo", &["ham", "spam", "egg"]); let s1 = Series::new("names", &["Jean", "Claude", "van"]); let mut df = DataFrame::new(vec![s0, s1]).unwrap(); fn str_to_len(str_val: &Series) -> Series { str_val.utf8() .unwrap() .into_iter() .map(|opt_name: Option<&str>| { opt_name.map(|name: &str| name.len() as u32) }) .collect::<UInt32Chunked>() .into_series() } // Replace the names column by the length of the names. df.apply("names", str_to_len);
Results in:
+--------+-------+
| foo | |
| --- | names |
| str | u32 |
+========+=======+
| "ham" | 4 |
+--------+-------+
| "spam" | 6 |
+--------+-------+
| "egg" | 3 |
+--------+-------+
pub fn apply_at_idx<F, S>(&mut self, idx: usize, f: F) -> Result<&mut Self> where
F: FnOnce(&Series) -> S,
S: IntoSeries,
[src]
F: FnOnce(&Series) -> S,
S: IntoSeries,
Apply a closure to a column at index idx
. This is the recommended way to do in place
modification.
Example
use polars::prelude::*; let s0 = Series::new("foo", &["ham", "spam", "egg"]); let s1 = Series::new("ascii", &[70, 79, 79]); let mut df = DataFrame::new(vec![s0, s1]).unwrap(); // Add 32 to get lowercase ascii values df.apply_at_idx(1, |s| s + 32);
Results in:
+--------+-------+
| foo | ascii |
| --- | --- |
| str | i32 |
+========+=======+
| "ham" | 102 |
+--------+-------+
| "spam" | 111 |
+--------+-------+
| "egg" | 111 |
+--------+-------+
pub fn may_apply_at_idx<F, S>(&mut self, idx: usize, f: F) -> Result<&mut Self> where
F: FnOnce(&Series) -> Result<S>,
S: IntoSeries,
[src]
F: FnOnce(&Series) -> Result<S>,
S: IntoSeries,
Apply a closure that may fail to a column at index idx
. This is the recommended way to do in place
modification.
Example
This is the idomatic way to replace some values a column of a DataFrame
given range of indexes.
let s0 = Series::new("foo", &["ham", "spam", "egg", "bacon", "quack"]); let s1 = Series::new("values", &[1, 2, 3, 4, 5]); let mut df = DataFrame::new(vec![s0, s1]).unwrap(); let idx = &[0, 1, 4]; df.may_apply("foo", |s| { s.utf8()? .set_at_idx_with(idx, |opt_val| opt_val.map(|string| format!("{}-is-modified", string))) });
Results in:
+---------------------+--------+
| foo | values |
| --- | --- |
| str | i32 |
+=====================+========+
| "ham-is-modified" | 1 |
+---------------------+--------+
| "spam-is-modified" | 2 |
+---------------------+--------+
| "egg" | 3 |
+---------------------+--------+
| "bacon" | 4 |
+---------------------+--------+
| "quack-is-modified" | 5 |
+---------------------+--------+
pub fn may_apply<F, S>(&mut self, column: &str, f: F) -> Result<&mut Self> where
F: FnOnce(&Series) -> Result<S>,
S: IntoSeries,
[src]
F: FnOnce(&Series) -> Result<S>,
S: IntoSeries,
Apply a closure that may fail to a column. This is the recommended way to do in place modification.
Example
This is the idomatic way to replace some values a column of a DataFrame
given a boolean mask.
let s0 = Series::new("foo", &["ham", "spam", "egg", "bacon", "quack"]); let s1 = Series::new("values", &[1, 2, 3, 4, 5]); let mut df = DataFrame::new(vec![s0, s1]).unwrap(); // create a mask let values = df.column("values").unwrap(); let mask = values.lt_eq(1) | values.gt_eq(5); df.may_apply("foo", |s| { s.utf8()? .set(&mask, Some("not_within_bounds")) });
Results in:
+---------------------+--------+
| foo | values |
| --- | --- |
| str | i32 |
+=====================+========+
| "not_within_bounds" | 1 |
+---------------------+--------+
| "spam" | 2 |
+---------------------+--------+
| "egg" | 3 |
+---------------------+--------+
| "bacon" | 4 |
+---------------------+--------+
| "not_within_bounds" | 5 |
+---------------------+--------+
pub fn slice(&self, offset: usize, length: usize) -> Result<Self>
[src]
Slice the DataFrame along the rows.
pub fn head(&self, length: Option<usize>) -> Self
[src]
Get the head of the DataFrame
pub fn tail(&self, length: Option<usize>) -> Self
[src]
Get the tail of the DataFrame
pub fn as_record_batches(&self) -> Result<Vec<RecordBatch>>
[src]
Transform the underlying chunks in the DataFrame to Arrow RecordBatches
pub fn iter_record_batches(
&mut self,
buffer_size: usize
) -> impl Iterator<Item = RecordBatch> + '_
[src]
&mut self,
buffer_size: usize
) -> impl Iterator<Item = RecordBatch> + '_
Iterator over the rows in this DataFrame as Arrow RecordBatches.
pub fn reverse(&self) -> Self
[src]
Get a DataFrame with all the columns in reversed order
pub fn shift(&self, periods: i32) -> Result<Self>
[src]
Shift the values by a given period and fill the parts that will be empty due to this operation
with Nones
.
See the method on Series for more info on the shift
operation.
pub fn fill_none(&self, strategy: FillNoneStrategy) -> Result<Self>
[src]
Replace None values with one of the following strategies:
- Forward fill (replace None with the previous value)
- Backward fill (replace None with the next value)
- Mean fill (replace None with the mean of the whole array)
- Min fill (replace None with the minimum of the whole array)
- Max fill (replace None with the maximum of the whole array)
See the method on Series for more info on the fill_none
operation.
pub fn max(&self) -> Self
[src]
Aggregate the columns to their maximum values.
pub fn std(&self) -> Self
[src]
Aggregate the columns to their standard deviation values.
pub fn var(&self) -> Self
[src]
Aggregate the columns to their variation values.
pub fn min(&self) -> Self
[src]
Aggregate the columns to their minimum values.
pub fn sum(&self) -> Self
[src]
Aggregate the columns to their sum values.
pub fn mean(&self) -> Self
[src]
Aggregate the columns to their mean values.
pub fn median(&self) -> Self
[src]
Aggregate the columns to their median values.
pub fn quantile(&self, quantile: f64) -> Result<Self>
[src]
Aggregate the columns to their quantile values.
pub fn pipe<F, B>(self, f: F) -> Result<B> where
F: Fn(DataFrame) -> Result<B>,
[src]
F: Fn(DataFrame) -> Result<B>,
Pipe different functions/ closure operations that work on a DataFrame together.
pub fn pipe_mut<F, B>(&mut self, f: F) -> Result<B> where
F: Fn(&mut DataFrame) -> Result<B>,
[src]
F: Fn(&mut DataFrame) -> Result<B>,
Pipe different functions/ closure operations that work on a DataFrame together.
pub fn pipe_with_args<F, B, Args>(self, f: F, args: Args) -> Result<B> where
F: Fn(DataFrame, Args) -> Result<B>,
[src]
F: Fn(DataFrame, Args) -> Result<B>,
Pipe different functions/ closure operations that work on a DataFrame together.
pub fn to_dummies(&self) -> Result<Self>
[src]
Create dummy variables.
Example
use polars::prelude::*; let df = df! { "id" => &[1, 2, 3, 1, 2, 3, 1, 1], "type" => &["A", "B", "B", "B", "C", "C", "C", "B"], "code" => &["X1", "X2", "X3", "X3", "X2", "X2", "X1", "X1"] }.unwrap(); let dummies = df.to_dummies().unwrap(); dbg!(dummies);
Outputs:
+------+------+------+--------+--------+--------+---------+---------+---------+
| id_1 | id_3 | id_2 | type_A | type_B | type_C | code_X1 | code_X2 | code_X3 |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| u8 | u8 | u8 | u8 | u8 | u8 | u8 | u8 | u8 |
+======+======+======+========+========+========+=========+=========+=========+
| 1 | 0 | 0 | 1 | 0 | 0 | 1 | 0 | 0 |
+------+------+------+--------+--------+--------+---------+---------+---------+
| 0 | 0 | 1 | 0 | 1 | 0 | 0 | 1 | 0 |
+------+------+------+--------+--------+--------+---------+---------+---------+
| 0 | 1 | 0 | 0 | 1 | 0 | 0 | 0 | 1 |
+------+------+------+--------+--------+--------+---------+---------+---------+
| 1 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 1 |
+------+------+------+--------+--------+--------+---------+---------+---------+
| 0 | 0 | 1 | 0 | 0 | 1 | 0 | 1 | 0 |
+------+------+------+--------+--------+--------+---------+---------+---------+
| 0 | 1 | 0 | 0 | 0 | 1 | 0 | 1 | 0 |
+------+------+------+--------+--------+--------+---------+---------+---------+
| 1 | 0 | 0 | 0 | 0 | 1 | 1 | 0 | 0 |
+------+------+------+--------+--------+--------+---------+---------+---------+
| 1 | 0 | 0 | 0 | 1 | 0 | 1 | 0 | 0 |
+------+------+------+--------+--------+--------+---------+---------+---------+
pub fn drop_duplicates(
&self,
maintain_order: bool,
subset: Option<&[String]>
) -> Result<Self>
[src]
&self,
maintain_order: bool,
subset: Option<&[String]>
) -> Result<Self>
Drop duplicate rows from a DataFrame. This fails when there is a column of type List in DataFrame
Example
use polars::prelude::*; fn example() -> Result<DataFrame> { let df = df! { "flt" => [1., 1., 2., 2., 3., 3.], "int" => [1, 1, 2, 2, 3, 3, ], "str" => ["a", "a", "b", "b", "c", "c"] }?; df.drop_duplicates(true, None) }
Returns
+-----+-----+-----+
| flt | int | str |
| --- | --- | --- |
| f64 | i32 | str |
+=====+=====+=====+
| 1 | 1 | "a" |
+-----+-----+-----+
| 2 | 2 | "b" |
+-----+-----+-----+
| 3 | 3 | "c" |
+-----+-----+-----+
pub fn is_unique(&self) -> Result<BooleanChunked>
[src]
Get a mask of all the unique rows in the DataFrame.
pub fn is_duplicated(&self) -> Result<BooleanChunked>
[src]
Get a mask of all the duplicated rows in the DataFrame.
impl DataFrame
[src]
impl DataFrame
[src]
pub fn frame_equal(&self, other: &DataFrame) -> bool
[src]
Check if DataFrames
are equal. Note that None == None
evaluates to false
pub fn frame_equal_missing(&self, other: &DataFrame) -> bool
[src]
Check if all values in DataFrames
are equal where None == None
evaluates to true
.
Trait Implementations
impl Add<&'_ Series> for &DataFrame
[src]
type Output = Result<DataFrame>
The resulting type after applying the +
operator.
pub fn add(self, rhs: &Series) -> Self::Output
[src]
impl Add<&'_ Series> for DataFrame
[src]
type Output = Result<DataFrame>
The resulting type after applying the +
operator.
pub fn add(self, rhs: &Series) -> Self::Output
[src]
impl Clone for DataFrame
[src]
impl Debug for DataFrame
[src]
impl Default for DataFrame
[src]
impl Display for DataFrame
[src]
impl Div<&'_ Series> for &DataFrame
[src]
type Output = Result<DataFrame>
The resulting type after applying the /
operator.
pub fn div(self, rhs: &Series) -> Self::Output
[src]
impl Div<&'_ Series> for DataFrame
[src]
type Output = Result<DataFrame>
The resulting type after applying the /
operator.
pub fn div(self, rhs: &Series) -> Self::Output
[src]
impl FromIterator<Series> for DataFrame
[src]
pub fn from_iter<T: IntoIterator<Item = Series>>(iter: T) -> Self
[src]
Panics
Panics if Series have different lengths.
impl Index<&'_ str> for DataFrame
[src]
type Output = Series
The returned type after indexing.
pub fn index(&self, index: &str) -> &Self::Output
[src]
impl Index<Range<usize>> for DataFrame
[src]
type Output = [Series]
The returned type after indexing.
pub fn index(&self, index: Range<usize>) -> &Self::Output
[src]
impl Index<RangeFrom<usize>> for DataFrame
[src]
type Output = [Series]
The returned type after indexing.
pub fn index(&self, index: RangeFrom<usize>) -> &Self::Output
[src]
impl Index<RangeFull> for DataFrame
[src]
type Output = [Series]
The returned type after indexing.
pub fn index(&self, index: RangeFull) -> &Self::Output
[src]
impl Index<RangeInclusive<usize>> for DataFrame
[src]
type Output = [Series]
The returned type after indexing.
pub fn index(&self, index: RangeInclusive<usize>) -> &Self::Output
[src]
impl Index<RangeTo<usize>> for DataFrame
[src]
type Output = [Series]
The returned type after indexing.
pub fn index(&self, index: RangeTo<usize>) -> &Self::Output
[src]
impl Index<RangeToInclusive<usize>> for DataFrame
[src]
type Output = [Series]
The returned type after indexing.
pub fn index(&self, index: RangeToInclusive<usize>) -> &Self::Output
[src]
impl Index<usize> for DataFrame
[src]
type Output = Series
The returned type after indexing.
pub fn index(&self, index: usize) -> &Self::Output
[src]
impl Mul<&'_ Series> for &DataFrame
[src]
type Output = Result<DataFrame>
The resulting type after applying the *
operator.
pub fn mul(self, rhs: &Series) -> Self::Output
[src]
impl Mul<&'_ Series> for DataFrame
[src]
type Output = Result<DataFrame>
The resulting type after applying the *
operator.
pub fn mul(self, rhs: &Series) -> Self::Output
[src]
impl Rem<&'_ Series> for &DataFrame
[src]
type Output = Result<DataFrame>
The resulting type after applying the %
operator.
pub fn rem(self, rhs: &Series) -> Self::Output
[src]
impl Rem<&'_ Series> for DataFrame
[src]
type Output = Result<DataFrame>
The resulting type after applying the %
operator.
pub fn rem(self, rhs: &Series) -> Self::Output
[src]
impl Sub<&'_ Series> for &DataFrame
[src]
type Output = Result<DataFrame>
The resulting type after applying the -
operator.
pub fn sub(self, rhs: &Series) -> Self::Output
[src]
impl Sub<&'_ Series> for DataFrame
[src]
type Output = Result<DataFrame>
The resulting type after applying the -
operator.
pub fn sub(self, rhs: &Series) -> Self::Output
[src]
impl TryFrom<RecordBatch> for DataFrame
[src]
Conversion from Vec
type Error = PolarsError
The type returned in the event of a conversion error.
pub fn try_from(batch: RecordBatch) -> Result<DataFrame>
[src]
impl TryFrom<Vec<RecordBatch, Global>> for DataFrame
[src]
Conversion from Vec
If batch-size is small it might be advisable to call rechunk to ensure predictable performance
type Error = PolarsError
The type returned in the event of a conversion error.
pub fn try_from(batches: Vec<RecordBatch>) -> Result<DataFrame>
[src]
Auto Trait Implementations
impl !RefUnwindSafe for DataFrame
[src]
impl Send for DataFrame
[src]
impl Sync for DataFrame
[src]
impl Unpin for DataFrame
[src]
impl !UnwindSafe for DataFrame
[src]
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T, U> Cast<U> for T where
U: FromCast<T>,
U: FromCast<T>,
pub fn cast(self) -> U
impl<T> From<T> for T
[src]
impl<T> FromCast<T> for T
pub fn from_cast(t: T) -> T
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T, Rhs, Output> NumOps<Rhs, Output> for T where
T: Sub<Rhs, Output = Output> + Mul<Rhs, Output = Output> + Div<Rhs, Output = Output> + Add<Rhs, Output = Output> + Rem<Rhs, Output = Output>,
[src]
T: Sub<Rhs, Output = Output> + Mul<Rhs, Output = Output> + Div<Rhs, Output = Output> + Add<Rhs, Output = Output> + Rem<Rhs, Output = Output>,
impl<T> Pointable for T
pub const ALIGN: usize
type Init = T
The type for initializers.
pub unsafe fn init(init: <T as Pointable>::Init) -> usize
pub unsafe fn deref<'a>(ptr: usize) -> &'a T
pub unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T
pub unsafe fn drop(ptr: usize)
impl<T> ToCell for T where
T: ToString,
[src]
T: ToString,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
impl<T> ToString for T where
T: Display + ?Sized,
[src]
T: Display + ?Sized,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
V: MultiLane<T>,