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.

let s = Series::new("dollars", &[1, 2, 3]);
let mask = s.equal(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 sample_n(
    &self,
    n: usize,
    with_replacement: bool,
    seed: u64
) -> Result<Self>

This is supported on crate feature random only.

pub fn sample_frac(
    &self,
    frac: f64,
    with_replacement: bool,
    seed: u64
) -> Result<Self>

This is supported on crate feature random only.

Sample a fraction between 0.0-1.0 of this ChunkedArray.

pub fn shuffle(&self, seed: u64) -> Self

This is supported on crate feature random only.

impl Series

pub fn agg_valid_count(&self, groups: &GroupsProxy) -> Option<Series>

pub fn agg_first(&self, groups: &GroupsProxy) -> Series

pub fn agg_n_unique(&self, groups: &GroupsProxy) -> Option<Series>

pub fn agg_last(&self, groups: &GroupsProxy) -> Series

impl Series

pub fn to_arrow(&self, chunk_idx: usize) -> ArrayRef

Convert a chunk in the Series to the correct Arrow type. This conversion is needed because polars doesn’t use a 1 on 1 mapping for logical/ categoricals, etc.

impl Series

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

This is supported on crate feature diff only.

impl Series

pub fn extend(&self, value: AnyValue<'_>, n: usize) -> Result<Self>

Extend with a constant value.

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 full_null(name: &str, size: usize, dtype: &DataType) -> Self

impl Series

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 ceil(&self) -> Result<Self>

This is supported on crate feature round_series only.

Ceil underlying floating point array to the heighest integers smaller or equal to the float value.

pub fn clip(&self, min: f64, max: f64) -> Result<Self>

This is supported on crate feature round_series only.

Ceil underlying floating point array to the heighest integers smaller or equal to the float value.

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]]

pub fn reshape(&self, dims: &[i64]) -> Result<Series>

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(&self, reverse: bool) -> Self

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

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, 

Compute the sum of all values in this Series. Returns None if the array is empty or only contains null values.

If the DataType is one of {Int8, UInt8, Int16, UInt16} the Series is first cast to Int64 to prevent overflow issues.

let s = Series::new("days", &[1, 2, 3]);
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
• Time -> Int64
• Categorical -> UInt32

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 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 sum_as_series(&self) -> Series

Get the sum of the Series as a new Series of length 1.

If the DataType is one of {Int8, UInt8, Int16, UInt16} the Series is first cast to Int64 to prevent overflow issues.

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

If the DataType is one of {Int8, UInt8, Int16, UInt16} the Series is first cast to Int64 to prevent overflow issues.

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

If the DataType is one of {Int8, UInt8, Int16, UInt16, Int32, UInt32} the Series is first cast to Int64 to prevent overflow issues.

pub fn product(&self) -> Series

This is supported on crate feature product only.

Get the product of an array.

If the DataType is one of {Int8, UInt8, Int16, UInt16} the Series is first cast to Int64 to prevent overflow issues.

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_median(&self, _options: RollingOptions) -> Result<Series>

This is supported on crate feature rolling_window only.

Apply a rolling median to a Series. See: ChunkedArray::rolling_median.

pub fn rolling_quantile(
    &self,
    _quantile: f64,
    _interpolation: QuantileInterpolOptions,
    _options: RollingOptions
) -> Result<Series>

This is supported on crate feature rolling_window only.

Apply a rolling quantile to a Series. See: ChunkedArray::rolling_quantile.

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, options: RankOptions) -> 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

pub fn is_logical(&self) -> bool

Check if the underlying data is a logical type.

pub fn is_numeric_physical(&self) -> bool

Check if underlying physical data is numeric.

Date types and Categoricals are also considered numeric.

pub fn is_numeric(&self) -> bool

Check if underlying data is numeric

pub fn abs(&self) -> Result<Series>

This is supported on crate feature abs only.

convert numerical values to their absolute value

pub fn str_value(&self, index: usize) -> Cow<'_, str>

pub fn head(&self, length: Option<usize>) -> Series

Get the head of the Series.

pub fn tail(&self, length: Option<usize>) -> Series

Get the tail of the Series.

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 AsRef<Series> for UnstableSeries<'_>

We don’t implement Deref so that the caller is aware of converting to Series

fn as_ref(&self) -> &Series

Performs the conversion.

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 equal(&self, rhs: &Series) -> BooleanChunked

Create a boolean mask by checking for equality.

fn not_equal(&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 equal(&self, rhs: &str) -> BooleanChunked

Check for equality.

fn not_equal(&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 equal(&self, rhs: Rhs) -> BooleanChunked

Check for equality.

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

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 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<[Cow<'a, str>]>> NamedFrom<T, [Cow<'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<'a, T: AsRef<[Option<Cow<'a, str>>]>> NamedFrom<T, [Option<Cow<'a, str>>]> for Series

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

Initialize by name and values.

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

fn new(name: &str, s: 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 PartialEq<Series> for Series

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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.