Struct polars::series::Series[−][src]

pub struct Series(pub Arc<dyn SeriesTrait + 'static>);

Series

The columnar data type for a DataFrame. The Series enum 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 = [1, 2, 3].iter().collect();
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.

use itertools::Itertools;
let s = Series::new("dollars", &[1, 2, 3]);
let mask = s.eq(1);
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 van be created from Vec's, slices and arrays
Series::new("boolean series", &vec![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();

Implementations

`impl Series`[src]

`pub fn rename(&mut self, name: &str) -> &mut Series`[src]

Rename series.

`pub fn append_array( &mut self, other: Arc<dyn Array + 'static> ) -> Result<&mut Series, PolarsError>`[src]

Append arrow array of same datatype.

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

Append a Series of the same type in place.

`pub fn sort_in_place(&mut self, reverse: bool) -> &mut Series`[src]

Sort in place.

`pub fn as_single_ptr(&mut self) -> Result<usize, PolarsError>`[src]

Rechunk and return a pointer to the start of the Series. Only implemented for numeric types

`pub fn cast<N>(&self) -> Result<Series, PolarsError> where N: PolarsDataType,` [src]

Cast to some primitive type.

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

Returns None if the array is empty or only contains null values.

let s = Series::new("days", [1, 2, 3].as_ref());
assert_eq!(s.sum(), Some(6));

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

Returns the minimum value in the array, according to the natural order. Returns an option because the array is nullable.

let s = Series::new("days", [1, 2, 3].as_ref());
assert_eq!(s.min(), Some(1));

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

Returns the maximum value in the array, according to the natural order. Returns an option because the array is nullable.

let s = Series::new("days", [1, 2, 3].as_ref());
assert_eq!(s.max(), Some(3));

`pub fn explode(&self) -> Result<Series, PolarsError>`[src]

Explode a list or utf8 Series. This expands every item to a new row..

`pub fn is_nan(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>`[src]

Check if float value is NaN (note this is different than missing/ null)

`pub fn is_not_nan(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>`[src]

Check if float value is NaN (note this is different than missing/ null)

`pub fn is_finite(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>`[src]

Check if float value is finite

`pub fn is_infinite(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>`[src]

Check if float value is finite

`pub fn zip_with( &self, mask: &ChunkedArray<BooleanType>, other: &Series ) -> Result<Series, PolarsError>`[src]

Create a new ChunkedArray with values from self where the mask evaluates true and values from other where the mask evaluates false

`pub fn is_in( &self, list_array: &ChunkedArray<ListType> ) -> Result<ChunkedArray<BooleanType>, PolarsError>`[src]

Check if values of this array are in the Series of the list array.

`pub fn to_physical_repr(&self) -> Series`[src]

Cast a datelike Series to their physical representation. Primitives remain unchanged

Date32 -> Int32
Date64 -> Int64
Time64 -> Int64
Duration -> Int64

`impl Series`[src]

`pub fn series_equal(&self, other: &Series) -> bool`[src]

Check if series are equal. Note that None == None evaluates to false

`pub fn series_equal_missing(&self, other: &Series) -> bool`[src]

Check if all values in series are equal where None == None evaluates to true.

`pub fn get_data_ptr(&self) -> usize`[src]

Get a pointer to the underlying data of this Series. Can be useful for fast comparisons.

`impl Series`[src]

`pub fn vec_hash_id(&self) -> ChunkedArray<UInt64Type>`[src]

Methods from Deref<Target = dyn SeriesTrait + 'static>