Type Definition polars::datatypes::Utf8Chunked

type Utf8Chunked = ChunkedArray<Utf8Type>;

Implementations

impl Utf8Chunked

pub fn str_lengths(&self) -> UInt32Chunked

This is supported on crate feature strings only.

Get the length of the string values.

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

This is supported on crate feature strings only.

Check if strings contain a regex pattern

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

This is supported on crate feature strings only.

Replace the leftmost (sub)string by a regex pattern

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

This is supported on crate feature strings only.

Replace all (sub)strings by a regex pattern

pub fn to_lowercase(&self) -> Utf8Chunked

This is supported on crate feature strings only.

Modify the strings to their lowercase equivalent

pub fn to_uppercase(&self) -> Utf8Chunked

This is supported on crate feature strings only.

Modify the strings to their uppercase equivalent

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

This is supported on crate feature strings only.

Concat with the values from a second Utf8Chunked

impl Utf8Chunked

pub fn as_date32(&self, fmt: Option<&str>) -> Result<Date32Chunked>

This is supported on crate feature temporal only.

pub fn as_date64(&self, fmt: Option<&str>) -> Result<Date64Chunked>

This is supported on crate feature temporal only.

Trait Implementations

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

type Output = Utf8Chunked

The resulting type after applying the + operator.

pub 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.

pub 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.

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

Performs the + operation.

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

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

Apply a closure F elementwise.

pub fn apply_with_idx<F>(&'a self, f: F) -> Self where
    F: Fn((usize, &'a str)) -> String + Copy, 

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

pub fn apply_with_idx_on_opt<F>(&'a self, f: F) -> Self where
    F: Fn((usize, Option<&'a str>)) -> Option<String> + Copy, 

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

impl ChunkApplyKernel<GenericStringArray<i32>> for Utf8Chunked

pub fn apply_kernel<F>(&self, f: F) -> Self where
    F: Fn(&StringArray) -> ArrayRef, 

Apply kernel and return result as a new ChunkedArray.

pub fn apply_kernel_cast<F, S>(&self, f: F) -> ChunkedArray<S> where
    F: Fn(&StringArray) -> ArrayRef,
    S: PolarsDataType, 

impl ChunkCast for Utf8Chunked

pub fn cast<N>(&self) -> Result<ChunkedArray<N>> where
    N: PolarsDataType, 

Cast ChunkedArray<T> to ChunkedArray<N>

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

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

Check for equality and regard missing values as equal.

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

Check for equality.

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

Check for inequality.

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

Greater than comparison.

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

Greater than or equal comparison.

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

Less than comparison.

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

Less than or equal comparison

impl ChunkCompare<&'_ str> for Utf8Chunked

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

Check for equality and regard missing values as equal.

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

Check for equality.

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

Check for inequality.

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

Greater than comparison.

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

Greater than or equal comparison.

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

Less than comparison.

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

Less than or equal comparison

impl ChunkExpandAtIndex<Utf8Type> for Utf8Chunked

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

Create a new ChunkedArray filled with values at that index.

impl ChunkFillNone for Utf8Chunked

pub fn fill_none(&self, strategy: FillNoneStrategy) -> Result<Self>

Replace None values with one of the following strategies:

impl ChunkFillNoneValue<&'_ str> for Utf8Chunked

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

Replace None values with a give value T.

impl ChunkFilter<Utf8Type> for Utf8Chunked

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

Filter values in the ChunkedArray with a boolean mask.

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

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

Create a ChunkedArray with a single value.

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

impl ChunkOps for Utf8Chunked

pub fn rechunk(&self, chunk_lengths: Option<&[usize]>) -> Result<Self>

Aggregate to chunk id. A chunk id is a vector of the chunk lengths.

pub fn optional_rechunk<A>(&self, rhs: &ChunkedArray<A>) -> Result<Option<Self>>

Only rechunk if lhs and rhs don't match

impl ChunkReverse<Utf8Type> for Utf8Chunked

pub fn reverse(&self) -> Self

Return a reversed version of this array.

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

pub fn set_at_idx<T: AsTakeIndex>(
    &'a self,
    idx: &T,
    opt_value: Option<&'a str>
) -> Result<Self> where
    Self: Sized, 

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

pub fn set_at_idx_with<T: AsTakeIndex, F>(
    &'a self,
    idx: &T,
    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.

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

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

pub 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

pub fn shift(&self, periods: i32) -> Result<Self>

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

pub fn shift_and_fill(
    &self,
    periods: i32,
    fill_value: Option<&str>
) -> Result<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

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

Returned a sorted ChunkedArray.

pub fn sort_in_place(&mut self, reverse: bool)

Sort this array in place.

pub fn argsort(&self, reverse: bool) -> Vec<usize>

Retrieve the indexes needed to sort this array.

impl ChunkTake for Utf8Chunked

pub fn take(
    &self,
    indices: impl Iterator<Item = usize>,
    capacity: Option<usize>
) -> Self where
    Self: Sized, 

Take values from ChunkedArray by index.

pub unsafe fn take_unchecked(
    &self,
    indices: impl Iterator<Item = usize>,
    capacity: Option<usize>
) -> Self

Take values from ChunkedArray by index

pub fn take_opt(
    &self,
    indices: impl Iterator<Item = Option<usize>>,
    capacity: Option<usize>
) -> Self where
    Self: Sized, 

Take values from ChunkedArray by Option.

pub unsafe fn take_opt_unchecked(
    &self,
    indices: impl Iterator<Item = Option<usize>>,
    capacity: Option<usize>
) -> Self

Take values from ChunkedArray by Option.

pub fn take_from_single_chunked(&self, idx: &UInt32Chunked) -> Result<Self>

pub fn take_from_single_chunked_iter(
    &self,
    indices: impl Iterator<Item = usize>
) -> Result<Self> where
    Self: Sized, 

impl ChunkUnique<Utf8Type> for Utf8Chunked

pub fn unique(&self) -> Result<Self>

Get unique values of a ChunkedArray

pub fn arg_unique(&self) -> Result<Vec<usize>>

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

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

Get a mask of all the unique values.

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

Get a mask of all the duplicated values.

pub fn value_counts(&self) -> Result<DataFrame>

Count the unique values.

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

Number of unique values in the ChunkedArray

impl ChunkVar<String> for Utf8Chunked

pub fn var(&self) -> Option<T>

Compute the variance of this ChunkedArray/Series.

pub fn std(&self) -> Option<T>

Compute the standard deviation of this ChunkedArray/Series.

impl ChunkWindow for Utf8Chunked

pub fn rolling_sum(
    &self,
    _window_size: usize,
    _weight: Option<&[f64]>,
    _ignore_null: bool
) -> Result<Self> where
    Self: Sized, 

Apply a rolling sum (moving sum) over the values in this array. A window of length window_size will traverse the array. The values that fill this window will (optionally) be multiplied with the weights given by the weight vector. The resulting values will be aggregated to their sum.

pub fn rolling_mean(
    &self,
    _window_size: usize,
    _weight: Option<&[f64]>,
    _ignore_null: bool
) -> Result<Self> where
    Self: Sized, 

Apply a rolling mean (moving mean) over the values in this array. A window of length window_size will traverse the array. The values that fill this window will (optionally) be multiplied with the weights given by the weight vector. The resulting values will be aggregated to their mean.

pub fn rolling_min(
    &self,
    _window_size: usize,
    _weight: Option<&[f64]>,
    _ignore_null: bool
) -> Result<Self> where
    Self: Sized, 

Apply a rolling min (moving min) over the values in this array. A window of length window_size will traverse the array. The values that fill this window will (optionally) be multiplied with the weights given by the weight vector. The resulting values will be aggregated to their min.

pub fn rolling_max(
    &self,
    _window_size: usize,
    _weight: Option<&[f64]>,
    _ignore_null: bool
) -> Result<Self> where
    Self: Sized, 

Apply a rolling max (moving max) over the values in this array. A window of length window_size will traverse the array. The values that fill this window will (optionally) be multiplied with the weights given by the weight vector. The resulting values will be aggregated to their max.

impl ChunkZip<Utf8Type> for Utf8Chunked

pub 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

pub fn zip_with_series(
    &self,
    mask: &BooleanChunked,
    other: &Series
) -> Result<ChunkedArray<Utf8Type>>

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

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

Formats the value using the given formatter.

impl Downcast<GenericStringArray<i32>> for Utf8Chunked

pub fn downcast_chunks(&self) -> Vec<&StringArray>

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

pub fn from_iter<I: IntoIterator<Item = &'a &'a str>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a> FromIterator<&'a Option<&'a str>> for Utf8Chunked

pub fn from_iter<I: IntoIterator<Item = &'a Option<&'a str>>>(iter: I) -> Self

Creates a value from an iterator.

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

pub fn from_iter<I: IntoIterator<Item = &'a str>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a> FromIterator<Cow<'a, str>> for Utf8Chunked

pub fn from_iter<I: IntoIterator<Item = Cow<'a, str>>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a> FromIterator<Option<&'a str>> for Utf8Chunked

pub fn from_iter<I: IntoIterator<Item = Option<&'a str>>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a> FromIterator<Option<Cow<'a, str>>> for Utf8Chunked

pub fn from_iter<I: IntoIterator<Item = Option<Cow<'a, str>>>>(iter: I) -> Self

Creates a value from an iterator.

impl FromIterator<Option<String>> for Utf8Chunked

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

Creates a value from an iterator.

impl FromIterator<String> for Utf8Chunked

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

Creates a value from an iterator.

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

pub fn from_par_iter<I: IntoParallelIterator<Item = &'a str>>(iter: I) -> Self

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

impl<'a> FromParallelIterator<Option<&'a str>> for Utf8Chunked

pub fn from_par_iter<I: IntoParallelIterator<Item = Option<&'a str>>>(
    iter: I
) -> Self

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

impl FromParallelIterator<Option<String>> for Utf8Chunked

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

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

impl FromParallelIterator<String> for Utf8Chunked

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

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

impl IntoGroupTuples for Utf8Chunked

pub fn group_tuples(&self) -> Vec<(usize, Vec<usize>)>

Create the tuples need for a groupby operation. * The first value in te 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?

pub fn into_iter(self) -> Self::IntoIter

Decides which iterator fits best the current chunked array. The decision are based on the number of chunks and the existence of null values.

impl<'a> IntoNoNullIterator for &'a Utf8Chunked

type Item = &'a str

type IntoIter = Box<dyn PolarsIterator<Item = Self::Item> + 'a>

pub fn into_no_null_iter(self) -> Self::IntoIter

Decides which iterator fits best the current no null chunked array. The decision are based on the number of chunks.

impl<'a> IntoParallelIterator for &'a Utf8Chunked

This is supported on crate feature parallel only.

Convert $ca_iter into a ParallelIterator using the most efficient ParallelIterator implementation for the given $ca_type.

• If $ca_type has only a chunk and has no null values, it uses $single_chunk_return_option.
• If $ca_type has only a chunk and does have null values, it uses $single_chunk_null_check_return_option.
• If $ca_type has many chunks and has no null values, it uses $many_chunk_return_option.
• If $ca_type has many chunks and does have null values, it uses $many_chunk_null_check_return_option.

type Iter = Utf8ParIterDispatcher<'a>

The parallel iterator type that will be created.

type Item = Option<&'a str>

The type of item that the parallel iterator will produce.

pub fn into_par_iter(self) -> Self::Iter

Converts self into a parallel iterator.

impl IntoSeries for Utf8Chunked

pub fn into_series(self) -> Series

impl<'a> IntoTakeRandom<'a> for &'a Utf8Chunked

type Item = &'a str

type TakeRandom = Box<dyn TakeRandom<Item = Self::Item> + 'a>

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

Create a type that implements TakeRandom.

impl<S> NewChunkedArray<Utf8Type, S> for Utf8Chunked where
    S: AsRef<str>, 

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

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

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

Create a new ChunkedArray from an iterator.

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

Create a new ChunkedArray from an iterator.

impl NumOpsDispatch for Utf8Chunked

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

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

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

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

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

impl<'a> TakeRandom for &'a Utf8Chunked

type Item = &'a str

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

Get a nullable value by index.

pub unsafe fn get_unchecked(&self, index: usize) -> Self::Item

Get a value by index and ignore the null bit.

impl<'a> TakeRandomUtf8 for &'a Utf8Chunked

type Item = &'a str

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

Get a nullable value by index.

pub unsafe fn get_unchecked(self, index: usize) -> Self::Item

Get a value by index and ignore the null bit.

impl ToDummies<Utf8Type> for Utf8Chunked

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

impl ZipOuterJoinColumn for Utf8Chunked

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