Type Definition polars_core::datatypes::Utf8Chunked

pub type Utf8Chunked = ChunkedArray<Utf8Type>;

Implementations

impl Utf8Chunked

pub fn json_path_match(&self, json_path: &str) -> Result<Utf8Chunked>

Extract json path, first match Refer to https://goessner.net/articles/JsonPath/

impl Utf8Chunked

pub fn hex_decode(&self, strict: Option<bool>) -> Result<Utf8Chunked>

pub fn hex_encode(&self) -> Utf8Chunked

pub fn base64_decode(&self, strict: Option<bool>) -> Result<Utf8Chunked>

pub fn base64_encode(&self) -> Utf8Chunked

impl Utf8Chunked

pub fn str_lengths(&self) -> UInt32Chunked

Get the length of the string values.

pub fn contains(&self, pat: &str) -> Result<BooleanChunked>

Check if strings contain a regex pattern

pub fn replace(&self, pat: &str, val: &str) -> Result<Utf8Chunked>

Replace the leftmost (sub)string by a regex pattern

pub fn replace_all(&self, pat: &str, val: &str) -> Result<Utf8Chunked>

Replace all (sub)strings by a regex pattern

pub fn extract(&self, pat: &str, group_index: usize) -> Result<Utf8Chunked>

Extract the nth capture group from pattern

pub fn to_lowercase(&self) -> Utf8Chunked

Modify the strings to their lowercase equivalent

pub fn to_uppercase(&self) -> Utf8Chunked

Modify the strings to their uppercase equivalent

pub fn concat(&self, other: &Utf8Chunked) -> Self

Concat with the values from a second Utf8Chunked

pub fn str_slice(&self, start: i64, length: Option<u64>) -> Result<Self>

Slice the string values Determines a substring starting from start and with optional length length of each of the elements in array. start can be negative, in which case the start counts from the end of the string.

Trait Implementations

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

type Output = Utf8Chunked

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&'_ str> for &Utf8Chunked

type Output = Utf8Chunked

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 = Utf8Chunked

The resulting type after applying the + operator.

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

Performs the + operation.

impl AggList for Utf8Chunked

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

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) -> 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) -> Self where
    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) -> Result<Self> where
    F: Fn(&'a str) -> Result<Cow<'a, str>> + Copy, 

fn apply_on_opt<F>(&'a self, f: F) -> Self where
    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) -> Self where
    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) -> Self where
    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) -> Result<Series>

Cast a [ChunkedArray] to [DataType]

impl ChunkCompare<&'_ ChunkedArray<Utf8Type>> for Utf8Chunked

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

Check for equality and regard missing values as equal.

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

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

Check for equality and regard missing values as equal.

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 expand_at_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) -> Result<(Series, Buffer<i64>)>

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

impl ChunkFillNull for Utf8Chunked

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

Replace None values with one of the following strategies:

impl ChunkFillNullValue<&'_ str> for Utf8Chunked

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

Replace None values with a give value T.

impl ChunkFilter<Utf8Type> for Utf8Chunked

fn filter(&self, filter: &BooleanChunked) -> Result<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 ChunkOps for Utf8Chunked

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<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
) -> Result<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 = usize>>(
    &'a self,
    idx: I,
    opt_value: Option<&'a str>
) -> Result<Self> where
    Self: Sized, 

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

fn set_at_idx_with<I: IntoIterator<Item = usize>, F>(
    &'a self,
    idx: I,
    f: F
) -> Result<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>) -> Result<Self> where
    Self: Sized, 

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

fn set_with<F>(&'a self, mask: &BooleanChunked, f: F) -> Result<Self> where
    Self: Sized,
    F: Fn(Option<&'a str>) -> Option<String>, 

Set the values where the mask evaluates to true by applying a closure to these values.

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

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

Number of unique values in the ChunkedArray

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

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

impl ChunkVar<String> for Utf8Chunked

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

fn zip_with(
    &self,
    mask: &BooleanChunked,
    other: &Utf8Chunked
) -> Result<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

Performs the conversion.

impl<Ptr> FromIterator<Option<Ptr>> for Utf8Chunked where
    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 Utf8Chunked where
    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 Utf8Chunked where
    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 Utf8Chunked where
    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 Utf8Chunked where
    Ptr: AsRef<str>, 

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

impl<Ptr> FromTrustedLenIterator<Ptr> for Utf8Chunked where
    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) -> 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 = 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 IntoSeries for Utf8Chunked

fn into_series(self) -> Series

fn is_series() -> bool

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

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

impl IsIn for Utf8Chunked

fn is_in(&self, other: &Series) -> Result<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 Utf8Chunked where
    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) -> Result<Series>

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

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

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

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

impl QuantileAggSeries for Utf8Chunked

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

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

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

fn to_dummies(&self) -> Result<DataFrame>

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

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

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

impl ZipOuterJoinColumn for Utf8Chunked

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