Pkg/polars/Expr

Expr

struct Expr

Expressions that can be used in various contexts.

Implementions

ToString

Operators

pub fn operator -(self): Expr

pub fn operator %(self, other: Expr): Expr

pub fn operator /(self, other: Expr): Expr

pub fn operator *(self, other: Expr): Expr

pub fn operator -(self, other: Expr): Expr

pub fn operator +(self, other: Expr): Expr

pub fn operator ^(self, other: Expr): Expr

pub fn operator |(self, b: Expr): Expr

pub fn operator !(self): Expr

pub fn operator !=(self, b: Expr): Expr

pub fn operator <=(self, other: Expr): Expr

pub fn operator <(self, b: Expr): Expr

pub fn operator ||(self, b: Expr): Expr

pub fn operator &&(self, b: Expr): Expr

pub fn operator >=(self, b: Expr): Expr

pub fn operator >(self, b: Expr): Expr

pub fn operator ==(self, b: Expr): Expr

pub fn operator &(self, b: Expr): Expr

Static Methods

pub fn all(): Expr

[src]

pub fn all(): Expr {
    return Expr.col("*");
}

Selects all columns.

Shorthand for col("*").

pub fn col(name: string): Expr

Create a Column Expression based on a column name.

pub fn cols(names: [string]): Expr

Crete a Column Expression select multiple columns.

pub fn concat_arr(exprs: [Expr]): Expr throws PolarsError

Horizontally concatenate columns into a single array-type column.

pub fn concat_expr(exprs: [Expr], rechunk: bool = false): Expr throws PolarsError

pub fn concat_list(exprs: [Expr]): Expr throws PolarsError

Concat lists entries.

pub fn concat_str(exprs: [Expr], separator: string = ",", ignore_nulls: bool = true): Expr

Horizontally concat string columns in linear time.

pub fn date_range(start: Expr, end: Expr, interval: Duration, closed: ClosedWindow): Expr

[src]

pub fn date_range(start: Expr, end: Expr, interval: Duration, closed: ClosedWindow): Expr {
    return Expr._date_range(start, end, interval, closed as int);
}

Create a column of date ranges from a start and stop expression.

pub fn datetime(year: Expr = Expr.lit(1970), month: Expr = Expr.lit(1), day: Expr = Expr.lit(1), hour: Expr = Expr.lit(0), minute: Expr = Expr.lit(0), second: Expr = Expr.lit(0), microsecond: Expr = Expr.lit(0), time_unit: TimeUnit = TimeUnit.Microseconds, time_zone: string? = nil, ambiguous: Expr = Expr.lit("raise")): Expr

[src]

pub fn datetime(
    year: Expr = Expr.lit(1970),
    month: Expr = Expr.lit(1),
    day: Expr = Expr.lit(1),
    hour: Expr = Expr.lit(0),
    minute: Expr = Expr.lit(0),
    second: Expr = Expr.lit(0),
    microsecond: Expr = Expr.lit(0),
    time_unit: TimeUnit = TimeUnit.Microseconds,
    time_zone: string? = nil,
    ambiguous: Expr = Expr.lit("raise")
): Expr {
    return Expr
        ._datetime(
            year,
            month,
            day,
            hour,
            minute,
            second,
            microsecond,
            time_unit as int,
            time_zone,
            ambiguous
        );
}

Create a column of Datetime.

pub fn datetime_range(start: Expr, end: Expr, interval: Duration, closed: ClosedWindow, time_unit: TimeUnit? = nil, time_zone: string? = nil): Expr

[src]

pub fn datetime_range(
    start: Expr,
    end: Expr,
    interval: Duration,
    closed: ClosedWindow,
    time_unit: TimeUnit? = nil,
    time_zone: string? = nil
): Expr {
    return Expr
        ._datetime_range(
            start,
            end,
            interval,
            closed as int,
            time_unit.map(|time_unit| time_unit as int),
            time_zone
        );
}

Create a datetime range from a start and stop expression.

pub fn datetime_ranges(start: Expr, end: Expr, interval: Duration, closed: ClosedWindow, time_unit: TimeUnit? = nil, time_zone: string? = nil): Expr

[src]

pub fn datetime_ranges(
    start: Expr,
    end: Expr,
    interval: Duration,
    closed: ClosedWindow,
    time_unit: TimeUnit? = nil,
    time_zone: string? = nil
): Expr {
    return Expr
        ._datetime_ranges(
            start,
            end,
            interval,
            closed as int,
            time_unit.map(|time_unit| time_unit as int),
            time_zone
        );
}

Create a column of datetime ranges from a start and stop expression.

pub fn duration(weeks: Expr = Expr.lit(0), days: Expr = Expr.lit(0), hours: Expr = Expr.lit(0), minutes: Expr = Expr.lit(0), seconds: Expr = Expr.lit(0), milliseconds: Expr = Expr.lit(0), microseconds: Expr = Expr.lit(0), nanoseconds: Expr = Expr.lit(0), time_unit: TimeUnit = TimeUnit.Microseconds): Expr

[src]

pub fn duration(
    weeks: Expr = Expr.lit(0),
    days: Expr = Expr.lit(0),
    hours: Expr = Expr.lit(0),
    minutes: Expr = Expr.lit(0),
    seconds: Expr = Expr.lit(0),
    milliseconds: Expr = Expr.lit(0),
    microseconds: Expr = Expr.lit(0),
    nanoseconds: Expr = Expr.lit(0),
    time_unit: TimeUnit = TimeUnit.Microseconds
): Expr {
    return Expr
        ._duration(
            weeks,
            days,
            hours,
            minutes,
            seconds,
            milliseconds,
            microseconds,
            nanoseconds,
            time_unit as int
        );
}

Construct a column of Duration.

pub fn first_col(): Expr

First column in a DataFrame.

pub fn format_str(format: string, args: [Expr]): Expr throws PolarsError

Format the results of an array of expressions using a format string

pub fn index_cols(indices: [int]): Expr

Select multiple columns by index.

pub fn int_ranges(start: Expr, end: Expr, step: Expr): Expr

Generate a range of integers for each row of the input columns.

pub fn last_col(): Expr

Last column in a DataFrame.

pub fn linear_space(start: Expr, stop: Expr, num_samples: Expr, closed: ClosedInterval): Expr

[src]

pub fn linear_space(start: Expr, stop: Expr, num_samples: Expr, closed: ClosedInterval): Expr {
    return Expr._linear_space(start, stop, num_samples, closed as int);
}

Generate a series of equally-spaced points.

pub fn lit(value: Scalar | Column | int | float | bool | string): Expr

[src]

pub fn lit(value: Scalar | Column | int | float | bool | string): Expr {
    switch (let value = value.(type)) {
        case Scalar:
            return Expr._literal_scalar(value);
        case Column:
            return Expr._literal_column(value);
        case int:
            return Expr._literal_scalar(Scalar.int64(value));
        case float:
            return Expr._literal_scalar(Scalar.float64(value));
        case bool:
            return Expr._literal_scalar(Scalar.bool(value));
        case string:
            return Expr._literal_scalar(Scalar.string(value));
    }
}

Create a literal expression.

pub fn pi(): Expr

Constant Pi

Methods

pub fn abs(self): Expr

Convert all values to their absolute/positive value.

pub fn agg_groups(self): Expr

Get the group indexes of the group by operation.

pub fn alias(self, name: string): Expr

Rename Column.

pub fn all(self, ignore_nulls: bool = false): Expr

Returns whether all values in the column are true.

If ignore_nulls is false, Kleene logic is used to deal with nulls: if the column contains any null values and no false values, the output is null.

pub fn any(self, ignore_nulls: bool = false): Expr

Returns whether any of the values in the column are true.

If ignore_nulls is False, Kleene logic is used to deal with nulls: if the column contains any null values and no true values, the output is null.

pub fn append(self, other: Expr, upcast: bool = false): Expr

Append expressions.

This is done by adding the chunks of other to this series.

pub fn approx_n_unique(self): Expr

Get the approximate count of unique values.

pub fn arccos(self): Expr

Compute the inverse cosine of the given expression.

pub fn arccosh(self): Expr

Compute the inverse hyperbolic cosine of the given expression.

pub fn arcsin(self): Expr

Compute the inverse sine of the given expression.

pub fn arcsinh(self): Expr

Compute the inverse hyperbolic sine of the given expression.

pub fn arctan(self): Expr

Compute the inverse tangent of the given expression.

pub fn arctan2(self, b: Expr): Expr

Compute the inverse tangent of the given expression.

pub fn arctanh(self): Expr

Compute the inverse hyperbolic tangent of the given expression.

pub fn arg_max(self): Expr

Get the index value that has the maximum value.

pub fn arg_min(self): Expr

Get the index value that has the minimum value.

pub fn arg_sort(self, descending: bool = false, nulls_last: bool = false, multithreaded: bool = true, maintain_order: bool = false, limit: int? = nil): Expr

Get the index values that would sort this expression.

pub fn arg_unique(self): Expr

Get the first index of unique values of this expression.

pub fn backward_fill(self, limit: int? = nil): Expr

Fill missing value with next non-null.

pub fn bottom_k(self, k: Expr): Expr

Returns the k smallest elements.

This has time complexity O(n + k log(n)).

pub fn bottom_k_by(self, k: Expr, by: [Expr], descending: [bool]): Expr

Returns the k smallest rows by given column.

pub fn cast(self, dtype: DataType, opts: CastOptions = .NonStrict): Expr

[src]

pub fn cast(self, dtype: DataType, opts: CastOptions = .NonStrict): Expr {
    return self._cast(dtype, opts as int);
}

Cast expression to another data type.

pub fn cbrt(self): Expr

Compute the cube root of the given expression.

pub fn ceil(self): Expr

Ceil underlying floating point array to the highest integers smaller or equal to the float value.

pub fn clip(self, min: Expr, max: Expr): Expr

Clip underlying values to a set boundary.

pub fn clip_max(self, max: Expr): Expr

Clip underlying values to a set boundary.

pub fn clip_min(self, min: Expr): Expr

Clip underlying values to a set boundary.

pub fn cos(self): Expr

Compute the cosine of the given expression

pub fn cosh(self): Expr

Compute the hyperbolic cosine of the given expression.

pub fn cot(self): Expr

Compute the cotangent of the given expression.

pub fn count(self): Expr

Count the values of the Series or Get counts of the group by operation.

pub fn cov(self, other: Expr, ddof: int = 1): Expr

Compute the covariance between two columns.

pub fn cum_count(self, reverse: bool = false): Expr

Cumulatively count values from 0 to len.

pub fn cum_max(self, reverse: bool = false): Expr

Get an array with the cumulative max computed at every element.

pub fn cum_min(self, reverse: bool = false): Expr

Get an array with the cumulative min computed at every element.

pub fn cum_prod(self, reverse: bool = false): Expr

Get an array with the cumulative product computed at every element.

pub fn cum_sum(self, reverse: bool = false): Expr

Get an array with the cumulative sum computed at every element.

pub fn degrees(self): Expr

Convert from radians to degrees

pub fn dot(self, other: Expr): Expr

Compute the dot/inner product between two expressions.

pub fn drop_nans(self): Expr

Drop NaN values.

pub fn drop_nulls(self): Expr

Drop null values.

pub fn dtype_col(self, dtype: DataType): Expr

[src]

pub fn dtype_col(self, dtype: DataType): Expr {
    return Expr._dtype_col(dtype);
}

Select multiple columns by dtype.

pub fn dtype_cols(self, dtypes: [DataType]): Expr

[src]

pub fn dtype_cols(self, dtypes: [DataType]): Expr {
    return Expr._dtype_cols(dtypes);
}

Select multiple columns by dtypes.

pub fn entropy(self, base: float, normalize: bool): Expr

Compute the entropy as -sum(pk * log(pk).

where pk are discrete probabilities.

pub fn eq_missing(self, b: Expr): Expr

pub fn ewm_mean(self, alpha: float = 0.5, adjust: bool = true, bias: bool = false, min_periods: int = 1, ignore_nulls: bool = true): Expr

Calculate the exponentially-weighted moving average.

pub fn ewm_std(self, alpha: float = 0.5, adjust: bool = true, bias: bool = false, min_periods: int = 1, ignore_nulls: bool = true): Expr

Calculate the exponentially-weighted moving standard deviation.

pub fn ewm_var(self, alpha: float = 0.5, adjust: bool = true, bias: bool = false, min_periods: int = 1, ignore_nulls: bool = true): Expr

Calculate the exponentially-weighted moving variance.

pub fn exclude(self, columns: [string]): Expr

Exclude a column from a wildcard/regex selection.

You may also use regexes in the exclude as long as they start with ^ and end with $.

pub fn exclude_dtype(self, dtypes: [DataType]): Expr

[src]

pub fn exclude_dtype(self, dtypes: [DataType]): Expr {
    return self._exclude_dtype(dtypes);
}

Exclude a column with a certain data type.

pub fn exp(self): Expr

Calculate the exponential of all elements in the input array.

pub fn explode(self): Expr

Explode the String/List column.

pub fn extend_constant(self, value: Expr, n: Expr): Expr

pub fn fill_nan(self, value: Expr): Expr

Replace the floating point NaN values by a value.

pub fn fill_null(self, value: Expr): Expr

Replace the null values by a value.

pub fn filter(self, predicate: Expr): Expr

Filter a single column.

Should be used in aggregation context. If you want to filter on a DataFrame level, use DataFrame.filter.

pub fn first(self): Expr

Get the first value in the group.

pub fn flatten(self): Expr

Alias for explode.

pub fn floor(self): Expr

Floor underlying floating point array to the lowest integers smaller or equal to the float value.

pub fn floor_div(self, rhs: Expr): Expr

Floor divide self by rhs.

pub fn forward_fill(self, limit: int? = nil): Expr

Floor divide self by rhs.

pub fn gather(self, idx: Expr): Expr

Floor divide self by rhs.

pub fn gather_every(self, n: int, offset: int): Expr

pub fn get(self, idx: Expr): Expr

Take the values by a single index.

pub fn head(self, n: int): Expr

Get the first n elements of the Expr result.

pub fn hist(self, bins: Expr? = nil, bin_count: int? = nil, include_category: bool = false, include_breakpoints: bool = false): Expr

Compute the histogram of a dataset.

pub fn implode(self): Expr

GroupBy the group to a Series.

pub fn int_range(self, start: Expr, end: Expr, step: int, dtype: DataType): Expr

[src]

pub fn int_range(self, start: Expr, end: Expr, step: int, dtype: DataType): Expr {
    return Expr._int_range(start, end, step, dtype);
}

Generate a range of integers.

pub fn interpolate(self, method: InterpolationMethod = .Linear): Expr

[src]

pub fn interpolate(self, method: InterpolationMethod = .Linear): Expr {
    return self._interpolate(method as int);
}

Fill null values using interpolation.

pub fn interpolate_by(self, by: Expr): Expr

Fill null values using interpolation.

pub fn is_duplicated(self): Expr

Get a mask of duplicated values.

pub fn is_finite(self): Expr

Get mask of finite values if dtype is Float.

pub fn is_first_distinct(self): Expr

Get a mask of the first unique value.

pub fn is_in(self, other: Expr): Expr

Check if the values of the left expression are in the lists of the right expr.

pub fn is_infinite(self): Expr

Get mask of infinite values if dtype is Float.

pub fn is_last_distinct(self): Expr

Get mask of infinite values if dtype is Float.

pub fn is_nan(self): Expr

Get mask of NaN values if dtype is Float.

pub fn is_not_nan(self): Expr

Get inverse mask of NaN values if dtype is Float.

pub fn is_not_null(self): Expr

Run is_not_null operation on Expr.

pub fn is_null(self): Expr

Run is_null operation on Expr.

pub fn is_unique(self): Expr

Get a mask of unique values.

pub fn kurtosis(self, fisher: bool, bias: bool): Expr

Compute the kurtosis (Fisher or Pearson).

Kurtosis is the fourth central moment divided by the square of the variance. If Fisher’s definition is used, then 3.0 is subtracted from the result to give 0.0 for a normal distribution. If bias is False then the kurtosis is calculated using k statistics to eliminate bias coming from biased moment estimators.

pub fn last(self): Expr

Get the last value in the group.

pub fn len(self): Expr

Returns the length of the value.

pub fn log(self, base: float): Expr

Compute the logarithm to a given base.

pub fn log1p(self): Expr

Compute the natural logarithm of all elements plus one in the input array.

pub fn lower_bound(self): Expr

Get minimal value that could be hold by this dtype.

pub fn max(self): Expr

Reduce groups to maximum value.

pub fn mean(self): Expr

Reduce groups to the mean value.

pub fn median(self): Expr

Reduce groups to the median value.

pub fn min(self): Expr

Reduce groups to minimal value.

pub fn mode(self): Expr

Compute the mode(s) of this column. This is the most occurring value.

pub fn n_unique(self): Expr

Get the number of unique values in the groups.

pub fn nan_max(self): Expr

Reduce groups to maximum value.

pub fn nan_min(self): Expr

Reduce groups to minimal value.

pub fn neq_missing(self, b: Expr): Expr

Compare Expr with other Expr on non-equality where nil == nil.

pub fn null_count(self): Expr

Get the null count of the column/group.

pub fn over(self, partition_by: [Expr], order_by: [Expr]? = nil, descending: bool = false, nulls_last: bool = false, multithreaded: bool = true, maintain_order: bool = false, limit: int? = nil, window_mapping: WindowMapping = .GroupsToRows): Expr

[src]

pub fn over(
    self,
    partition_by: [Expr],
    order_by: [Expr]? = nil,
    descending: bool = false,
    nulls_last: bool = false,
    multithreaded: bool = true,
    maintain_order: bool = false,
    limit: int? = nil,
    window_mapping: WindowMapping = .GroupsToRows
): Expr {
    return self
        ._over(
            partition_by,
            order_by,
            descending,
            nulls_last,
            multithreaded,
            maintain_order,
            limit,
            window_mapping as int
        );
}

Apply window function over a subgroup.

This is similar to a group_by + aggregation + self join.

pub fn pct_change(self, n: Expr): Expr

Computes percentage change between values.

pub fn peak_max(self): Expr

pub fn peak_min(self): Expr

pub fn pearson_corr(self, other: Expr): Expr

Compute the pearson correlation between two columns.

pub fn pow(self, exponent: Expr): Expr

Raise expression to the power exponent.

pub fn product(self): Expr

Get the product aggregation of an expression.

pub fn qcut(self, probs: [float], labels: [string]? = nil, left_closed: bool = false, allow_duplicates: bool = false, include_breaks: bool = false): Expr

Bin continuous values into discrete categories based on their quantiles.

pub fn qcut_uniform(self, n_bins: int, labels: [string]? = nil, left_closed: bool = false, allow_duplicates: bool = false, include_breaks: bool = false): Expr

Bin continuous values into discrete categories using uniform quantile probabilities.

pub fn quantile(self, quantile: Expr, method: QuantileMethod): Expr

[src]

pub fn quantile(self, quantile: Expr, method: QuantileMethod): Expr {
    return self._quantile(quantile, method as int);
}

Compute the quantile per group.

pub fn radians(self): Expr

Convert from degrees to radians

pub fn rank(self, method: RankMethod = .Dense, descending: bool = false, seed: int? = nil): Expr

[src]

pub fn rank(self, method: RankMethod = .Dense, descending: bool = false, seed: int? = nil): Expr {
    return self._rank(method as int, descending, seed);
}

Assign ranks to data, dealing with ties appropriately.

pub fn repeat_by(self, by: Expr): Expr

pub fn replace(self, old: Expr, new: Expr): Expr

Replace the given values with other values.

pub fn replace_strict(self, old: Expr, new: Expr, default_: Expr? = nil, return_dtype: DataType? = nil): Expr

[src]

pub fn replace_strict(
    self, old: Expr, new: Expr, default_: Expr? = nil, return_dtype: DataType? = nil
): Expr {
    return self._replace_strict(old, new, default_, return_dtype);
}

Replace the given values with other values.

pub fn reshape(self, dimensions: [int]): Expr

pub fn reverse(self): Expr

Reverse column

pub fn rle(self): Expr

Get the lengths of runs of identical values.

pub fn rle_id(self): Expr

Similar to rle, but maps values to run IDs.

pub fn rolling(self, index_column: string, period: Duration, offset: Duration, closed_window: int): Expr

pub fn round(self, decimals: int): Expr

Round underlying floating point array to given decimal numbers.

pub fn round_sig_figs(self, digits: int): Expr

Round underlying floating point array to given decimal numbers.

pub fn sample_frac(self, frac: Expr, with_replacement: bool = false, shuffle: bool = false, seed: int? = nil): Expr

pub fn sample_n(self, n: Expr, with_replacement: bool = false, shuffle: bool = false, seed: int? = nil): Expr

pub fn shift(self, n: Expr): Expr

Shift the values in the array by some period.

pub fn shift_and_fill(self, n: Expr, fill_value: Expr): Expr

Shift the values in the array by some period and fill the resulting empty values.

pub fn shrink_dtype(self): Expr

Shrink numeric columns to the minimal required datatype needed to fit the extrema of this Series.

This can be used to reduce memory pressure.

pub fn shuffle(self, seed: int?): Expr

pub fn slice(self, other: Expr, length: Expr): Expr

Slice the Series.

offset may be negative.

pub fn sort(self, descending: bool = false, nulls_last: bool = false, multithreaded: bool = true, maintain_order: bool = false, limit: int? = nil): Expr

Sort with given options.

pub fn sort_by(self, by: [Expr], descending: [bool] = [false], nulls_last: [bool] = [false], multithreaded: bool = true, maintain_order: bool = false, limit: int? = nil): Expr

[src]

pub fn sort_by(
    self,
    by: [Expr],
    descending: [bool] = [false],
    nulls_last: [bool] = [false],
    multithreaded: bool = true,
    maintain_order: bool = false,
    limit: int? = nil
): Expr {
    return self._sort_by(by, descending, nulls_last, multithreaded, maintain_order, limit);
}

Sort this column by the ordering of another column evaluated from given expr.

Can also be used in a group_by context to sort the groups.

pub fn sqrt(self): Expr

Compute the square root of the given expression

pub fn std(self, ddof: int = 1): Expr

Compute the square root of the given expression

pub fn strict_cast(self, dtype: DataType): Expr

[src]

pub fn strict_cast(self, dtype: DataType): Expr {
    return self._strict_cast(dtype);
}

Cast expression to another data type.

pub fn sum(self): Expr

Reduce groups to the sum of all the values.

pub fn tail(self, n: int?): Expr

Get the last n elements of the Expr result.

pub fn to_string(self): string

pub fn unique(self, stable: bool = false): Expr

Get unique values of this expression.

pub fn unique_counts(self): Expr

Returns a count of the unique values in the order of appearance.

pub fn upper_bound(self): Expr

Get maximal value that could be hold by this dtype.

pub fn value_counts(self, name: string, sort: bool = false, parallel: bool = false, normalize: bool = false): Expr

Count all unique values and create a struct mapping value to count.

The name of the struct field with the counts is given by the parameter name.

pub fn var(self, ddof: int = 1): Expr

Variance of the values of the Series.