Struct 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".into(), [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".into(), &[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 ChunkCompareEq trait and ChunkCompareIneq trait.

§Iterators

The Series variants contain differently typed ChunkedArrays. 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".into(), [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".into(), &[true, false, true]);
Series::new("int series".into(), &[1, 2, 3]);
// And can be nullable
Series::new("got nulls".into(), &[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 SeriesCopy item path

§Series

§Arithmetic

§Comparison

§Iterators

§Creation

Tuple Fields§

Implementations§

impl Series

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

§Example

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( name: PlSmallStr, values: &[AnyValue<'_>], strict: bool, ) -> Result<Series, PolarsError>

pub fn from_any_values_and_dtype( name: PlSmallStr, values: &[AnyValue<'_>], dtype: &DataType, strict: bool, ) -> Result<Series, PolarsError>

impl Series

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

impl Series

pub fn try_add_owned(self, other: Series) -> Result<Series, PolarsError>

pub fn try_sub_owned(self, other: Series) -> Result<Series, PolarsError>

pub fn try_mul_owned(self, other: Series) -> Result<Series, PolarsError>

impl Series

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

§Safety

pub unsafe fn _try_from_arrow_unchecked( name: PlSmallStr, chunks: Vec<Box<dyn Array>>, dtype: &ArrowDataType, ) -> Result<Series, PolarsError>

§Safety

pub unsafe fn _try_from_arrow_unchecked_with_md( name: PlSmallStr, chunks: Vec<Box<dyn Array>>, dtype: &ArrowDataType, md: Option<&BTreeMap<PlSmallStr, PlSmallStr>>, ) -> Result<Series, PolarsError>

§Safety

impl Series

pub fn try_new<T>( name: PlSmallStr, data: T, ) -> Result<Series, <(PlSmallStr, T) as TryInto<Series>>::Error>where (PlSmallStr, T): TryInto<Series>,

impl Series

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

impl Series

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

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

impl Series

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

§Panics

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

impl Series

pub fn try_i8(&self) -> Option<&ChunkedArray<Int8Type>>

pub fn try_i16(&self) -> Option<&ChunkedArray<Int16Type>>

pub fn try_i32(&self) -> Option<&ChunkedArray<Int32Type>>

pub fn try_i64(&self) -> Option<&ChunkedArray<Int64Type>>

pub fn try_f32(&self) -> Option<&ChunkedArray<Float32Type>>

pub fn try_f64(&self) -> Option<&ChunkedArray<Float64Type>>

pub fn try_u8(&self) -> Option<&ChunkedArray<UInt8Type>>

pub fn try_u16(&self) -> Option<&ChunkedArray<UInt16Type>>

pub fn try_u32(&self) -> Option<&ChunkedArray<UInt32Type>>

pub fn try_u64(&self) -> Option<&ChunkedArray<UInt64Type>>

pub fn try_bool(&self) -> Option<&ChunkedArray<BooleanType>>

pub fn try_str(&self) -> Option<&ChunkedArray<StringType>>

pub fn try_binary(&self) -> Option<&ChunkedArray<BinaryType>>

pub fn try_binary_offset(&self) -> Option<&ChunkedArray<BinaryOffsetType>>

pub fn try_time(&self) -> Option<&Logical<TimeType, Int64Type>>

pub fn try_date(&self) -> Option<&Logical<DateType, Int32Type>>

pub fn try_datetime(&self) -> Option<&Logical<DatetimeType, Int64Type>>

pub fn try_duration(&self) -> Option<&Logical<DurationType, Int64Type>>

pub fn try_decimal(&self) -> Option<&Logical<DecimalType, Int128Type>>

pub fn try_list(&self) -> Option<&ChunkedArray<ListType>>

pub fn try_array(&self) -> Option<&ChunkedArray<FixedSizeListType>>

pub fn try_categorical(&self) -> Option<&CategoricalChunked>

pub fn try_struct(&self) -> Option<&ChunkedArray<StructType>>

pub fn try_null(&self) -> Option<&NullChunked>

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>

Struct Series

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

pub fn try_new<T>( name: PlSmallStr, data: T, ) -> Result<Series, <(PlSmallStr, T) as TryInto<Series>>::Error>
where (PlSmallStr, T): TryInto<Series>,

pub fn try_set_metadata<T>(&mut self, metadata: Metadata<T>) -> bool
where T: PolarsDataType + 'static,

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

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

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