Type Definition polars_core::datatypes::ObjectChunked

pub type ObjectChunked<T> = ChunkedArray<ObjectType<T>>;

Implementations

impl<T> ObjectChunked<T> where
    T: PolarsObject, 

pub fn new_from_vec(name: &str, v: Vec<T>) -> Self

impl<T> ObjectChunked<T> where
    T: PolarsObject, 

pub unsafe fn get_object_unchecked(
    &self,
    index: usize
) -> Option<&dyn PolarsObjectSafe>

Get a hold to an object that can be formatted or downcasted via the Any trait.

Safety

No bounds checks

pub fn get_object(&self, index: usize) -> Option<&dyn PolarsObjectSafe>

Get a hold to an object that can be formatted or downcasted via the Any trait.

Trait Implementations

impl<T: PolarsObject> AggList for ObjectChunked<T>

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

impl<T> ArgAgg for ObjectChunked<T>

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<T> ChunkAggSeries for ObjectChunked<T>

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<T: PolarsObject> ChunkAnyValue for ObjectChunked<T>

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, T> ChunkApply<'a, &'a T, T> for ObjectChunked<T> where
    T: PolarsObject, 

fn apply_cast_numeric<F, S>(&'a self, _f: F) -> ChunkedArray<S> where
    F: Fn(&'a T) -> 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>(&'a self, _f: F) -> ChunkedArray<S> where
    F: Fn(Option<&'a T>) -> S::Native + Copy,
    S: PolarsNumericType, 

Apply a closure on optional values and cast to Numeric ChunkedArray without null values.

fn apply<F>(&'a self, f: F) -> Self where
    F: Fn(&'a T) -> T + Copy, 

Apply a closure elementwise. This is fastest when the null check branching is more expensive than the closure application. Often it is.

fn try_apply<F>(&'a self, _f: F) -> Result<Self> where
    F: Fn(&'a T) -> Result<T> + Copy, 

fn apply_on_opt<F>(&'a self, f: F) -> Self where
    F: Fn(Option<&'a T>) -> Option<T> + Copy, 

Apply a closure elementwise including null values.

fn apply_with_idx<F>(&'a self, _f: F) -> Self where
    F: Fn((usize, &'a T)) -> T + 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<&'a T>)) -> Option<T> + Copy, 

Apply a closure elementwise. The closure gets the index of the element as first argument.

fn apply_to_slice<F, V>(&'a self, f: F, slice: &mut [V]) where
    F: Fn(Option<&'a T>, &V) -> V, 

Apply a closure elementwise and write results to a mutable slice.

impl<T: PolarsObject> ChunkExpandAtIndex<ObjectType<T>> for ObjectChunked<T>

fn expand_at_index(&self, index: usize, length: usize) -> ObjectChunked<T>

Create a new ChunkedArray filled with values at that index.

impl<T> ChunkFillNull for ObjectChunked<T>

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

Replace None values with one of the following strategies:

impl<T> ChunkFillNullValue<ObjectType<T>> for ObjectChunked<T>

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

Replace None values with a give value T.

impl<T> ChunkFilter<ObjectType<T>> for ObjectChunked<T> where
    T: PolarsObject, 

fn filter(&self, filter: &BooleanChunked) -> Result<ChunkedArray<ObjectType<T>>> where
    Self: Sized, 

Filter values in the ChunkedArray with a boolean mask.

impl<T: PolarsObject> ChunkFull<T> for ObjectChunked<T>

fn full(name: &str, value: T, length: usize) -> Self where
    Self: Sized, 

Create a ChunkedArray with a single value.

impl<T: PolarsObject> ChunkFullNull for ObjectChunked<T>

fn full_null(name: &str, length: usize) -> ObjectChunked<T>

impl<T> ChunkOps for ObjectChunked<T> where
    T: PolarsObject, 

fn rechunk(&self) -> Self where
    Self: Sized, 

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<T> ChunkQuantile<Series> for ObjectChunked<T>

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<T: PolarsObject> ChunkReverse<ObjectType<T>> for ObjectChunked<T>

fn reverse(&self) -> Self

Return a reversed version of this array.

impl<T> ChunkShift<ObjectType<T>> for ObjectChunked<T>

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

impl<T> ChunkShiftFill<ObjectType<T>, Option<ObjectType<T>>> for ObjectChunked<T>

fn shift_and_fill(
    &self,
    _periods: i64,
    _fill_value: Option<ObjectType<T>>
) -> ChunkedArray<ObjectType<T>>

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

impl<T: PolarsObject> ChunkTake for ObjectChunked<T>

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<T> ChunkTakeEvery<ObjectType<T>> for ObjectChunked<T>

fn take_every(&self, _n: usize) -> ObjectChunked<T>

Traverse and collect every nth element in a new array.

impl<T> ChunkUnique<ObjectType<T>> for ObjectChunked<T>

fn unique(&self) -> Result<ChunkedArray<ObjectType<T>>>

Get unique values of a ChunkedArray

fn arg_unique(&self) -> Result<IdxCa>

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

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

Number of unique values in the ChunkedArray

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

Get a mask of all the unique values.

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

Get a mask of all the duplicated values.

fn mode(&self) -> Result<ChunkedArray<T>>

The most occurring value(s). Can return multiple Values

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<T: PolarsObject> ChunkZip<ObjectType<T>> for ObjectChunked<T>

fn zip_with(
    &self,
    mask: &BooleanChunked,
    other: &ChunkedArray<ObjectType<T>>
) -> Result<ChunkedArray<ObjectType<T>>>

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

impl<T> Debug for ObjectChunked<T> where
    T: PolarsObject, 

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

Formats the value using the given formatter.

impl<T: PolarsObject> FromIterator<Option<T>> for ObjectChunked<T>

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

Creates a value from an iterator.

impl<T: PolarsObject> FromTrustedLenIterator<Option<T>> for ObjectChunked<T>

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

impl<T> IntoGroupsProxy for ObjectChunked<T> where
    T: PolarsObject, 

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, T> IntoIterator for &'a ObjectChunked<T> where
    T: PolarsObject, 

type Item = Option<&'a T>

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?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T> IntoSeries for ObjectChunked<T> where
    T: PolarsObject, 

fn into_series(self) -> Series

fn is_series() -> bool

impl<'a, T: PolarsObject> IntoTakeRandom<'a> for &'a ObjectChunked<T>

type Item = &'a T

type TakeRandom = TakeRandBranch2<ObjectTakeRandomSingleChunk<'a, T>, ObjectTakeRandom<'a, T>>

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

Create a type that implements TakeRandom.

impl<T: PolarsObject> NamedFrom<&'_ [T], &'_ [T]> for ObjectChunked<T>

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

Initialize by name and values.

impl<T: PolarsObject, S: AsRef<[Option<T>]>> NamedFrom<S, [Option<T>]> for ObjectChunked<T>

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

Initialize by name and values.

impl<T> NewChunkedArray<ObjectType<T>, T> for ObjectChunked<T> where
    T: PolarsObject, 

fn from_iter_values(name: &str, it: impl Iterator<Item = T>) -> ObjectChunked<T>

Create a new ChunkedArray from an iterator.

fn from_slice(name: &str, v: &[T]) -> Self

fn from_slice_options(name: &str, opt_v: &[Option<T>]) -> Self

fn from_iter_options(
    name: &str,
    it: impl Iterator<Item = Option<T>>
) -> ObjectChunked<T>

Create a new ChunkedArray from an iterator.

impl<T> QuantileAggSeries for ObjectChunked<T>

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<'a, T: PolarsObject> TakeRandom for &'a ObjectChunked<T>

type Item = &'a T

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<T> VarAggSeries for ObjectChunked<T>

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.

impl<T> VecHash for ObjectChunked<T> where
    T: PolarsObject, 

fn vec_hash(&self, random_state: RandomState) -> Vec<u64>

Compute the hash for all values in the array.

fn vec_hash_combine(&self, random_state: RandomState, hashes: &mut [u64])