Type Alias polars_core::datatypes::ListChunked

pub type ListChunked = ChunkedArray<ListType>;

Aliased Type

struct ListChunked { /* private fields */ }

Implementations

impl ListChunked

pub fn full_null_with_dtype( name: &str, length: usize, inner_dtype: &DataType ) -> ListChunked

impl ListChunked

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

pub fn par_iter_indexed( &mut self ) -> impl IndexedParallelIterator<Item = Option<Series>> + '_

impl ListChunked

pub fn to_ndarray<N>(&self) -> PolarsResult<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 saves allocations. A Series is: 1. Arc<ChunkedArray> 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<…>

If the returned AmortSeries is cloned, the local copy will be replaced and a new container will be set.

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

See amortized_iter.

pub fn apply_amortized_generic<F, K, V>(&self, f: F) -> ChunkedArray<V>

where V: PolarsDataType, F: FnMut(Option<AmortSeries>) -> Option<K> + Copy, V::Array: ArrayFromIter<Option<K>>,

Apply a closure F elementwise.

pub fn try_apply_amortized_generic<F, K, V>( &self, f: F ) -> PolarsResult<ChunkedArray<V>>

where V: PolarsDataType, F: FnMut(Option<AmortSeries>) -> PolarsResult<Option<K>> + Copy, V::Array: ArrayFromIter<Option<K>>,

pub fn for_each_amortized<F>(&self, f: F)

where F: FnMut(Option<AmortSeries>),

pub fn zip_and_apply_amortized<'a, T, I, F>( &'a self, ca: &'a ChunkedArray<T>, f: F ) -> Self

where T: PolarsDataType, &'a ChunkedArray<T>: IntoIterator<IntoIter = I>, I: TrustedLen<Item = Option<T::Physical<'a>>>, F: FnMut(Option<AmortSeries>, Option<T::Physical<'a>>) -> Option<Series>,

Zip with a ChunkedArray then apply a binary function F elementwise.

pub fn binary_zip_and_apply_amortized<'a, T, U, F>( &'a self, ca1: &'a ChunkedArray<T>, ca2: &'a ChunkedArray<U>, f: F ) -> Self

where T: PolarsDataType, U: PolarsDataType, F: FnMut(Option<AmortSeries>, Option<T::Physical<'a>>, Option<U::Physical<'a>>) -> Option<Series>,

pub fn try_zip_and_apply_amortized<'a, T, I, F>( &'a self, ca: &'a ChunkedArray<T>, f: F ) -> PolarsResult<Self>

where T: PolarsDataType, &'a ChunkedArray<T>: IntoIterator<IntoIter = I>, I: TrustedLen<Item = Option<T::Physical<'a>>>, F: FnMut(Option<AmortSeries>, Option<T::Physical<'a>>) -> PolarsResult<Option<Series>>,

pub fn apply_amortized<F>(&self, f: F) -> Self

where F: FnMut(AmortSeries) -> Series,

Apply a closure F elementwise.

pub fn try_apply_amortized<F>(&self, f: F) -> PolarsResult<Self>

where F: FnMut(AmortSeries) -> PolarsResult<Series>,

impl ListChunked

pub fn inner_dtype(&self) -> &DataType

Get the inner data type of the list.

pub fn set_inner_dtype(&mut self, dtype: DataType)

pub fn set_fast_explode(&mut self)

pub fn _can_fast_explode(&self) -> bool

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

Set the logical type of the ListChunked.

Safety

The caller must ensure that the logical type given fits the physical type of the array.

pub fn get_inner(&self) -> Series

Get the inner values as Series, ignoring the list offsets.

pub fn iter_offsets(&self) -> impl Iterator<Item = i64> + '_

Returns an iterator over the offsets of this chunked array.

The offsets are returned as though the array consisted of a single chunk.

pub fn apply_to_inner( &self, func: &dyn Fn(Series) -> PolarsResult<Series> ) -> PolarsResult<ListChunked>

Ignore the list indices and apply func to the inner type as Series.

impl ListChunked

pub fn get_as_series(&self, idx: usize) -> Option<Series>

Trait Implementations

impl AggList for ListChunked

Available on crate feature algorithm_group_by only.

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

Safety

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) -> PolarsResult<AnyValue<'_>>

Get a single value. Beware this is slow.

impl<'a> ChunkApply<'a, Series> for ListChunked

fn apply_values<F>(&'a self, f: F) -> Self

where F: Fn(Series) -> Series + Copy,

Apply a closure F elementwise.

type FuncRet = Series

fn apply<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_with_options( &self, data_type: &DataType, options: CastOptions ) -> PolarsResult<Series>

Cast a ChunkedArray to DataType

unsafe fn cast_unchecked(&self, data_type: &DataType) -> PolarsResult<Series>

Does not check if the cast is a valid one and may over/underflow

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

Cast a ChunkedArray to DataType

impl ChunkCompare<&ChunkedArray<ListType>> for ListChunked

type Item = ChunkedArray<BooleanType>

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

Check for equality.

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

Check for equality where None == None.

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

Check for inequality.

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

Check for inequality where None == None.

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 new_from_index(&self, index: usize, length: usize) -> ListChunked

Create a new ChunkedArray filled with values at that index.

impl ChunkExplode for ListChunked

fn offsets(&self) -> PolarsResult<OffsetsBuffer<i64>>

fn explode_and_offsets(&self) -> PolarsResult<(Series, OffsetsBuffer<i64>)>

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

impl ChunkFilter<ListType> for ListChunked

fn filter(&self, filter: &BooleanChunked) -> PolarsResult<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 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 ) -> PolarsResult<Option<T>>

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

impl ChunkReverse 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 ChunkVar for ListChunked

fn var(&self, _ddof: u8) -> Option<f64>

Compute the variance of this ChunkedArray/Series.

fn std(&self, _ddof: u8) -> Option<f64>

Compute the standard deviation of this ChunkedArray/Series.

impl Debug for ListChunked

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

Formats the value using the given formatter.

impl FromIterator<Option<Box<dyn Array>>> 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 FromParIterWithDtype<Option<Series>> for ListChunked

fn from_par_iter_with_dtype<I>(iter: I, name: &str, dtype: DataType) -> Self

where I: IntoParallelIterator<Item = Option<Series>>, Self: Sized,

impl FromParallelIterator<Option<Series>> for ListChunked

fn from_par_iter<I>(par_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

Available on crate feature algorithm_group_by only.

fn group_tuples<'a>( &'a self, multithreaded: bool, sorted: bool ) -> PolarsResult<GroupsProxy>

Create the tuples need for a group_by operation. * The first value in the tuple is the first index of the group. * The second value in the tuple is 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>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl ValueSize for ListChunked

fn get_values_size(&self) -> usize

Get the values size that is still “visible” to the underlying array. E.g. take the offsets into account.