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::SeriesCopy item path

§Series

§Arithmetic

§Comparison

§Iterators

§Creation

Tuple Fields§

Implementations§

impl Series

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

§Example

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( name: &str, values: &[AnyValue<'_>], strict: bool ) -> PolarsResult<Self>

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

impl Series

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

impl Series

pub fn wrapping_trunc_div_scalar<T: Num + NumCast>(&self, rhs: T) -> Self

impl Series

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

§Safety

pub unsafe fn _try_from_arrow_unchecked( name: &str, chunks: Vec<ArrayRef>, dtype: &ArrowDataType ) -> PolarsResult<Self>

§Safety

pub unsafe fn _try_from_arrow_unchecked_with_md( name: &str, chunks: Vec<ArrayRef>, dtype: &ArrowDataType, md: Option<&Metadata> ) -> PolarsResult<Self>

§Safety

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, pl_flavor: bool) -> ArrayRef

impl Series

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

§Panics

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

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 str(&self) -> PolarsResult<&StringChunked>

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

pub fn binary_offset(&self) -> PolarsResult<&BinaryOffsetChunked>

pub fn decimal(&self) -> PolarsResult<&DecimalChunked>

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

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

pub fn null(&self) -> PolarsResult<&NullChunked>

impl Series

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

impl Series

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

impl Series

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

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

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>

§Safety

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 from_arrow(name: &str, array: ArrayRef) -> PolarsResult<Series>

pub fn shrink_to_fit(&mut self)

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

Struct polars_core::series::Series

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

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

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

pub fn unpack<N>(&self) -> PolarsResult<&ChunkedArray<N>>
where N: 'static + PolarsDataType,

impl<T> Add<T> for &Series
where T: Num + NumCast,

impl<T> Add<T> for Series
where T: Num + NumCast,