Struct polars::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::series::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: &str, values: &[AnyValue<'_>], strict: bool ) -> Result<Series, PolarsError>

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

impl Series

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

impl Series

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

impl Series

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

§Safety

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

§Safety

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

§Safety

impl Series

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

impl Series

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

pub fn to_arrow(&self, chunk_idx: usize, pl_flavor: bool) -> 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 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 str(&self) -> Result<&ChunkedArray<StringType>, PolarsError>

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

pub fn binary_offset( &self ) -> Result<&ChunkedArray<BinaryOffsetType>, 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>

pub fn null(&self) -> Result<&NullChunked, 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 implode(&self) -> Result<ChunkedArray<ListType>, PolarsError>

pub fn reshape(&self, dimensions: &[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>>

§Safety

pub fn is_sorted_flag(&self) -> IsSorted

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

pub fn get_flags(&self) -> Settings

Struct polars::series::Series

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

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,

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

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

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