Type Definition polars_core::datatypes::ListChunked

pub type ListChunked = ChunkedArray<ListType>;

Implementations

impl ListChunked

pub fn par_iter(&self) -> impl ParallelIterator<Item = Option<Series>> + '_

impl ListChunked

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

Available on crate feature ndarray only.

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

impl ListChunked

pub fn amortized_iter(
    &self
) -> AmortizedListIter<'_, impl Iterator<Item = Option<ArrayBox>> + '_>

This is an iterator over a ListChunked that save allocations. A Series is: 1. Arc ChunkedArray is: 2. Vec< 3. ArrayRef>

The ArrayRef we indicated with 3. will be updated during iteration. The Series will be pinned in memory, saving an allocation for

1. Arc<..>
2. Vec<…>

Warning

Though memory safe in the sense that it will not read unowned memory, UB, or memory leaks this function still needs precautions. The returned should never be cloned or taken longer than a single iteration, as every call on next of the iterator will change the contents of that Series.

pub fn apply_amortized<'a, F>(&'a self, f: F) -> Self where
    F: FnMut(UnstableSeries<'a>) -> Series, 

Apply a closure F elementwise.

pub fn try_apply_amortized<'a, F>(&'a self, f: F) -> Result<Self> where
    F: FnMut(UnstableSeries<'a>) -> Result<Series>, 

impl ListChunked

pub fn lst_join(&self, separator: &str) -> Result<Utf8Chunked>

Available on crate feature list only.

In case the inner dtype DataType::Utf8, the individual items will be joined into a single string separated by separator.

pub fn lst_max(&self) -> Series

Available on crate feature list only.

pub fn lst_min(&self) -> Series

Available on crate feature list only.

pub fn lst_sum(&self) -> Series

Available on crate feature list only.

pub fn lst_mean(&self) -> Float64Chunked

Available on crate feature list only.

pub fn lst_sort(&self, reverse: bool) -> ListChunked

Available on crate feature list only.

pub fn lst_reverse(&self) -> ListChunked

Available on crate feature list only.

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

Available on crate feature list only.

pub fn lst_arg_min(&self) -> IdxCa

Available on crate feature list only.

pub fn lst_arg_max(&self) -> IdxCa

Available on crate feature list only.

pub fn lst_diff(&self, n: usize, null_behavior: NullBehavior) -> ListChunked

Available on crate features list and diff only.

pub fn lst_shift(&self, periods: i64) -> ListChunked

Available on crate feature list only.

pub fn lst_slice(&self, offset: i64, length: usize) -> ListChunked

Available on crate feature list only.

pub fn lst_lengths(&self) -> UInt32Chunked

Available on crate feature list only.

pub fn lst_get(&self, idx: i64) -> Result<Series>

Available on crate feature list only.

Get the value by index in the sublists. So index 0 would return the first item of every sublist and index -1 would return the last item of every sublist if an index is out of bounds, it will return a None.

pub fn lst_concat(&self, other: &[Series]) -> Result<ListChunked>

Available on crate feature list only.

impl ListChunked

pub fn set_fast_explode(&mut self)

pub fn to_logical(&mut self, inner_dtype: DataType)

impl ListChunked

pub fn inner_dtype(&self) -> DataType

Get the inner data type of the list.

Trait Implementations

impl AggList for ListChunked

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

impl ArgAgg for ListChunked

fn arg_min(&self) -> Option<usize>

Get the index of the minimal value

fn arg_max(&self) -> Option<usize>

Get the index of the maximal value

impl ChunkAggSeries for ListChunked

fn sum_as_series(&self) -> Series

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

fn max_as_series(&self) -> Series

Get the max of the ChunkedArray as a new Series of length 1.

fn min_as_series(&self) -> Series

Get the min of the ChunkedArray as a new Series of length 1.

fn prod_as_series(&self) -> Series

Get the product of the ChunkedArray as a new Series of length 1.

impl ChunkAnyValue for ListChunked

unsafe fn get_any_value_unchecked(&self, index: usize) -> AnyValue<'_>

Get a single value. Beware this is slow. If you need to use this slightly performant, cast Categorical to UInt32

fn get_any_value(&self, index: usize) -> AnyValue<'_>

Get a single value. Beware this is slow.

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 ChunkCast for ListChunked

We cannot cast anything to or from List/LargeList So this implementation casts the inner type

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

Cast a [ChunkedArray] to [DataType]

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

type Item = ChunkedArray<BooleanType>

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

Check for equality and regard missing values as equal.

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

Check for equality.

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

Check for inequality.

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

Greater than comparison.

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

Greater than or equal comparison.

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

Less than comparison.

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

Less than or equal comparison

impl ChunkExpandAtIndex<ListType> for ListChunked

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

Create a new ChunkedArray filled with values at that index.

impl ChunkExplode for ListChunked

fn explode_and_offsets(&self) -> Result<(Series, Buffer<i64>)>

fn explode(&self) -> Result<Series>

impl ChunkFillNull for ListChunked

fn fill_null(&self, _strategy: FillNullStrategy) -> Result<Self>

Replace None values with one of the following strategies:

impl ChunkFillNullValue<&'_ Series> for ListChunked

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

Replace None values with a give value T.

impl ChunkFilter<ListType> for ListChunked

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

Filter values in the ChunkedArray with a boolean mask.

impl ChunkFull<&'_ Series> for ListChunked

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

Create a ChunkedArray with a single value.

impl ChunkFullNull for ListChunked

fn full_null(name: &str, length: usize) -> ListChunked

impl ChunkOps for ListChunked

fn rechunk(&self) -> Self

Aggregate to contiguous memory.

fn slice(&self, offset: i64, length: usize) -> Self

Slice the array. The chunks are reallocated the underlying data slices are zero copy.

fn limit(&self, num_elements: usize) -> Self where
    Self: Sized, 

Take a view of top n elements

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

Get the head of the ChunkedArray

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

Get the tail of the ChunkedArray

impl ChunkQuantile<Series> for ListChunked

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

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

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

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

impl ChunkReverse<ListType> for ListChunked

fn reverse(&self) -> Self

Return a reversed version of this array.

impl ChunkShift<ListType> for ListChunked

fn shift(&self, periods: i64) -> Self

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

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

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

impl ChunkTake for ListChunked

unsafe fn take_unchecked<I, INulls>(
    &self,
    indices: TakeIdx<'_, I, INulls>
) -> Self where
    Self: Sized,
    I: TakeIterator,
    INulls: TakeIteratorNulls, 

Take values from ChunkedArray by index.

fn take<I, INulls>(&self, indices: TakeIdx<'_, I, INulls>) -> Result<Self> where
    Self: Sized,
    I: TakeIterator,
    INulls: TakeIteratorNulls, 

Take values from ChunkedArray by index. Note that the iterator will be cloned, so prefer an iterator that takes the owned memory by reference.

impl ChunkTakeEvery<ListType> for ListChunked

fn take_every(&self, n: usize) -> ListChunked

Traverse and collect every nth element in a new array.

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 ChunkZip<ListType> for ListChunked

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

impl Debug for ListChunked

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

Formats the value using the given formatter.

impl FromIterator<Option<Box<dyn Array + 'static, Global>>> for ListChunked

fn from_iter<I: IntoIterator<Item = Option<Box<dyn Array>>>>(iter: I) -> Self

Creates a value from an iterator.

impl FromIterator<Option<Series>> for ListChunked

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

Creates a value from an iterator.

impl<Ptr> FromIterator<Ptr> for ListChunked where
    Ptr: Borrow<Series>, 

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

Creates a value from an iterator.

impl FromParallelIterator<Option<Series>> for ListChunked

fn from_par_iter<I>(iter: I) -> Self where
    I: IntoParallelIterator<Item = Option<Series>>, 

Creates an instance of the collection from the parallel iterator par_iter.

impl FromTrustedLenIterator<Option<Series>> for ListChunked

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

impl<Ptr> FromTrustedLenIterator<Ptr> for ListChunked where
    Ptr: Borrow<Series>, 

fn from_iter_trusted_length<I: IntoIterator<Item = Ptr>>(iter: I) -> Self

impl IntoGroupsProxy for ListChunked

fn group_tuples(&self, _multithreaded: bool, _sorted: bool) -> GroupsProxy

Create the tuples need for a groupby operation. * The first value in the 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 = <&'a ChunkedArray<ListType> as IntoIterator>::Item> + 'a, Global>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl IntoSeries for ListChunked

fn into_series(self) -> Series

fn is_series() -> bool

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

type Item = Series

type TakeRandom = TakeRandBranch2<ListTakeRandomSingleChunk<'a>, ListTakeRandom<'a>>

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

Create a type that implements TakeRandom.

impl QuantileAggSeries for ListChunked

fn quantile_as_series(
    &self,
    _quantile: f64,
    _interpol: QuantileInterpolOptions
) -> Result<Series>

Get the quantile of the ChunkedArray as a new Series of length 1.

fn median_as_series(&self) -> Series

Get the median of the ChunkedArray as a new Series of length 1.

impl TakeRandom for ListChunked

type Item = Series

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

Get a nullable value by index.

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

Get a value by index and ignore the null bit.

impl ValueSize for ListChunked

fn get_values_size(&self) -> usize

Useful for a Utf8 or a List to get underlying value size. During a rechunk this is handy

impl VarAggSeries for ListChunked

fn var_as_series(&self) -> Series

Get the variance of the ChunkedArray as a new Series of length 1.

fn std_as_series(&self) -> Series

Get the standard deviation of the ChunkedArray as a new Series of length 1.