Struct polars_core::series::Series

source ·

pub struct Series(pub Arc<dyn SeriesTrait>);

Expand description

Series

The columnar data type for a DataFrame.

Most of the available functions are defined in the SeriesTrait trait.

The Series struct consists of typed ChunkedArray’s. To quickly cast a Series to a ChunkedArray you can call the method with the name of the type:

let s: Series = [1, 2, 3].iter().collect();
// Quickly obtain the ChunkedArray wrapped by the Series.
let chunked_array = s.i32().unwrap();

Arithmetic

You can do standard arithmetic on series.

let s = Series::new("a", [1 , 2, 3]);
let out_add = &s + &s;
let out_sub = &s - &s;
let out_div = &s / &s;
let out_mul = &s * &s;

Or with series and numbers.

let s: Series = (1..3).collect();
let out_add_one = &s + 1;
let out_multiply = &s * 10;

// Could not overload left hand side operator.
let out_divide = 1.div(&s);
let out_add = 1.add(&s);
let out_subtract = 1.sub(&s);
let out_multiply = 1.mul(&s);

Comparison

You can obtain boolean mask by comparing series.

let s = Series::new("dollars", &[1, 2, 3]);
let mask = s.equal(1).unwrap();
let valid = [true, false, false].iter();
assert!(mask
    .into_iter()
    .map(|opt_bool| opt_bool.unwrap()) // option, because series can be null
    .zip(valid)
    .all(|(a, b)| a == *b))

See all the comparison operators in the CmpOps trait

Iterators

The Series variants contain differently typed ChunkedArray’s. These structs can be turned into iterators, making it possible to use any function/ closure you want on a Series.

These iterators return an Option<T> because the values of a series may be null.

use polars_core::prelude::*;
let pi = 3.14;
let s = Series::new("angle", [2f32 * pi, pi, 1.5 * pi].as_ref());
let s_cos: Series = s.f32()
                    .expect("series was not an f32 dtype")
                    .into_iter()
                    .map(|opt_angle| opt_angle.map(|angle| angle.cos()))
                    .collect();

Creation

Series can be create from different data structures. Below we’ll show a few ways we can create a Series object.

// Series can be created from Vec's, slices and arrays
Series::new("boolean series", &[true, false, true]);
Series::new("int series", &[1, 2, 3]);
// And can be nullable
Series::new("got nulls", &[Some(1), None, Some(2)]);

// Series can also be collected from iterators
let from_iter: Series = (0..10)
    .into_iter()
    .collect();

Tuple Fields§

§0: Arc<dyn SeriesTrait>

Struct polars_core::series::Series

Tuple Fields§

Implementations§

impl Series

pub fn fill_null(&self, strategy: FillNullStrategy) -> PolarsResult<Series>

impl Series

pub fn sample_n( &self, n: usize, with_replacement: bool, shuffle: bool, seed: Option<u64> ) -> PolarsResult<Self>

pub fn sample_frac( &self, frac: f64, with_replacement: bool, shuffle: bool, seed: Option<u64> ) -> PolarsResult<Self>

pub fn shuffle(&self, seed: Option<u64>) -> Self

impl Series

pub fn fmt_list(&self) -> String

impl Series

pub fn from_any_values_and_dtype( name: &str, av: &[AnyValue<'_>], dtype: &DataType, strict: bool ) -> PolarsResult<Series>

pub fn from_any_values( name: &str, avs: &[AnyValue<'_>], strict: bool ) -> PolarsResult<Series>

impl Series

pub fn try_add(&self, rhs: &Series) -> PolarsResult<Series>

impl Series

pub unsafe fn from_chunks_and_dtype_unchecked( name: &str, chunks: Vec<ArrayRef>, dtype: &DataType ) -> Self

impl Series

pub fn new_null(name: &str, len: usize) -> Series

impl Series

pub fn array_ref(&self, chunk_idx: usize) -> &ArrayRef

pub fn to_arrow(&self, chunk_idx: usize) -> ArrayRef

impl Series

pub fn iter(&self) -> SeriesIter<'_> ⓘ

pub fn phys_iter(&self) -> SeriesPhysIter<'_>

impl Series

pub fn diff(&self, n: i64, null_behavior: NullBehavior) -> PolarsResult<Series>

impl Series

pub fn i8(&self) -> PolarsResult<&Int8Chunked>

pub fn i16(&self) -> PolarsResult<&Int16Chunked>

pub fn i32(&self) -> PolarsResult<&Int32Chunked>

pub fn i64(&self) -> PolarsResult<&Int64Chunked>

pub fn f32(&self) -> PolarsResult<&Float32Chunked>

pub fn f64(&self) -> PolarsResult<&Float64Chunked>

pub fn u8(&self) -> PolarsResult<&UInt8Chunked>

pub fn u16(&self) -> PolarsResult<&UInt16Chunked>

pub fn u32(&self) -> PolarsResult<&UInt32Chunked>

pub fn u64(&self) -> PolarsResult<&UInt64Chunked>

pub fn bool(&self) -> PolarsResult<&BooleanChunked>

pub fn utf8(&self) -> PolarsResult<&Utf8Chunked>

pub fn binary(&self) -> PolarsResult<&BinaryChunked>

pub fn list(&self) -> PolarsResult<&ListChunked>

pub fn categorical(&self) -> PolarsResult<&CategoricalChunked>

impl Series

pub fn extend_constant( &self, value: AnyValue<'_>, n: usize ) -> PolarsResult<Self>

impl Series

pub fn skew(&self, bias: bool) -> PolarsResult<Option<f64>>

pub fn kurtosis(&self, fisher: bool, bias: bool) -> PolarsResult<Option<f64>>

impl Series

pub fn full_null(name: &str, size: usize, dtype: &DataType) -> Self

impl Series

pub fn round(&self, decimals: u32) -> PolarsResult<Self>

pub fn floor(&self) -> PolarsResult<Self>

pub fn ceil(&self) -> PolarsResult<Self>

pub fn clip(self, min: AnyValue<'_>, max: AnyValue<'_>) -> PolarsResult<Self>

pub fn clip_max(self, max: AnyValue<'_>) -> PolarsResult<Self>

pub fn clip_min(self, min: AnyValue<'_>) -> PolarsResult<Self>

impl Series

pub fn implode(&self) -> PolarsResult<ListChunked>

pub fn reshape(&self, dims: &[i64]) -> PolarsResult<Series>

impl Series

pub fn unique_counts(&self) -> IdxCa

impl Series

pub fn new_empty(name: &str, dtype: &DataType) -> Series

pub fn clear(&self) -> Series

pub unsafe fn chunks_mut(&mut self) -> &mut Vec<ArrayRef>

pub fn set_sorted_flag(&mut self, sorted: IsSorted)

pub fn into_frame(self) -> DataFrame

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

pub fn shrink_to_fit(&mut self)

pub fn append(&mut self, other: &Series) -> PolarsResult<&mut Self>

pub fn extend(&mut self, other: &Series) -> PolarsResult<&mut Self>

pub fn sort(&self, descending: bool) -> Self

pub fn as_single_ptr(&mut self) -> PolarsResult<usize>

pub fn cast(&self, dtype: &DataType) -> PolarsResult<Self>

pub unsafe fn cast_unchecked(&self, dtype: &DataType) -> PolarsResult<Self>

pub fn sum<T>(&self) -> Option<T>where T: NumCast,

pub fn min<T>(&self) -> Option<T>where T: NumCast,

pub fn max<T>(&self) -> Option<T>where T: NumCast,