Struct polars_core::series::Series

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

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

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

Rename series.

pub fn append_array(&mut self, other: ArrayRef) -> Result<&mut Self>

Append arrow array of same datatype.

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

Append a Series of the same type in place.

pub fn sort_in_place(&mut self, reverse: bool) -> &mut Self

Sort in place.

pub fn as_single_ptr(&mut self) -> Result<usize>

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

pub fn cast<N>(&self) -> Result<Self> where
    N: PolarsDataType, 

Cast to some primitive type.

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

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, 

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, 

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>

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

pub fn is_nan(&self) -> Result<BooleanChunked>

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

pub fn is_not_nan(&self) -> Result<BooleanChunked>

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

pub fn is_finite(&self) -> Result<BooleanChunked>

Check if float value is finite

pub fn is_infinite(&self) -> Result<BooleanChunked>

Check if float value is finite

pub fn zip_with(&self, mask: &BooleanChunked, other: &Series) -> Result<Series>

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

pub fn to_physical_repr(&self) -> Series

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

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

pub unsafe fn take_unchecked_threaded(
    &self,
    idx: &UInt32Chunked,
    rechunk: bool
) -> Result<Series>

Take by index if ChunkedArray contains a single chunk.

Safety

This doesn’t check any bounds. Null validity is checked.

pub fn take_threaded(&self, idx: &UInt32Chunked, rechunk: bool) -> Series

Take by index. This operation is clone.

Safety

Out of bounds access doesn’t Error but will return a Null value

pub fn filter_threaded(
    &self,
    filter: &BooleanChunked,
    rechunk: bool
) -> Result<Series>

Filter by boolean mask. This operation clones data.

impl Series

pub fn series_equal(&self, other: &Series) -> bool

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

pub fn series_equal_missing(&self, other: &Series) -> bool

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

pub fn get_data_ptr(&self) -> usize

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

Methods from Deref<Target = dyn SeriesTrait>

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

Trait Implementations

impl Add<&'_ Series> for &DataFrame

type Output = Result<DataFrame>

The resulting type after applying the + operator.

fn add(self, rhs: &Series) -> Self::Output

Performs the + operation.

impl Add<&'_ Series> for DataFrame

type Output = Result<DataFrame>

The resulting type after applying the + operator.

fn add(self, rhs: &Series) -> Self::Output

Performs the + operation.

impl Add<&'_ Series> for &Series

type Output = Series

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

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

type Output = Series

The resulting type after applying the + operator.

fn add(self, rhs: T) -> Self::Output

Performs the + operation.

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

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: T) -> Self::Output

Performs the + operation.

impl<'a> AsRef<dyn SeriesTrait + 'a> for Series

fn as_ref(&self) -> &(dyn SeriesTrait + 'a)

Performs the conversion.

impl ChunkAgg<Series> for ListChunked

fn sum(&self) -> Option<T>

Aggregate the sum of the ChunkedArray. Returns None if the array is empty or only contains null values.

fn min(&self) -> Option<T>

fn max(&self) -> Option<T>

Returns the maximum value in the array, according to the natural order. Returns None if the array is empty or only contains null values.

fn mean(&self) -> Option<f64>

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

fn median(&self) -> Option<f64>

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

fn quantile(&self, _quantile: f64) -> Result<Option<T>>

Aggregate a given quantile of the ChunkedArray. Returns None if the array is empty or only contains null values.

impl<'a> ChunkApply<'a, Series, Series> for ListChunked

fn apply<F>(&'a self, f: F) -> Self where
    F: Fn(Series) -> Series + Copy, 

Apply a closure F elementwise.

fn apply_with_idx<F>(&'a self, f: F) -> Self where
    F: Fn((usize, Series)) -> Series + Copy, 

Apply a closure elementwise. The closure gets the index of the element as first argument.

fn apply_with_idx_on_opt<F>(&'a self, f: F) -> Self where
    F: Fn((usize, Option<Series>)) -> Option<Series> + Copy, 

Apply a closure elementwise. The closure gets the index of the element as first argument.

fn apply_cast_numeric<F, S>(&self, f: F) -> ChunkedArray<S> where
    F: Fn(Series) -> S::Native + Copy,
    S: PolarsNumericType, 

Apply a closure elementwise and cast to a Numeric ChunkedArray. This is fastest when the null check branching is more expensive than the closure application.

fn branch_apply_cast_numeric_no_null<F, S>(&self, f: F) -> ChunkedArray<S> where
    F: Fn(Option<Series>) -> S::Native + Copy,
    S: PolarsNumericType, 

Apply a closure on optional values and cast to Numeric ChunkedArray without null values.

impl ChunkCompare<&'_ Series> for Series

fn eq(&self, rhs: &Series) -> BooleanChunked

Create a boolean mask by checking for equality.

fn neq(&self, rhs: &Series) -> BooleanChunked

Create a boolean mask by checking for inequality.

fn gt(&self, rhs: &Series) -> BooleanChunked

Create a boolean mask by checking if lhs > rhs.

fn gt_eq(&self, rhs: &Series) -> BooleanChunked

Create a boolean mask by checking if lhs >= rhs.

fn lt(&self, rhs: &Series) -> BooleanChunked

Create a boolean mask by checking if lhs < rhs.

fn lt_eq(&self, rhs: &Series) -> BooleanChunked

Create a boolean mask by checking if lhs <= rhs.

fn eq_missing(&self, rhs: &Series) -> BooleanChunked

Check for equality and regard missing values as equal.

impl ChunkCompare<&'_ str> for Series

fn eq_missing(&self, rhs: &str) -> BooleanChunked

Check for equality and regard missing values as equal.

fn eq(&self, rhs: &str) -> BooleanChunked

Check for equality.

fn neq(&self, rhs: &str) -> BooleanChunked

Check for inequality.

fn gt(&self, rhs: &str) -> BooleanChunked

Greater than comparison.

fn gt_eq(&self, rhs: &str) -> BooleanChunked

Greater than or equal comparison.

fn lt(&self, rhs: &str) -> BooleanChunked

Less than comparison.

fn lt_eq(&self, rhs: &str) -> BooleanChunked

Less than or equal comparison

impl<Rhs> ChunkCompare<Rhs> for Series where
    Rhs: NumComp, 

fn eq_missing(&self, rhs: Rhs) -> BooleanChunked

Check for equality and regard missing values as equal.

fn eq(&self, rhs: Rhs) -> BooleanChunked

Check for equality.

fn neq(&self, rhs: Rhs) -> BooleanChunked

Check for inequality.

fn gt(&self, rhs: Rhs) -> BooleanChunked

Greater than comparison.

fn gt_eq(&self, rhs: Rhs) -> BooleanChunked

Greater than or equal comparison.

fn lt(&self, rhs: Rhs) -> BooleanChunked

Less than comparison.

fn lt_eq(&self, rhs: Rhs) -> BooleanChunked

Less than or equal comparison

impl ChunkFillNoneValue<&'_ Series> for ListChunked

fn fill_none_with_value(&self, _value: &Series) -> Result<Self>

Replace None values with a give value T.

impl ChunkFull<&'_ Series> for ListChunked

fn full(name: &str, value: &Series, length: usize) -> ListChunked

Create a ChunkedArray with a single value.

impl ChunkVar<Series> for ListChunked

fn var(&self) -> Option<T>

Compute the variance of this ChunkedArray/Series.

fn std(&self) -> Option<T>

Compute the standard deviation of this ChunkedArray/Series.

impl<T> ChunkVar<Series> for ObjectChunked<T>

fn var(&self) -> Option<T>

Compute the variance of this ChunkedArray/Series.

fn std(&self) -> Option<T>

Compute the standard deviation of this ChunkedArray/Series.

impl Clone for Series

fn clone(&self) -> Series

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Series

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Series

fn default() -> Self

Returns the “default value” for a type.

impl Deref for Series

type Target = dyn SeriesTrait

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl Display for Series

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Div<&'_ Series> for &DataFrame

type Output = Result<DataFrame>

The resulting type after applying the / operator.

fn div(self, rhs: &Series) -> Self::Output

Performs the / operation.

impl Div<&'_ Series> for DataFrame

type Output = Result<DataFrame>

The resulting type after applying the / operator.

fn div(self, rhs: &Series) -> Self::Output

Performs the / operation.

impl Div<&'_ Series> for &Series

fn div(self, rhs: Self) -> Self::Output

let s: Series = [1, 2, 3].iter().collect();
let out = &s / &s;

type Output = Series

The resulting type after applying the / operator.

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

type Output = Series

The resulting type after applying the / operator.

fn div(self, rhs: T) -> Self::Output

Performs the / operation.

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

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: T) -> Self::Output

Performs the / operation.

impl<T> From<ChunkedArray<T>> for Series where
    T: PolarsDataType,
    ChunkedArray<T>: IntoSeries, 

fn from(ca: ChunkedArray<T>) -> Self

Performs the conversion.

impl<'a> FromIterator<&'a bool> for Series

fn from_iter<I: IntoIterator<Item = &'a bool>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a> FromIterator<&'a f32> for Series

fn from_iter<I: IntoIterator<Item = &'a f32>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a> FromIterator<&'a f64> for Series

fn from_iter<I: IntoIterator<Item = &'a f64>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a> FromIterator<&'a i16> for Series

fn from_iter<I: IntoIterator<Item = &'a i16>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a> FromIterator<&'a i32> for Series

fn from_iter<I: IntoIterator<Item = &'a i32>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a> FromIterator<&'a i64> for Series

fn from_iter<I: IntoIterator<Item = &'a i64>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a> FromIterator<&'a i8> for Series

fn from_iter<I: IntoIterator<Item = &'a i8>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a> FromIterator<&'a str> for Series

fn from_iter<I: IntoIterator<Item = &'a str>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a> FromIterator<&'a u16> for Series

fn from_iter<I: IntoIterator<Item = &'a u16>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a> FromIterator<&'a u32> for Series

fn from_iter<I: IntoIterator<Item = &'a u32>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a> FromIterator<&'a u64> for Series

fn from_iter<I: IntoIterator<Item = &'a u64>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a> FromIterator<&'a u8> for Series

fn from_iter<I: IntoIterator<Item = &'a u8>>(iter: I) -> Self

Creates a value from an iterator.

impl FromIterator<Option<bool>> for Series

fn from_iter<I: IntoIterator<Item = Option<bool>>>(iter: I) -> Self

Creates a value from an iterator.

impl FromIterator<Option<f32>> for Series

fn from_iter<I: IntoIterator<Item = Option<f32>>>(iter: I) -> Self

Creates a value from an iterator.

impl FromIterator<Option<f64>> for Series

fn from_iter<I: IntoIterator<Item = Option<f64>>>(iter: I) -> Self

Creates a value from an iterator.

impl FromIterator<Option<i16>> for Series

fn from_iter<I: IntoIterator<Item = Option<i16>>>(iter: I) -> Self

Creates a value from an iterator.

impl FromIterator<Option<i32>> for Series

fn from_iter<I: IntoIterator<Item = Option<i32>>>(iter: I) -> Self

Creates a value from an iterator.

impl FromIterator<Option<i64>> for Series

fn from_iter<I: IntoIterator<Item = Option<i64>>>(iter: I) -> Self

Creates a value from an iterator.

impl FromIterator<Option<i8>> for Series

fn from_iter<I: IntoIterator<Item = Option<i8>>>(iter: I) -> Self

Creates a value from an iterator.

impl FromIterator<Option<u16>> for Series

fn from_iter<I: IntoIterator<Item = Option<u16>>>(iter: I) -> Self

Creates a value from an iterator.

impl FromIterator<Option<u32>> for Series

fn from_iter<I: IntoIterator<Item = Option<u32>>>(iter: I) -> Self

Creates a value from an iterator.

impl FromIterator<Option<u64>> for Series

fn from_iter<I: IntoIterator<Item = Option<u64>>>(iter: I) -> Self

Creates a value from an iterator.

impl FromIterator<Option<u8>> for Series

fn from_iter<I: IntoIterator<Item = Option<u8>>>(iter: I) -> Self

Creates a value from an iterator.

impl FromIterator<Series> for DataFrame

fn from_iter<T: IntoIterator<Item = Series>>(iter: T) -> Self

Panics

Panics if Series have different lengths.

impl FromIterator<bool> for Series

fn from_iter<I: IntoIterator<Item = bool>>(iter: I) -> Self

Creates a value from an iterator.

impl FromIterator<f32> for Series

fn from_iter<I: IntoIterator<Item = f32>>(iter: I) -> Self

Creates a value from an iterator.

impl FromIterator<f64> for Series

fn from_iter<I: IntoIterator<Item = f64>>(iter: I) -> Self

Creates a value from an iterator.

impl FromIterator<i16> for Series

fn from_iter<I: IntoIterator<Item = i16>>(iter: I) -> Self

Creates a value from an iterator.

impl FromIterator<i32> for Series

fn from_iter<I: IntoIterator<Item = i32>>(iter: I) -> Self

Creates a value from an iterator.

impl FromIterator<i64> for Series

fn from_iter<I: IntoIterator<Item = i64>>(iter: I) -> Self

Creates a value from an iterator.

impl FromIterator<i8> for Series

fn from_iter<I: IntoIterator<Item = i8>>(iter: I) -> Self

Creates a value from an iterator.

impl FromIterator<u16> for Series

fn from_iter<I: IntoIterator<Item = u16>>(iter: I) -> Self

Creates a value from an iterator.

impl FromIterator<u32> for Series

fn from_iter<I: IntoIterator<Item = u32>>(iter: I) -> Self

Creates a value from an iterator.

impl FromIterator<u64> for Series

fn from_iter<I: IntoIterator<Item = u64>>(iter: I) -> Self

Creates a value from an iterator.

impl FromIterator<u8> for Series

fn from_iter<I: IntoIterator<Item = u8>>(iter: I) -> Self

Creates a value from an iterator.

impl IntoSeries for Series

fn into_series(self) -> Series

impl Mul<&'_ Series> for &DataFrame

type Output = Result<DataFrame>

The resulting type after applying the * operator.

fn mul(self, rhs: &Series) -> Self::Output

Performs the * operation.

impl Mul<&'_ Series> for DataFrame

type Output = Result<DataFrame>

The resulting type after applying the * operator.

fn mul(self, rhs: &Series) -> Self::Output

Performs the * operation.

impl Mul<&'_ Series> for &Series

fn mul(self, rhs: Self) -> Self::Output

let s: Series = [1, 2, 3].iter().collect();
let out = &s * &s;

type Output = Series

The resulting type after applying the * operator.

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

type Output = Series

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Self::Output

Performs the * operation.

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

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Self::Output

Performs the * operation.

impl<'a, T: AsRef<[&'a str]>> NamedFrom<T, [&'a str]> for Series

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<'a, T: AsRef<[Option<&'a str>]>> NamedFrom<T, [Option<&'a str>]> for Series

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[Option<String>]>> NamedFrom<T, [Option<String>]> for Series

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[Option<bool>]>> NamedFrom<T, [Option<bool>]> for Series

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[Option<f32>]>> NamedFrom<T, [Option<f32>]> for Series

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[Option<f64>]>> NamedFrom<T, [Option<f64>]> for Series

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[Option<i16>]>> NamedFrom<T, [Option<i16>]> for Series

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[Option<i32>]>> NamedFrom<T, [Option<i32>]> for Series

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[Option<i64>]>> NamedFrom<T, [Option<i64>]> for Series

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[Option<i8>]>> NamedFrom<T, [Option<i8>]> for Series

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[Option<u16>]>> NamedFrom<T, [Option<u16>]> for Series

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[Option<u32>]>> NamedFrom<T, [Option<u32>]> for Series

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[Option<u64>]>> NamedFrom<T, [Option<u64>]> for Series

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[Option<u8>]>> NamedFrom<T, [Option<u8>]> for Series

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[String]>> NamedFrom<T, [String]> for Series

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[bool]>> NamedFrom<T, [bool]> for Series

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[f32]>> NamedFrom<T, [f32]> for Series

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[f64]>> NamedFrom<T, [f64]> for Series

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[i16]>> NamedFrom<T, [i16]> for Series

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[i32]>> NamedFrom<T, [i32]> for Series

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[i64]>> NamedFrom<T, [i64]> for Series

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[i8]>> NamedFrom<T, [i8]> for Series

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[u16]>> NamedFrom<T, [u16]> for Series

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[u32]>> NamedFrom<T, [u32]> for Series

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[u64]>> NamedFrom<T, [u64]> for Series

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[u8]>> NamedFrom<T, [u8]> for Series

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[Series]>> NamedFrom<T, ListType> for Series

fn new(name: &str, s: T) -> Self

Initialize by name and values.

impl Rem<&'_ Series> for &DataFrame

type Output = Result<DataFrame>

The resulting type after applying the % operator.

fn rem(self, rhs: &Series) -> Self::Output

Performs the % operation.

impl Rem<&'_ Series> for DataFrame

type Output = Result<DataFrame>

The resulting type after applying the % operator.

fn rem(self, rhs: &Series) -> Self::Output

Performs the % operation.

impl Rem<&'_ Series> for &Series

fn rem(self, rhs: Self) -> Self::Output

let s: Series = [1, 2, 3].iter().collect();
let out = &s / &s;

type Output = Series

The resulting type after applying the % operator.

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

type Output = Series

The resulting type after applying the % operator.

fn rem(self, rhs: T) -> Self::Output

Performs the % operation.

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

type Output = Self

The resulting type after applying the % operator.

fn rem(self, rhs: T) -> Self::Output

Performs the % operation.

impl Sub<&'_ Series> for &DataFrame

type Output = Result<DataFrame>

The resulting type after applying the - operator.

fn sub(self, rhs: &Series) -> Self::Output

Performs the - operation.

impl Sub<&'_ Series> for DataFrame

type Output = Result<DataFrame>

The resulting type after applying the - operator.

fn sub(self, rhs: &Series) -> Self::Output

Performs the - operation.

impl Sub<&'_ Series> for &Series

type Output = Series

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

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

type Output = Series

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> Self::Output

Performs the - operation.

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

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> Self::Output

Performs the - operation.

impl TryFrom<(&'_ str, Arc<dyn Array + 'static>)> for Series

type Error = PolarsError

The type returned in the event of a conversion error.

fn try_from(name_arr: (&str, ArrayRef)) -> Result<Self>

Performs the conversion.

impl TryFrom<(&'_ str, Vec<Arc<dyn Array + 'static>, Global>)> for Series

type Error = PolarsError

The type returned in the event of a conversion error.

fn try_from(name_arr: (&str, Vec<ArrayRef>)) -> Result<Self>

Performs the conversion.