Struct polars_core::series::Series

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

Series

The columnar data type for a DataFrame.

Most of the available functions are definedin 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 = [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();

Tuple Fields

0: Arc<dyn SeriesTrait>

Implementations

impl Series

pub fn diff(&self, n: usize, null_behavior: NullBehavior) -> Series

This is supported on crate feature diff only.

impl Series

pub fn skew(&self, bias: bool) -> Result<Option<f64>>

This is supported on crate feature moment only.

Compute the sample skewness of a data set.

For normally distributed data, the skewness should be about zero. For unimodal continuous distributions, a skewness value greater than zero means that there is more weight in the right tail of the distribution. The function skewtest can be used to determine if the skewness value is close enough to zero, statistically speaking.

see: https://github.com/scipy/scipy/blob/47bb6febaa10658c72962b9615d5d5aa2513fa3a/scipy/stats/stats.py#L1024

pub fn kurtosis(&self, fisher: bool, bias: bool) -> Result<Option<f64>>

This is supported on crate feature moment only.

Compute the kurtosis (Fisher or Pearson) of a dataset.

Kurtosis is the fourth central moment divided by the square of the variance. If Fisher’s definition is used, then 3.0 is subtracted from the result to give 0.0 for a normal distribution. If bias is false then the kurtosis is calculated using k statistics to eliminate bias coming from biased moment estimators

see: https://github.com/scipy/scipy/blob/47bb6febaa10658c72962b9615d5d5aa2513fa3a/scipy/stats/stats.py#L1027

impl Series

pub fn to_list(&self) -> Result<ListChunked>

Convert the values of this Series to a ListChunked with a length of 1, So a Series of: [1, 2, 3] becomes [[1, 2, 3]]

impl Series

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

Rename series.

pub fn shrink_to_fit(&mut self)

Shrink the capacity of this array to fit it’s length.

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(&self, dtype: &DataType) -> Result<Self>

Cast [Series] to another [DataType]

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>

This is supported on crate feature zip_with only.

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) -> Cow<'_, Series>

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

• Date -> Int32
• Datetime-> 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
) -> Result<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.

pub fn round(&self, decimals: u32) -> Result<Self>

This is supported on crate feature round_series only.

Round underlying floating point array to given decimal.

pub fn floor(&self) -> Result<Self>

This is supported on crate feature round_series only.

Floor underlying floating point array to the lowest integers smaller or equal to the float value.

pub fn dot(&self, other: &Series) -> Option<f64>

This is supported on crate feature dot_product only.

pub fn hash(&self, build_hasher: RandomState) -> UInt64Chunked

This is supported on crate feature row_hash only.

Get a hash of this Series

pub fn cummax(&self, _reverse: bool) -> Series

This is supported on crate feature cum_agg only.

Get an array with the cumulative max computed at every element

pub fn cummin(&self, _reverse: bool) -> Series

This is supported on crate feature cum_agg only.

Get an array with the cumulative min computed at every element

pub fn cumsum(&self, _reverse: bool) -> Series

This is supported on crate feature cum_agg only.

Get an array with the cumulative sum computed at every element

pub fn cumprod(&self, _reverse: bool) -> Series

This is supported on crate feature cum_agg only.

Get an array with the cumulative product computed at every element

pub fn rolling_var(&self, _options: RollingOptions) -> Result<Series>

This is supported on crate feature rolling_window only.

Apply a rolling variance to a Series. See:

pub fn rolling_std(&self, _options: RollingOptions) -> Result<Series>

This is supported on crate feature rolling_window only.

Apply a rolling std to a Series. See:

pub fn rolling_mean(&self, _options: RollingOptions) -> Result<Series>

This is supported on crate feature rolling_window only.

Apply a rolling mean to a Series. See: ChunkedArray::rolling_mean.

pub fn rolling_sum(&self, _options: RollingOptions) -> Result<Series>

This is supported on crate feature rolling_window only.

Apply a rolling sum to a Series. See: ChunkedArray::rolling_sum.

pub fn rolling_min(&self, _options: RollingOptions) -> Result<Series>

This is supported on crate feature rolling_window only.

Apply a rolling min to a Series. See: ChunkedArray::rolling_min.

pub fn rolling_max(&self, _options: RollingOptions) -> Result<Series>

This is supported on crate feature rolling_window only.

Apply a rolling max to a Series. See: ChunkedArray::rolling_max.

pub fn rank(&self, method: RankMethod) -> Series

This is supported on crate feature rank only.

pub fn strict_cast(&self, data_type: &DataType) -> Result<Series>

Cast throws an error if conversion had overflows

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<'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.

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

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

Apply a closure elementwise including null values.

fn apply_to_slice<F, T>(&'a self, f: F, slice: &mut [T]) where
    F: Fn(Option<Series>, &T) -> T, 

Apply a closure elementwise and write results to a mutable slice.

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 self > rhs.

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

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

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

Create a boolean mask by checking if self < rhs.

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

Create a boolean mask by checking if self <= 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: NumericNative, 

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 ChunkFillNullValue<&'_ Series> for ListChunked

fn fill_null_with_values(&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>

This is supported on crate feature object only.

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 From<Logical<DatetimeType, Int64Type>> for Series

This is supported on crate feature dtype-datetime only.

fn from(a: DatetimeChunked) -> 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 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 str> for Series

fn from_iter<I: IntoIterator<Item = &'a str>>(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 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<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<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<Series> for DataFrame

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

Panics

Panics if Series have different lengths.

impl FromIterator<String> for Series

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

Creates a value from an iterator.

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<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<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 IntoSeries for Series

fn is_series() -> bool

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<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<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<[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<[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<[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<[Series]>> NamedFrom<T, ListType> for Series

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

Initialize by name and values.

impl NumOpsDispatchChecked for Series

fn checked_div(&self, rhs: &Series) -> Result<Series>

Checked integer division. Computes self / rhs, returning None if rhs == 0 or the division results in overflow.

fn checked_div_num<T: ToPrimitive>(&self, rhs: T) -> Result<Series>

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, Box<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, Box<dyn Array>)) -> 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.