Struct polars::series::Series

source ·

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

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, Global>

Struct polars::series::Series

Tuple Fields§

Implementations§

impl Series

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

impl Series

pub fn take_every(&self, n: usize) -> Series

impl Series

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

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

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

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 ) -> Result<Series, PolarsError>

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

impl Series

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

impl Series

pub unsafe fn from_chunks_and_dtype_unchecked( name: &str, chunks: Vec<Box<dyn Array, Global>, Global>, dtype: &DataType ) -> Series

impl Series

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

impl Series

pub fn array_ref(&self, chunk_idx: usize) -> &Box<dyn Array, Global>

pub fn to_arrow(&self, chunk_idx: usize) -> Box<dyn Array, Global>

impl Series

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

pub fn phys_iter( &self ) -> Box<dyn ExactSizeIterator<Item = AnyValue<'_>> + '_, Global>

impl Series

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

impl Series

pub fn i8(&self) -> Result<&ChunkedArray<Int8Type>, PolarsError>

pub fn i16(&self) -> Result<&ChunkedArray<Int16Type>, PolarsError>

pub fn i32(&self) -> Result<&ChunkedArray<Int32Type>, PolarsError>

pub fn i64(&self) -> Result<&ChunkedArray<Int64Type>, PolarsError>

pub fn f32(&self) -> Result<&ChunkedArray<Float32Type>, PolarsError>

pub fn f64(&self) -> Result<&ChunkedArray<Float64Type>, PolarsError>

pub fn u8(&self) -> Result<&ChunkedArray<UInt8Type>, PolarsError>

pub fn u16(&self) -> Result<&ChunkedArray<UInt16Type>, PolarsError>

pub fn u32(&self) -> Result<&ChunkedArray<UInt32Type>, PolarsError>

pub fn u64(&self) -> Result<&ChunkedArray<UInt64Type>, PolarsError>

pub fn bool(&self) -> Result<&ChunkedArray<BooleanType>, PolarsError>

pub fn utf8(&self) -> Result<&ChunkedArray<Utf8Type>, PolarsError>

pub fn binary(&self) -> Result<&ChunkedArray<BinaryType>, PolarsError>

pub fn time(&self) -> Result<&Logical<TimeType, Int64Type>, PolarsError>

pub fn date(&self) -> Result<&Logical<DateType, Int32Type>, PolarsError>

pub fn datetime(&self) -> Result<&Logical<DatetimeType, Int64Type>, PolarsError>

pub fn duration(&self) -> Result<&Logical<DurationType, Int64Type>, PolarsError>

pub fn decimal(&self) -> Result<&Logical<DecimalType, Int128Type>, PolarsError>

pub fn list(&self) -> Result<&ChunkedArray<ListType>, PolarsError>

pub fn array(&self) -> Result<&ChunkedArray<FixedSizeListType>, PolarsError>

pub fn categorical(&self) -> Result<&CategoricalChunked, PolarsError>

pub fn struct_(&self) -> Result<&StructChunked, PolarsError>

impl Series

pub fn extend_constant( &self, value: AnyValue<'_>, n: usize ) -> Result<Series, PolarsError>

impl Series

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

impl Series

pub fn round(&self, decimals: u32) -> Result<Series, PolarsError>

pub fn floor(&self) -> Result<Series, PolarsError>

pub fn ceil(&self) -> Result<Series, PolarsError>

pub fn clip( self, min: AnyValue<'_>, max: AnyValue<'_> ) -> Result<Series, PolarsError>

pub fn clip_max(self, max: AnyValue<'_>) -> Result<Series, PolarsError>

pub fn clip_min(self, min: AnyValue<'_>) -> Result<Series, PolarsError>

impl Series

pub fn implode(&self) -> Result<ChunkedArray<ListType>, PolarsError>

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

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<Box<dyn Array, Global>, Global>

pub fn is_sorted_flag(&self) -> IsSorted

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

pub fn get_flags(&self) -> Settings

pub fn into_frame(self) -> DataFrame

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

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

pub fn shrink_to_fit(&mut self)

pub fn append(&mut self, other: &Series) -> Result<&mut Series, PolarsError>

pub fn extend(&mut self, other: &Series) -> Result<&mut Series, PolarsError>