Type Definition polars::datatypes::ListChunked

type ListChunked = ChunkedArray<ListType>;

Implementations

impl ListChunked

pub fn to_ndarray<N>(&self) -> Result<Array2<N::Native>> where
    N: PolarsNumericType, 

This is supported on crate feature ndarray only.

If all nested Series have the same length, a 2 dimensional ndarray::Array is returned.

impl ListChunked

pub fn explode(&self) -> Result<(Series, Vec<usize>)>

Trait Implementations

impl ChunkCast for ListChunked

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

Cast ChunkedArray<T> to ChunkedArray<N>

impl ChunkCompare<&'_ ChunkedArray<ListType>> for ListChunked

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

Check for equality and regard missing values as equal.

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

Check for equality.

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

Check for inequality.

pub fn gt(&self, _rhs: &ListChunked) -> BooleanChunked

Greater than comparison.

pub fn gt_eq(&self, _rhs: &ListChunked) -> BooleanChunked

Greater than or equal comparison.

pub fn lt(&self, _rhs: &ListChunked) -> BooleanChunked

Less than comparison.

pub fn lt_eq(&self, _rhs: &ListChunked) -> BooleanChunked

Less than or equal comparison

impl ChunkExpandAtIndex<ListType> for ListChunked

pub fn expand_at_index(&self, _index: usize, _length: usize) -> ListChunked

Create a new ChunkedArray filled with values at that index.

impl ChunkFillNone for ListChunked

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

Replace None values with one of the following strategies:

impl ChunkFillNoneValue<&'_ Series> for ListChunked

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

Replace None values with a give value T.

impl ChunkFilter<ListType> for ListChunked

pub fn filter(&self, filter: &BooleanChunked) -> Result<ListChunked>

Filter values in the ChunkedArray with a boolean mask.

impl ChunkFull<&'_ (dyn SeriesTrait + '_)> for ListChunked

pub fn full(
    _name: &str,
    _value: &dyn SeriesTrait,
    _length: usize
) -> ListChunked

Create a ChunkedArray with a single value.

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

impl ChunkOps for ListChunked

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

Aggregate to chunk id. A chunk id is a vector of the chunk lengths.

pub fn optional_rechunk<A>(&self, rhs: &ChunkedArray<A>) -> Result<Option<Self>>

Only rechunk if lhs and rhs don't match

impl ChunkReverse<ListType> for ListChunked

pub fn reverse(&self) -> Self

Return a reversed version of this array.

impl ChunkShift<ListType> for ListChunked

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

impl ChunkShiftFill<ListType, Option<&'_ Series>> for ListChunked

pub fn shift_and_fill(
    &self,
    periods: i32,
    fill_value: Option<&Series>
) -> Result<ListChunked>

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

impl ChunkSort<ListType> for ListChunked

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

Returned a sorted ChunkedArray.

pub fn sort_in_place(&mut self, _reverse: bool)

Sort this array in place.

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

Retrieve the indexes needed to sort this array.

impl ChunkTake for ListChunked

pub fn take(
    &self,
    indices: impl Iterator<Item = usize>,
    capacity: Option<usize>
) -> Self

Take values from ChunkedArray by index.

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

Take values from ChunkedArray by index

pub fn take_opt(
    &self,
    indices: impl Iterator<Item = Option<usize>>,
    capacity: Option<usize>
) -> Self

Take values from ChunkedArray by Option.

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

Take values from ChunkedArray by Option.

pub fn take_from_single_chunked(&self, idx: &UInt32Chunked) -> Result<Self>

pub fn take_from_single_chunked_iter(
    &self,
    indices: impl Iterator<Item = usize>
) -> Result<Self> where
    Self: Sized, 

impl ChunkUnique<ListType> for ListChunked

pub fn unique(&self) -> Result<ChunkedArray<ListType>>

Get unique values of a ChunkedArray

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

Get first index of the unique values in a ChunkedArray. This Vec is sorted.

pub fn n_unique(&self) -> Result<usize>

Number of unique values in the ChunkedArray

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

Get a mask of all the unique values.

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

Get a mask of all the duplicated values.

pub fn value_counts(&self) -> Result<DataFrame>

Count the unique values.

impl ChunkVar<Series> for ListChunked

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

Compute the variance of this ChunkedArray/Series.

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

Compute the standard deviation of this ChunkedArray/Series.

impl ChunkWindow for ListChunked

pub fn rolling_sum(
    &self,
    _window_size: usize,
    _weight: Option<&[f64]>,
    _ignore_null: bool
) -> Result<Self> where
    Self: Sized, 

Apply a rolling sum (moving sum) over the values in this array. A window of length window_size will traverse the array. The values that fill this window will (optionally) be multiplied with the weights given by the weight vector. The resulting values will be aggregated to their sum.

pub fn rolling_mean(
    &self,
    _window_size: usize,
    _weight: Option<&[f64]>,
    _ignore_null: bool
) -> Result<Self> where
    Self: Sized, 

Apply a rolling mean (moving mean) over the values in this array. A window of length window_size will traverse the array. The values that fill this window will (optionally) be multiplied with the weights given by the weight vector. The resulting values will be aggregated to their mean.

pub fn rolling_min(
    &self,
    _window_size: usize,
    _weight: Option<&[f64]>,
    _ignore_null: bool
) -> Result<Self> where
    Self: Sized, 

Apply a rolling min (moving min) over the values in this array. A window of length window_size will traverse the array. The values that fill this window will (optionally) be multiplied with the weights given by the weight vector. The resulting values will be aggregated to their min.

pub fn rolling_max(
    &self,
    _window_size: usize,
    _weight: Option<&[f64]>,
    _ignore_null: bool
) -> Result<Self> where
    Self: Sized, 

Apply a rolling max (moving max) over the values in this array. A window of length window_size will traverse the array. The values that fill this window will (optionally) be multiplied with the weights given by the weight vector. The resulting values will be aggregated to their max.

impl ChunkZip<ListType> for ListChunked

pub fn zip_with(
    &self,
    _mask: &BooleanChunked,
    _other: &ChunkedArray<ListType>
) -> Result<ChunkedArray<ListType>>

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

pub fn zip_with_series(
    &self,
    _mask: &BooleanChunked,
    _other: &Series
) -> Result<ChunkedArray<ListType>>

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

impl CompToSeries for ListChunked

pub fn lt_series(&self, _rhs: &Series) -> BooleanChunked

pub fn gt_series(&self, _rhs: &Series) -> BooleanChunked

pub fn gt_eq_series(&self, _rhs: &Series) -> BooleanChunked

pub fn lt_eq_series(&self, _rhs: &Series) -> BooleanChunked

pub fn eq_series(&self, _rhs: &Series) -> BooleanChunked

pub fn neq_series(&self, _rhs: &Series) -> BooleanChunked

impl Debug for ListChunked

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

Formats the value using the given formatter.

impl Downcast<GenericListArray<i32>> for ListChunked

pub fn downcast_chunks(&self) -> Vec<&ListArray>

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

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

Creates a value from an iterator.

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

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

Creates a value from an iterator.

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

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

Creates a value from an iterator.

impl FromIterator<Option<Arc<dyn SeriesTrait + 'static>>> for ListChunked

pub fn from_iter<I: IntoIterator<Item = Option<Arc<dyn SeriesTrait>>>>(
    iter: I
) -> Self

Creates a value from an iterator.

impl FromIterator<Option<Series>> for ListChunked

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

Creates a value from an iterator.

impl FromIterator<Series> for ListChunked

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

Creates a value from an iterator.

impl IntoGroupTuples for ListChunked

pub fn group_tuples(&self) -> Vec<(usize, Vec<usize>)>

Create the tuples need for a groupby operation. * The first value in te tuple is the first index of the group. * The second value in the tuple is are the indexes of the groups including the first value.

impl<'a> IntoIterator for &'a ListChunked

type Item = Option<Series>

The type of the elements being iterated over.

type IntoIter = Box<dyn PolarsIterator<Item = Self::Item> + 'a>

Which kind of iterator are we turning this into?

pub fn into_iter(self) -> Self::IntoIter

Decides which iterator fits best the current chunked array. The decision are based on the number of chunks and the existence of null values.

impl<'a> IntoNoNullIterator for &'a ListChunked

type Item = Series

type IntoIter = Box<dyn PolarsIterator<Item = Self::Item> + 'a>

pub fn into_no_null_iter(self) -> Self::IntoIter

Decides which iterator fits best the current no null chunked array. The decision are based on the number of chunks.

impl<'a> IntoParallelIterator for &'a ListChunked

This is supported on crate feature parallel only.

Convert $ca_iter into a ParallelIterator using the most efficient ParallelIterator implementation for the given $ca_type.

• If $ca_type has only a chunk and has no null values, it uses $single_chunk_return_option.
• If $ca_type has only a chunk and does have null values, it uses $single_chunk_null_check_return_option.
• If $ca_type has many chunks and has no null values, it uses $many_chunk_return_option.
• If $ca_type has many chunks and does have null values, it uses $many_chunk_null_check_return_option.

type Iter = ListParIterDispatcher<'a>

The parallel iterator type that will be created.

type Item = Option<Series>

The type of item that the parallel iterator will produce.

pub fn into_par_iter(self) -> Self::Iter

Converts self into a parallel iterator.

impl IntoSeries for ListChunked

pub fn into_series(self) -> Series

impl<'a> IntoTakeRandom<'a> for &'a ListChunked

type Item = Series

type TakeRandom = Box<dyn TakeRandom<Item = Self::Item> + 'a>

pub fn take_rand(&self) -> Self::TakeRandom

Create a type that implements TakeRandom.

impl NumOpsDispatch for ListChunked

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

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

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

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

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

impl TakeRandom for ListChunked

type Item = Series

pub fn get(&self, index: usize) -> Option<Self::Item>

Get a nullable value by index.

pub unsafe fn get_unchecked(&self, index: usize) -> Self::Item

Get a value by index and ignore the null bit.

impl ToDummies<ListType> for ListChunked

pub fn to_dummies(&self) -> Result<DataFrame>

impl ZipOuterJoinColumn for ListChunked

pub fn zip_outer_join_column(
    &self,
    _right_column: &Series,
    _opt_join_tuples: &[(Option<usize>, Option<usize>)]
) -> Series