Enum polars::series::Series

pub enum Series {
    UInt8(ChunkedArray<UInt8Type>),
    UInt16(ChunkedArray<UInt16Type>),
    UInt32(ChunkedArray<UInt32Type>),
    UInt64(ChunkedArray<UInt64Type>),
    Int8(ChunkedArray<Int8Type>),
    Int16(ChunkedArray<Int16Type>),
    Int32(ChunkedArray<Int32Type>),
    Int64(ChunkedArray<Int64Type>),
    Float32(ChunkedArray<Float32Type>),
    Float64(ChunkedArray<Float64Type>),
    Utf8(ChunkedArray<Utf8Type>),
    Bool(ChunkedArray<BooleanType>),
    Date32(ChunkedArray<Date32Type>),
    Date64(ChunkedArray<Date64Type>),
    Time32Millisecond(Time32MillisecondChunked),
    Time32Second(Time32SecondChunked),
    Time64Nanosecond(ChunkedArray<Time64NanosecondType>),
    Time64Microsecond(ChunkedArray<Time64MicrosecondType>),
    DurationNanosecond(ChunkedArray<DurationNanosecondType>),
    DurationMicrosecond(DurationMicrosecondChunked),
    DurationMillisecond(DurationMillisecondChunked),
    DurationSecond(DurationSecondChunked),
    IntervalDayTime(IntervalDayTimeChunked),
    IntervalYearMonth(IntervalYearMonthChunked),
    TimestampNanosecond(TimestampNanosecondChunked),
    TimestampMicrosecond(TimestampMicrosecondChunked),
    TimestampMillisecond(TimestampMillisecondChunked),
    TimestampSecond(TimestampSecondChunked),
    LargeList(LargeListChunked),
}

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::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();

Variants

UInt8(ChunkedArray<UInt8Type>)

UInt16(ChunkedArray<UInt16Type>)

UInt32(ChunkedArray<UInt32Type>)

UInt64(ChunkedArray<UInt64Type>)

Int8(ChunkedArray<Int8Type>)

Int16(ChunkedArray<Int16Type>)

Int32(ChunkedArray<Int32Type>)

Int64(ChunkedArray<Int64Type>)

Float32(ChunkedArray<Float32Type>)

Float64(ChunkedArray<Float64Type>)

Utf8(ChunkedArray<Utf8Type>)

Bool(ChunkedArray<BooleanType>)

Date32(ChunkedArray<Date32Type>)

Date64(ChunkedArray<Date64Type>)

Time32Millisecond(Time32MillisecondChunked)

Time32Second(Time32SecondChunked)

Time64Nanosecond(ChunkedArray<Time64NanosecondType>)

Time64Microsecond(ChunkedArray<Time64MicrosecondType>)

DurationNanosecond(ChunkedArray<DurationNanosecondType>)

DurationMicrosecond(DurationMicrosecondChunked)

DurationMillisecond(DurationMillisecondChunked)

DurationSecond(DurationSecondChunked)

IntervalDayTime(IntervalDayTimeChunked)

IntervalYearMonth(IntervalYearMonthChunked)

TimestampNanosecond(TimestampNanosecondChunked)

TimestampMicrosecond(TimestampMicrosecondChunked)

TimestampMillisecond(TimestampMillisecondChunked)

TimestampSecond(TimestampSecondChunked)

LargeList(LargeListChunked)

Implementations

impl Series

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

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 + Zero + ToPrimitive, 

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 + Zero + ToPrimitive, 

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 mean<T>(&self) -> Option<T> where
    T: NumCast + Zero + ToPrimitive + Div<Output = T>, 

impl Series

pub fn array_data(&self) -> Vec<ArrayDataRef>

Get Arrow ArrayData

pub fn from_chunked_array<T: PolarsDataType>(ca: ChunkedArray<T>) -> Self

pub fn chunk_lengths(&self) -> &Vec<usize>

Get the lengths of the underlying chunks

pub fn name(&self) -> &str

Name of series.

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

Rename series.

pub fn field(&self) -> &Field

Get field (used in schema)

pub fn dtype(&self) -> &ArrowDataType

Get datatype of series.

pub fn chunks(&self) -> &Vec<ArrayRef>

Underlying chunks.

pub fn n_chunks(&self) -> usize

No. of chunks

pub fn i8(&self) -> Result<&Int8Chunked>

pub fn i16(&self) -> Result<&Int16Chunked>

pub fn i32(&self) -> Result<&Int32Chunked>

Unpack to ChunkedArray

let s: Series = [1, 2, 3].iter().collect();
let s_squared: Series = s.i32()
    .unwrap()
    .into_iter()
    .map(|opt_v| {
        match opt_v {
            Some(v) => Some(v * v),
            None => None, // null value
        }
}).collect();

pub fn i64(&self) -> Result<&Int64Chunked>

Unpack to ChunkedArray

pub fn f32(&self) -> Result<&Float32Chunked>

Unpack to ChunkedArray

pub fn f64(&self) -> Result<&Float64Chunked>

Unpack to ChunkedArray

pub fn u8(&self) -> Result<&UInt8Chunked>

Unpack to ChunkedArray

pub fn u16(&self) -> Result<&UInt16Chunked>

Unpack to ChunkedArray

pub fn u32(&self) -> Result<&UInt32Chunked>

Unpack to ChunkedArray

pub fn u64(&self) -> Result<&UInt64Chunked>

Unpack to ChunkedArray

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

Unpack to ChunkedArray

pub fn utf8(&self) -> Result<&Utf8Chunked>

Unpack to ChunkedArray

pub fn date32(&self) -> Result<&Date32Chunked>

Unpack to ChunkedArray

pub fn date64(&self) -> Result<&Date64Chunked>

Unpack to ChunkedArray

pub fn time32_millisecond(&self) -> Result<&Time32MillisecondChunked>

Unpack to ChunkedArray

pub fn time32_second(&self) -> Result<&Time32SecondChunked>

Unpack to ChunkedArray

pub fn time64_nanosecond(&self) -> Result<&Time64NanosecondChunked>

Unpack to ChunkedArray

pub fn time64_microsecond(&self) -> Result<&Time64MicrosecondChunked>

Unpack to ChunkedArray

pub fn duration_nanosecond(&self) -> Result<&DurationNanosecondChunked>

Unpack to ChunkedArray

pub fn duration_microsecond(&self) -> Result<&DurationMicrosecondChunked>

Unpack to ChunkedArray

pub fn duration_millisecond(&self) -> Result<&DurationMillisecondChunked>

Unpack to ChunkedArray

pub fn duration_second(&self) -> Result<&DurationSecondChunked>

Unpack to ChunkedArray

pub fn timestamp_nanosecond(&self) -> Result<&TimestampNanosecondChunked>

Unpack to ChunkedArray

pub fn timestamp_microsecond(&self) -> Result<&TimestampMicrosecondChunked>

Unpack to ChunkedArray

pub fn timestamp_millisecond(&self) -> Result<&TimestampMillisecondChunked>

Unpack to ChunkedArray

pub fn timestamp_second(&self) -> Result<&TimestampSecondChunked>

Unpack to ChunkedArray

pub fn interval_daytime(&self) -> Result<&IntervalDayTimeChunked>

Unpack to ChunkedArray

pub fn interval_year_month(&self) -> Result<&IntervalYearMonthChunked>

Unpack to ChunkedArray

pub fn large_list(&self) -> Result<&LargeListChunked>

Unpack to ChunkedArray

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

pub fn limit(&self, num_elements: usize) -> Result<Self>

Take num_elements from the top as a zero copy view.

pub fn slice(&self, offset: usize, length: usize) -> Result<Self>

Get a zero copy view of the data.

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

Append a Series of the same type in place.

pub fn filter<T: AsRef<BooleanChunked>>(&self, filter: T) -> Result<Self>

Filter by boolean mask. This operation clones data.

pub fn take_iter(
    &self,
    iter: impl Iterator<Item = usize>,
    capacity: Option<usize>
) -> Result<Self>

Take by index from an iterator. This operation clones the data.

pub unsafe fn take_iter_unchecked(
    &self,
    iter: impl Iterator<Item = usize>,
    capacity: Option<usize>
) -> Self

Take by index from an iterator. This operation clones the data.

pub unsafe fn take_opt_iter_unchecked(
    &self,
    iter: impl Iterator<Item = Option<usize>>,
    capacity: Option<usize>
) -> Self

Take by index from an iterator. This operation clones the data.

pub fn take_opt_iter(
    &self,
    iter: impl Iterator<Item = Option<usize>>,
    capacity: Option<usize>
) -> Result<Self>

Take by index from an iterator. This operation clones the data.

pub fn take<T: AsTakeIndex>(&self, indices: &T) -> Result<Self>

Take by index. This operation is clone.

pub fn len(&self) -> usize

Get length of series.

pub fn rechunk(&self, chunk_lengths: Option<&[usize]>) -> Result<Self>

Aggregate all chunks to a contiguous array of memory.

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

Get the head of the Series.

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

Get the tail of the Series.

pub fn expand_at_index(&self, index: usize, length: usize) -> Self

Create a new Series filled with values at that index.

Example

use polars::prelude::*;
let s = Series::new("a", [0i32, 1, 8]);
let expanded = s.expand_at_index(2, 4);
assert_eq!(Vec::from(expanded.i32().unwrap()), &[Some(8), Some(8), Some(8), Some(8)])

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

Cast to some primitive type.

pub fn cast_with_arrow_datatype(
    &self,
    data_type: &ArrowDataType
) -> Result<Self>

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

Get the ChunkedArray for some PolarsDataType

pub fn get(&self, index: usize) -> AnyType<'_>

Get a single value by index. Don't use this operation for loops as a runtime cast is needed for every iteration.

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

Sort in place.

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

pub fn argsort(&self, reverse: bool) -> Vec<usize>

Retrieve the indexes needed for a sort.

pub fn null_count(&self) -> usize

Count the null values.

pub fn unique(&self) -> Self

Get unique values in the Series.

pub fn arg_unique(&self) -> Vec<usize>

Get first indexes of unique values.

pub fn is_null(&self) -> BooleanChunked

Get a mask of the null values.

pub fn is_not_null(&self) -> BooleanChunked

Get a mask of the non-null values.

pub fn null_bits(&self) -> Vec<(usize, Option<Buffer>)>

Get the bits that represent the null values of the underlying ChunkedArray

pub fn reverse(&self) -> Self

return a Series in reversed order

pub fn as_single_ptr(&mut self) -> usize

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

pub fn shift(&self, periods: i32) -> Result<Self>

Shift the values by a given period and fill the parts that will be empty due to this operation with Nones.

NOTE: If you want to fill the Nones with a value use the shift operation on ChunkedArray<T>.

Example

fn example() -> Result<()> {
    let s = Series::new("series", &[1, 2, 3]);

    let shifted = s.shift(1)?;
    assert_eq!(Vec::from(shifted.i32()?), &[None, Some(1), Some(2)]);

    let shifted = s.shift(-1)?;
    assert_eq!(Vec::from(shifted.i32()?), &[Some(2), Some(3), None]);

    let shifted = s.shift(2)?;
    assert_eq!(Vec::from(shifted.i32()?), &[None, None, Some(1)]);

    Ok(())
}
example();

pub fn fill_none(&self, strategy: FillNoneStrategy) -> Result<Self>

Replace None values with one of the following strategies:

• Forward fill (replace None with the previous value)
• Backward fill (replace None with the next value)
• Mean fill (replace None with the mean of the whole array)
• Min fill (replace None with the minimum of the whole array)
• Max fill (replace None with the maximum of the whole array)

NOTE: If you want to fill the Nones with a value use the fill_none operation on ChunkedArray<T>.

Example

fn example() -> Result<()> {
    let s = Series::new("some_missing", &[Some(1), None, Some(2)]);

    let filled = s.fill_none(FillNoneStrategy::Forward)?;
    assert_eq!(Vec::from(filled.i32()?), &[Some(1), Some(1), Some(2)]);

    let filled = s.fill_none(FillNoneStrategy::Backward)?;
    assert_eq!(Vec::from(filled.i32()?), &[Some(1), Some(2), Some(2)]);

    let filled = s.fill_none(FillNoneStrategy::Min)?;
    assert_eq!(Vec::from(filled.i32()?), &[Some(1), Some(1), Some(2)]);

    let filled = s.fill_none(FillNoneStrategy::Max)?;
    assert_eq!(Vec::from(filled.i32()?), &[Some(1), Some(2), Some(2)]);

    let filled = s.fill_none(FillNoneStrategy::Mean)?;
    assert_eq!(Vec::from(filled.i32()?), &[Some(1), Some(1), Some(2)]);

    Ok(())
}
example();

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

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

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.

Trait Implementations

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

type Output = Self

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 AsMut<ChunkedArray<BooleanType>> for Series

fn as_mut(&mut self) -> &mut ChunkedArray<BooleanType>

Performs the conversion.

impl AsMut<ChunkedArray<Date32Type>> for Series

fn as_mut(&mut self) -> &mut ChunkedArray<Date32Type>

Performs the conversion.

impl AsMut<ChunkedArray<Date64Type>> for Series

fn as_mut(&mut self) -> &mut ChunkedArray<Date64Type>

Performs the conversion.

impl AsMut<ChunkedArray<DurationMicrosecondType>> for Series

fn as_mut(&mut self) -> &mut ChunkedArray<DurationMicrosecondType>

Performs the conversion.

impl AsMut<ChunkedArray<DurationMillisecondType>> for Series

fn as_mut(&mut self) -> &mut ChunkedArray<DurationMillisecondType>

Performs the conversion.

impl AsMut<ChunkedArray<DurationNanosecondType>> for Series

fn as_mut(&mut self) -> &mut ChunkedArray<DurationNanosecondType>

Performs the conversion.

impl AsMut<ChunkedArray<DurationSecondType>> for Series

fn as_mut(&mut self) -> &mut ChunkedArray<DurationSecondType>

Performs the conversion.

impl AsMut<ChunkedArray<Float32Type>> for Series

fn as_mut(&mut self) -> &mut ChunkedArray<Float32Type>

Performs the conversion.

impl AsMut<ChunkedArray<Float64Type>> for Series

fn as_mut(&mut self) -> &mut ChunkedArray<Float64Type>

Performs the conversion.

impl AsMut<ChunkedArray<Int16Type>> for Series

fn as_mut(&mut self) -> &mut ChunkedArray<Int16Type>

Performs the conversion.

impl AsMut<ChunkedArray<Int32Type>> for Series

fn as_mut(&mut self) -> &mut ChunkedArray<Int32Type>

Performs the conversion.

impl AsMut<ChunkedArray<Int64Type>> for Series

fn as_mut(&mut self) -> &mut ChunkedArray<Int64Type>

Performs the conversion.

impl AsMut<ChunkedArray<Int8Type>> for Series

fn as_mut(&mut self) -> &mut ChunkedArray<Int8Type>

Performs the conversion.

impl AsMut<ChunkedArray<IntervalDayTimeType>> for Series

fn as_mut(&mut self) -> &mut ChunkedArray<IntervalDayTimeType>

Performs the conversion.

impl AsMut<ChunkedArray<IntervalYearMonthType>> for Series

fn as_mut(&mut self) -> &mut ChunkedArray<IntervalYearMonthType>

Performs the conversion.

impl AsMut<ChunkedArray<LargeListType>> for Series

fn as_mut(&mut self) -> &mut ChunkedArray<LargeListType>

Performs the conversion.

impl AsMut<ChunkedArray<Time32MillisecondType>> for Series

fn as_mut(&mut self) -> &mut ChunkedArray<Time32MillisecondType>

Performs the conversion.

impl AsMut<ChunkedArray<Time32SecondType>> for Series

fn as_mut(&mut self) -> &mut ChunkedArray<Time32SecondType>

Performs the conversion.

impl AsMut<ChunkedArray<Time64MicrosecondType>> for Series

fn as_mut(&mut self) -> &mut ChunkedArray<Time64MicrosecondType>

Performs the conversion.

impl AsMut<ChunkedArray<Time64NanosecondType>> for Series

fn as_mut(&mut self) -> &mut ChunkedArray<Time64NanosecondType>

Performs the conversion.

impl AsMut<ChunkedArray<TimestampMicrosecondType>> for Series

fn as_mut(&mut self) -> &mut ChunkedArray<TimestampMicrosecondType>

Performs the conversion.

impl AsMut<ChunkedArray<TimestampMillisecondType>> for Series

fn as_mut(&mut self) -> &mut ChunkedArray<TimestampMillisecondType>

Performs the conversion.

impl AsMut<ChunkedArray<TimestampNanosecondType>> for Series

fn as_mut(&mut self) -> &mut ChunkedArray<TimestampNanosecondType>

Performs the conversion.

impl AsMut<ChunkedArray<TimestampSecondType>> for Series

fn as_mut(&mut self) -> &mut ChunkedArray<TimestampSecondType>

Performs the conversion.

impl AsMut<ChunkedArray<UInt16Type>> for Series

fn as_mut(&mut self) -> &mut ChunkedArray<UInt16Type>

Performs the conversion.

impl AsMut<ChunkedArray<UInt32Type>> for Series

fn as_mut(&mut self) -> &mut ChunkedArray<UInt32Type>

Performs the conversion.

impl AsMut<ChunkedArray<UInt64Type>> for Series

fn as_mut(&mut self) -> &mut ChunkedArray<UInt64Type>

Performs the conversion.

impl AsMut<ChunkedArray<UInt8Type>> for Series

fn as_mut(&mut self) -> &mut ChunkedArray<UInt8Type>

Performs the conversion.

impl AsMut<ChunkedArray<Utf8Type>> for Series

fn as_mut(&mut self) -> &mut ChunkedArray<Utf8Type>

Performs the conversion.

impl AsRef<ChunkedArray<BooleanType>> for Series

fn as_ref(&self) -> &ChunkedArray<BooleanType>

Performs the conversion.

impl AsRef<ChunkedArray<Date32Type>> for Series

fn as_ref(&self) -> &ChunkedArray<Date32Type>

Performs the conversion.

impl AsRef<ChunkedArray<Date64Type>> for Series

fn as_ref(&self) -> &ChunkedArray<Date64Type>

Performs the conversion.

impl AsRef<ChunkedArray<DurationMicrosecondType>> for Series

fn as_ref(&self) -> &ChunkedArray<DurationMicrosecondType>

Performs the conversion.

impl AsRef<ChunkedArray<DurationMillisecondType>> for Series

fn as_ref(&self) -> &ChunkedArray<DurationMillisecondType>

Performs the conversion.

impl AsRef<ChunkedArray<DurationNanosecondType>> for Series

fn as_ref(&self) -> &ChunkedArray<DurationNanosecondType>

Performs the conversion.

impl AsRef<ChunkedArray<DurationSecondType>> for Series

fn as_ref(&self) -> &ChunkedArray<DurationSecondType>

Performs the conversion.

impl AsRef<ChunkedArray<Float32Type>> for Series

fn as_ref(&self) -> &ChunkedArray<Float32Type>

Performs the conversion.

impl AsRef<ChunkedArray<Float64Type>> for Series

fn as_ref(&self) -> &ChunkedArray<Float64Type>

Performs the conversion.

impl AsRef<ChunkedArray<Int16Type>> for Series

fn as_ref(&self) -> &ChunkedArray<Int16Type>

Performs the conversion.

impl AsRef<ChunkedArray<Int32Type>> for Series

fn as_ref(&self) -> &ChunkedArray<Int32Type>

Performs the conversion.

impl AsRef<ChunkedArray<Int64Type>> for Series

fn as_ref(&self) -> &ChunkedArray<Int64Type>

Performs the conversion.

impl AsRef<ChunkedArray<Int8Type>> for Series

fn as_ref(&self) -> &ChunkedArray<Int8Type>

Performs the conversion.

impl AsRef<ChunkedArray<IntervalDayTimeType>> for Series

fn as_ref(&self) -> &ChunkedArray<IntervalDayTimeType>

Performs the conversion.

impl AsRef<ChunkedArray<IntervalYearMonthType>> for Series

fn as_ref(&self) -> &ChunkedArray<IntervalYearMonthType>

Performs the conversion.

impl AsRef<ChunkedArray<LargeListType>> for Series

fn as_ref(&self) -> &ChunkedArray<LargeListType>

Performs the conversion.

impl AsRef<ChunkedArray<Time32MillisecondType>> for Series

fn as_ref(&self) -> &ChunkedArray<Time32MillisecondType>

Performs the conversion.

impl AsRef<ChunkedArray<Time32SecondType>> for Series

fn as_ref(&self) -> &ChunkedArray<Time32SecondType>

Performs the conversion.

impl AsRef<ChunkedArray<Time64MicrosecondType>> for Series

fn as_ref(&self) -> &ChunkedArray<Time64MicrosecondType>

Performs the conversion.

impl AsRef<ChunkedArray<Time64NanosecondType>> for Series

fn as_ref(&self) -> &ChunkedArray<Time64NanosecondType>

Performs the conversion.

impl AsRef<ChunkedArray<TimestampMicrosecondType>> for Series

fn as_ref(&self) -> &ChunkedArray<TimestampMicrosecondType>

Performs the conversion.

impl AsRef<ChunkedArray<TimestampMillisecondType>> for Series

fn as_ref(&self) -> &ChunkedArray<TimestampMillisecondType>

Performs the conversion.

impl AsRef<ChunkedArray<TimestampNanosecondType>> for Series

fn as_ref(&self) -> &ChunkedArray<TimestampNanosecondType>

Performs the conversion.

impl AsRef<ChunkedArray<TimestampSecondType>> for Series

fn as_ref(&self) -> &ChunkedArray<TimestampSecondType>

Performs the conversion.

impl AsRef<ChunkedArray<UInt16Type>> for Series

fn as_ref(&self) -> &ChunkedArray<UInt16Type>

Performs the conversion.

impl AsRef<ChunkedArray<UInt32Type>> for Series

fn as_ref(&self) -> &ChunkedArray<UInt32Type>

Performs the conversion.

impl AsRef<ChunkedArray<UInt64Type>> for Series

fn as_ref(&self) -> &ChunkedArray<UInt64Type>

Performs the conversion.

impl AsRef<ChunkedArray<UInt8Type>> for Series

fn as_ref(&self) -> &ChunkedArray<UInt8Type>

Performs the conversion.

impl AsRef<ChunkedArray<Utf8Type>> for Series

fn as_ref(&self) -> &ChunkedArray<Utf8Type>

Performs the conversion.

impl<'_> ChunkCompare<&'_ Series> for Series

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

Check for equality and regard missing values as equal.

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.

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<'_> ChunkFillNone<&'_ Series> for LargeListChunked

fn fill_none(&self, _strategy: FillNoneStrategy) -> Result<Self>

Replace None values with one of the following strategies:

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

Replace None values with a give value T.

impl ChunkFull<Series> for LargeListChunked

fn full(_name: &str, _value: Series, _length: usize) -> LargeListChunked

Create a ChunkedArray with a single value.

fn full_null(_name: &str, _length: usize) -> LargeListChunked

impl ChunkShift<LargeListType, Series> for LargeListChunked

fn shift(
    &self,
    periods: i32,
    fill_value: &Option<Series>
) -> Result<LargeListChunked>

Shift the values by a given period and fill the parts that will be empty due to this operation with fill_value.

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

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

Formats the value using the given formatter.

impl<'_> Div<&'_ Series> for &'_ Series

type Output = Series

The resulting type after applying the / operator.

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

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

impl Div<Series> for Series

type Output = Self

The resulting type after applying the / operator.

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

Performs the / operation.

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<'a> From<&'a Series> for &'a UInt8Chunked

fn from(s: &'a Series) -> Self

Performs the conversion.

impl<'a> From<&'a Series> for &'a UInt16Chunked

fn from(s: &'a Series) -> Self

Performs the conversion.

impl<'a> From<&'a Series> for &'a BooleanChunked

fn from(s: &'a Series) -> Self

Performs the conversion.

impl<'a> From<&'a Series> for &'a Utf8Chunked

fn from(s: &'a Series) -> Self

Performs the conversion.

impl<'a> From<&'a Series> for &'a Date32Chunked

fn from(s: &'a Series) -> Self

Performs the conversion.

impl<'a> From<&'a Series> for &'a Date64Chunked

fn from(s: &'a Series) -> Self

Performs the conversion.

impl<'a> From<&'a Series> for &'a Time32MillisecondChunked

fn from(s: &'a Series) -> Self

Performs the conversion.

impl<'a> From<&'a Series> for &'a Time32SecondChunked

fn from(s: &'a Series) -> Self

Performs the conversion.

impl<'a> From<&'a Series> for &'a Time64MicrosecondChunked

fn from(s: &'a Series) -> Self

Performs the conversion.

impl<'a> From<&'a Series> for &'a Time64NanosecondChunked

fn from(s: &'a Series) -> Self

Performs the conversion.

impl<'a> From<&'a Series> for &'a DurationMillisecondChunked

fn from(s: &'a Series) -> Self

Performs the conversion.

impl<'a> From<&'a Series> for &'a DurationSecondChunked

fn from(s: &'a Series) -> Self

Performs the conversion.

impl<'a> From<&'a Series> for &'a UInt32Chunked

fn from(s: &'a Series) -> Self

Performs the conversion.

impl<'a> From<&'a Series> for &'a DurationMicrosecondChunked

fn from(s: &'a Series) -> Self

Performs the conversion.

impl<'a> From<&'a Series> for &'a DurationNanosecondChunked

fn from(s: &'a Series) -> Self

Performs the conversion.

impl<'a> From<&'a Series> for &'a TimestampMillisecondChunked

fn from(s: &'a Series) -> Self

Performs the conversion.

impl<'a> From<&'a Series> for &'a TimestampSecondChunked

fn from(s: &'a Series) -> Self

Performs the conversion.

impl<'a> From<&'a Series> for &'a TimestampMicrosecondChunked

fn from(s: &'a Series) -> Self

Performs the conversion.

impl<'a> From<&'a Series> for &'a TimestampNanosecondChunked

fn from(s: &'a Series) -> Self

Performs the conversion.

impl<'a> From<&'a Series> for &'a IntervalDayTimeChunked

fn from(s: &'a Series) -> Self

Performs the conversion.

impl<'a> From<&'a Series> for &'a IntervalYearMonthChunked

fn from(s: &'a Series) -> Self

Performs the conversion.

impl<'a> From<&'a Series> for &'a LargeListChunked

fn from(s: &'a Series) -> Self

Performs the conversion.

impl<'a> From<&'a Series> for &'a UInt64Chunked

fn from(s: &'a Series) -> Self

Performs the conversion.

impl<'a> From<&'a Series> for &'a Int8Chunked

fn from(s: &'a Series) -> Self

Performs the conversion.

impl<'a> From<&'a Series> for &'a Int16Chunked

fn from(s: &'a Series) -> Self

Performs the conversion.

impl<'a> From<&'a Series> for &'a Int32Chunked

fn from(s: &'a Series) -> Self

Performs the conversion.

impl<'a> From<&'a Series> for &'a Int64Chunked

fn from(s: &'a Series) -> Self

Performs the conversion.

impl<'a> From<&'a Series> for &'a Float32Chunked

fn from(s: &'a Series) -> Self

Performs the conversion.

impl<'a> From<&'a Series> for &'a Float64Chunked

fn from(s: &'a Series) -> Self

Performs the conversion.

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

fn from(name_arr: (&str, ArrayRef)) -> Self

Performs the conversion.

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

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

Performs the conversion.

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

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

Creates a value from an iterator.

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

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

Creates a value from an iterator.

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

fn from_iter<I: IntoIterator<Item = Option<Series>>>(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 LargeListChunked

fn from_iter<I: IntoIterator<Item = Series>>(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<Series> for Series

fn from_iter<I: IntoIterator<Item = Series>>(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<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 &'_ Series

type Output = Series

The resulting type after applying the * operator.

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

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

impl Mul<Series> for Series

type Output = Self

The resulting type after applying the * operator.

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

Performs the * operation.

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, LargeListType> for Series

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

Initialize by name and values.

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

type Output = Self

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.