Type Definition polars_core::datatypes::Utf8Chunked

pub type Utf8Chunked = ChunkedArray<Utf8Type>;

Implementations

impl Utf8Chunked

pub fn par_iter_indexed(
    &self
) -> impl IndexedParallelIterator<Item = Option<&str>>

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

impl Utf8Chunked

pub fn hex_decode(&self) -> PolarsResult<Utf8Chunked>

Available on crate feature string_encoding and non-crate feature binary_encoding only.

pub fn hex_encode(&self) -> Utf8Chunked

Available on crate feature string_encoding only.

pub fn base64_decode(&self) -> PolarsResult<Utf8Chunked>

Available on crate feature string_encoding and non-crate feature binary_encoding only.

pub fn base64_encode(&self) -> Utf8Chunked

Available on crate feature string_encoding only.

Trait Implementations

impl Add<&ChunkedArray<Utf8Type>> for &Utf8Chunked

type Output = ChunkedArray<Utf8Type>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl Add<&str> for &Utf8Chunked

type Output = ChunkedArray<Utf8Type>

The resulting type after applying the + operator.

fn add(self, rhs: &str) -> Self::Output

Performs the + operation.

impl Add<ChunkedArray<Utf8Type>> for Utf8Chunked

type Output = ChunkedArray<Utf8Type>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl AggList for Utf8Chunked

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

Safety

impl ArgAgg for Utf8Chunked

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 Utf8Chunked

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 Utf8Chunked

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, &'a str, Cow<'a, str>> for Utf8Chunked

fn apply_cast_numeric<F, S>(&'a self, f: F) -> ChunkedArray<S>where
    F: Fn(&'a str) -> 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 str>) -> 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 str) -> Cow<'a, str> + 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 str) -> PolarsResult<Cow<'a, str>> + Copy,

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

Apply a closure elementwise including null values.

fn apply_with_idx<F>(&'a self, f: F) -> Selfwhere
    F: Fn((usize, &'a str)) -> Cow<'a, str> + 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 str>)) -> Option<Cow<'a, str>> + Copy,

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

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

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

impl ChunkApplyKernel<Utf8Array<i64>> for Utf8Chunked

fn apply_kernel(&self, f: &dyn Fn(&LargeStringArray) -> ArrayRef) -> Self

Apply kernel and return result as a new ChunkedArray.

fn apply_kernel_cast<S>(
    &self,
    f: &dyn Fn(&LargeStringArray) -> ArrayRef
) -> ChunkedArray<S>where
    S: PolarsDataType,

Apply a kernel that outputs an array of different type.

impl ChunkCast for Utf8Chunked

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

Cast a [ChunkedArray] to [DataType]

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

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

impl ChunkCompare<&ChunkedArray<Utf8Type>> for Utf8Chunked

type Item = ChunkedArray<BooleanType>

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

Check for equality.

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

Check for inequality.

fn gt(&self, rhs: &Utf8Chunked) -> BooleanChunked

Greater than comparison.

fn gt_eq(&self, rhs: &Utf8Chunked) -> BooleanChunked

Greater than or equal comparison.

fn lt(&self, rhs: &Utf8Chunked) -> BooleanChunked

Less than comparison.

fn lt_eq(&self, rhs: &Utf8Chunked) -> BooleanChunked

Less than or equal comparison

impl ChunkCompare<&str> for Utf8Chunked

type Item = ChunkedArray<BooleanType>

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

Check for equality.

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

Check for inequality.

fn gt(&self, rhs: &str) -> BooleanChunked

Greater than comparison.

fn gt_eq(&self, rhs: &str) -> BooleanChunked

Greater than or equal comparison.

fn lt(&self, rhs: &str) -> BooleanChunked

Less than comparison.

fn lt_eq(&self, rhs: &str) -> BooleanChunked

Less than or equal comparison

impl ChunkExpandAtIndex<Utf8Type> for Utf8Chunked

fn new_from_index(&self, index: usize, length: usize) -> Utf8Chunked

Create a new ChunkedArray filled with values at that index.

impl ChunkExplode for Utf8Chunked

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

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

impl ChunkFillNull for Utf8Chunked

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

Replace None values with one of the following strategies:

impl ChunkFillNullValue<&str> for Utf8Chunked

fn fill_null_with_values(&self, value: &str) -> PolarsResult<Self>

Replace None values with a give value T.

impl ChunkFilter<Utf8Type> for Utf8Chunked

fn filter(&self, filter: &BooleanChunked) -> PolarsResult<ChunkedArray<Utf8Type>>

Filter values in the ChunkedArray with a boolean mask.

impl<'a> ChunkFull<&'a str> for Utf8Chunked

fn full(name: &str, value: &'a str, length: usize) -> Self

Create a ChunkedArray with a single value.

impl ChunkFullNull for Utf8Chunked

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

impl ChunkQuantile<String> for Utf8Chunked

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<Utf8Type> for Utf8Chunked

fn reverse(&self) -> Self

Return a reversed version of this array.

impl<'a> ChunkSet<'a, &'a str, String> for Utf8Chunked

fn set_at_idx<I: IntoIterator<Item = IdxSize>>(
    &'a self,
    idx: I,
    opt_value: Option<&'a str>
) -> PolarsResult<Self>where
    Self: Sized,

Set the values at indexes idx to some optional value Option<T>.

fn set_at_idx_with<I: IntoIterator<Item = IdxSize>, F>(
    &'a self,
    idx: I,
    f: F
) -> PolarsResult<Self>where
    Self: Sized,
    F: Fn(Option<&'a str>) -> Option<String>,

Set the values at indexes idx by applying a closure to these values.

fn set(
    &'a self,
    mask: &BooleanChunked,
    value: Option<&'a str>
) -> PolarsResult<Self>where
    Self: Sized,

Set the values where the mask evaluates to true to some optional value Option<T>.

impl ChunkShift<Utf8Type> for Utf8Chunked

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

impl ChunkShiftFill<Utf8Type, Option<&str>> for Utf8Chunked

fn shift_and_fill(&self, periods: i64, fill_value: Option<&str>) -> Utf8Chunked

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

impl ChunkSort<Utf8Type> for Utf8Chunked

fn argsort_multiple(
    &self,
    other: &[Series],
    reverse: &[bool]
) -> PolarsResult<IdxCa>

Panics

This function is very opinionated. On the implementation of ChunkedArray<T> for numeric types, we assume that all numeric Series are of the same type.

In this case we assume that all numeric Series are f64 types. The caller needs to uphold this contract. If not, it will panic.

fn sort_with(&self, options: SortOptions) -> ChunkedArray<Utf8Type>

fn sort(&self, reverse: bool) -> Utf8Chunked

Returned a sorted ChunkedArray.

fn argsort(&self, options: SortOptions) -> IdxCa

Retrieve the indexes needed to sort this array.

impl ChunkTake for Utf8Chunked

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 ChunkTakeEvery<Utf8Type> for Utf8Chunked

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

Traverse and collect every nth element in a new array.

impl ChunkUnique<Utf8Type> for Utf8Chunked

fn unique(&self) -> PolarsResult<Self>

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 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 n_unique(&self) -> PolarsResult<usize>

Number of unique values in the ChunkedArray

fn mode(&self) -> PolarsResult<Self>

Available on crate feature mode only.

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

impl ChunkVar<String> for Utf8Chunked

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 ChunkZip<Utf8Type> for Utf8Chunked

Available on crate feature zip_with only.

fn zip_with(
    &self,
    mask: &BooleanChunked,
    other: &Utf8Chunked
) -> PolarsResult<Utf8Chunked>

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 Utf8Chunked

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

Formats the value using the given formatter.

impl From<(&str, Utf8Array<i64>)> for Utf8Chunked

fn from(tpl: (&str, Utf8Array<i64>)) -> Self

Converts to this type from the input type.

impl<Ptr> FromIterator<Option<Ptr>> for Utf8Chunkedwhere
    Ptr: AsRef<str>,

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

Creates a value from an iterator.

impl<Ptr> FromIterator<Ptr> for Utf8Chunkedwhere
    Ptr: PolarsAsRef<str>,

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

Creates a value from an iterator.

impl<Ptr> FromParallelIterator<Option<Ptr>> for Utf8Chunkedwhere
    Ptr: AsRef<str> + Send + Sync,

fn from_par_iter<I: IntoParallelIterator<Item = Option<Ptr>>>(iter: I) -> Self

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

impl<Ptr> FromParallelIterator<Ptr> for Utf8Chunkedwhere
    Ptr: PolarsAsRef<str> + Send + Sync,

fn from_par_iter<I: IntoParallelIterator<Item = Ptr>>(iter: I) -> Self

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

impl<Ptr> FromTrustedLenIterator<Option<Ptr>> for Utf8Chunkedwhere
    Ptr: AsRef<str>,

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

impl<Ptr> FromTrustedLenIterator<Ptr> for Utf8Chunkedwhere
    Ptr: PolarsAsRef<str>,

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

impl IntoGroupsProxy for Utf8Chunked

fn group_tuples<'a>(
    &'a 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> IntoIterator for &'a Utf8Chunked

type Item = Option<&'a str>

The type of the elements being iterated over.

type IntoIter = Box<dyn PolarsIterator<Item = <&'a ChunkedArray<Utf8Type> 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> IntoTakeRandom<'a> for &'a Utf8Chunked

type Item = &'a str

type TakeRandom = TakeRandBranch2<Utf8TakeRandomSingleChunk<'a>, Utf8TakeRandom<'a>>

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

Create a type that implements TakeRandom.

impl IsFirst<Utf8Type> for Utf8Chunked

Available on crate feature is_first only.

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

impl IsIn for Utf8Chunked

Available on crate feature is_in only.

fn is_in(&self, other: &Series) -> PolarsResult<BooleanChunked>

Check if elements of this array are in the right Series, or List values of the right Series.

impl<'a, T: AsRef<[&'a str]>> NamedFrom<T, [&'a str]> for Utf8Chunked

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

Initialize by name and values.

impl<'a, T: AsRef<[Cow<'a, str>]>> NamedFrom<T, [Cow<'a, str>]> for Utf8Chunked

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

Initialize by name and values.

impl<'a, T: AsRef<[Option<&'a str>]>> NamedFrom<T, [Option<&'a str>]> for Utf8Chunked

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

Initialize by name and values.

impl<'a, T: AsRef<[Option<Cow<'a, str>>]>> NamedFrom<T, [Option<Cow<'a, str>>]> for Utf8Chunked

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

Initialize by name and values.

impl<S> NewChunkedArray<Utf8Type, S> for Utf8Chunkedwhere
    S: AsRef<str>,

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

Create a new ChunkedArray from an iterator.

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

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

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

Create a new ChunkedArray from an iterator.

impl NumOpsDispatch for Utf8Chunked

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

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

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

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

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

impl RepeatBy for Utf8Chunked

Available on crate feature repeat_by only.

fn repeat_by(&self, by: &IdxCa) -> ListChunked

Repeat the values n times, where n is determined by the values in by.

impl StrConcat for Utf8Chunked

Available on crate feature concat_str only.

fn str_concat(&self, delimiter: &str) -> Utf8Chunked

Concat the values into a string array.

impl<'a> TakeRandom for &'a Utf8Chunked

type Item = &'a str

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

Get a nullable value by index.

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

Get a value by index and ignore the null bit.

impl<'a> TakeRandomUtf8 for &'a Utf8Chunked

type Item = &'a str

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 Utf8Chunked

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 VecHash for Utf8Chunked

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])

impl ZipOuterJoinColumn for Utf8Chunked

fn zip_outer_join_column(
    &self,
    right_column: &Series,
    opt_join_tuples: &[(Option<IdxSize>, Option<IdxSize>)]
) -> Series