Type Definition polars_core::datatypes::ObjectChunked

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

Available on crate feature object only.

Implementations

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

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

pub fn new_empty(name: &str) -> 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>

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

Safety

impl<T: PolarsObject> 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: PolarsObject> 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) -> PolarsResult<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) -> Selfwhere
    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) -> PolarsResult<Self>where
    F: Fn(&'a T) -> PolarsResult<T> + Copy,

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

Apply a closure elementwise including null values.

fn apply_with_idx<F>(&'a self, _f: F) -> Selfwhere
    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) -> Selfwhere
    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 new_from_index(&self, index: usize, length: usize) -> ObjectChunked<T>

Create a new ChunkedArray filled with values at that index.

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

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

Replace None values with one of the following strategies:

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

fn fill_null_with_values(&self, _value: ObjectType<T>) -> PolarsResult<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
) -> PolarsResult<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) -> Selfwhere
    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: PolarsObject> 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
) -> PolarsResult<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: PolarsObject> ChunkShift<ObjectType<T>> for ObjectChunked<T>

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

impl<T: PolarsObject> 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>
) -> Selfwhere
    Self: Sized,
    I: TakeIterator,
    INulls: TakeIteratorNulls,

Take values from ChunkedArray by index.

fn take<I, INulls>(&self, indices: TakeIdx<'_, I, INulls>) -> PolarsResult<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: PolarsObject> 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: PolarsObject> ChunkUnique<ObjectType<T>> for ObjectChunked<T>

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

Get unique values of a ChunkedArray

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

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

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

Number of unique values in the ChunkedArray

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

Get a mask of all the unique values.

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

Get a mask of all the duplicated values.

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

Available on crate feature mode only.

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

impl<T: PolarsObject> ChunkVar<Series> for ObjectChunked<T>

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

Compute the variance of this ChunkedArray/Series.

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

Compute the standard deviation of this ChunkedArray/Series.

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

Available on crate feature zip_with only.

fn zip_with(
    &self,
    mask: &BooleanChunked,
    other: &ChunkedArray<ObjectType<T>>
) -> PolarsResult<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
) -> PolarsResult<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 = <&'a ChunkedArray<ObjectType<T>> 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<'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<'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> VecHash for ObjectChunked<T>where
    T: PolarsObject,

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

Compute the hash for all values in the array.

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