Enum polars_plan::dsl::Expr

pub enum Expr {
    Alias(Arc<Expr>, ColumnName),
    Column(ColumnName),
    Columns(Arc<[ColumnName]>),
    DtypeColumn(Vec<DataType>),
    IndexColumn(Arc<[i64]>),
    Literal(LiteralValue),
    BinaryExpr {
        left: Arc<Expr>,
        op: Operator,
        right: Arc<Expr>,
    },
    Cast {
        expr: Arc<Expr>,
        data_type: DataType,
        options: CastOptions,
    },
    Sort {
        expr: Arc<Expr>,
        options: SortOptions,
    },
    Gather {
        expr: Arc<Expr>,
        idx: Arc<Expr>,
        returns_scalar: bool,
    },
    SortBy {
        expr: Arc<Expr>,
        by: Vec<Expr>,
        sort_options: SortMultipleOptions,
    },
    Agg(AggExpr),
    Ternary {
        predicate: Arc<Expr>,
        truthy: Arc<Expr>,
        falsy: Arc<Expr>,
    },
    Function {
        input: Vec<Expr>,
        function: FunctionExpr,
        options: FunctionOptions,
    },
    Explode(Arc<Expr>),
    Filter {
        input: Arc<Expr>,
        by: Arc<Expr>,
    },
    Window {
        function: Arc<Expr>,
        partition_by: Vec<Expr>,
        order_by: Option<(Arc<Expr>, SortOptions)>,
        options: WindowType,
    },
    Wildcard,
    Slice {
        input: Arc<Expr>,
        offset: Arc<Expr>,
        length: Arc<Expr>,
    },
    Exclude(Arc<Expr>, Vec<Excluded>),
    KeepName(Arc<Expr>),
    Len,
    Nth(i64),
    RenameAlias {
        function: SpecialEq<Arc<dyn RenameAliasFn>>,
        expr: Arc<Expr>,
    },
    Field(Arc<[ColumnName]>),
    AnonymousFunction {
        input: Vec<Expr>,
        function: SpecialEq<Arc<dyn SeriesUdf>>,
        output_type: GetOutput,
        options: FunctionOptions,
    },
    SubPlan(SpecialEq<Arc<DslPlan>>, Vec<String>),
    Selector(Selector),
}

Expressions that can be used in various contexts. Queries consist of multiple expressions. When using the polars lazy API, don’t construct an Expr directly; instead, create one using the functions in the polars_lazy::dsl module. See that module’s docs for more info.

Variants

Alias(Arc<Expr>, ColumnName)

Column(ColumnName)

Columns(Arc<[ColumnName]>)

DtypeColumn(Vec<DataType>)

IndexColumn(Arc<[i64]>)

Literal(LiteralValue)

BinaryExpr

Fields

left: Arc<Expr>

op: Operator

right: Arc<Expr>

Cast

Fields

expr: Arc<Expr>

data_type: DataType

options: CastOptions

Sort

Fields

expr: Arc<Expr>

options: SortOptions

Gather

Fields

expr: Arc<Expr>

idx: Arc<Expr>

returns_scalar: bool

SortBy

Fields

expr: Arc<Expr>

by: Vec<Expr>

sort_options: SortMultipleOptions

Agg(AggExpr)

Ternary

A ternary operation if true then “foo” else “bar”

Fields

predicate: Arc<Expr>

truthy: Arc<Expr>

falsy: Arc<Expr>

Function

Fields

input: Vec<Expr>

function arguments

function: FunctionExpr

function to apply

options: FunctionOptions

Explode(Arc<Expr>)

Filter

Fields

input: Arc<Expr>

by: Arc<Expr>

Window

Polars flavored window functions.

Fields

function: Arc<Expr>

Also has the input. i.e. avg(“foo”)

partition_by: Vec<Expr>

order_by: Option<(Arc<Expr>, SortOptions)>

options: WindowType

Wildcard

Slice

Fields

input: Arc<Expr>

offset: Arc<Expr>

length is not yet known so we accept negative offsets

length: Arc<Expr>

Exclude(Arc<Expr>, Vec<Excluded>)

Can be used in a select statement to exclude a column from selection

KeepName(Arc<Expr>)

Set root name as Alias

Len

Nth(i64)

Take the nth column in the DataFrame

RenameAlias

Fields

function: SpecialEq<Arc<dyn RenameAliasFn>>

expr: Arc<Expr>

Field(Arc<[ColumnName]>)

Available on crate feature dtype-struct only.

AnonymousFunction

Fields

input: Vec<Expr>

function arguments

function: SpecialEq<Arc<dyn SeriesUdf>>

function to apply

output_type: GetOutput

output dtype of the function

options: FunctionOptions

SubPlan(SpecialEq<Arc<DslPlan>>, Vec<String>)

Selector(Selector)

Expressions in this node should only be expanding e.g. Expr::Columns Expr::Dtypes Expr::Wildcard Expr::Exclude

Implementations

impl Expr

pub fn floor_div(self, rhs: Self) -> Self

Floor divide self by rhs.

pub fn pow<E: Into<Expr>>(self, exponent: E) -> Self

Raise expression to the power exponent

pub fn sqrt(self) -> Self

Compute the square root of the given expression

pub fn cbrt(self) -> Self

Compute the cube root of the given expression

pub fn cos(self) -> Self

Available on crate feature trigonometry only.

Compute the cosine of the given expression

pub fn cot(self) -> Self

Available on crate feature trigonometry only.

Compute the cotangent of the given expression

pub fn sin(self) -> Self

Available on crate feature trigonometry only.

Compute the sine of the given expression

pub fn tan(self) -> Self

Available on crate feature trigonometry only.

Compute the tangent of the given expression

pub fn arccos(self) -> Self

Available on crate feature trigonometry only.

Compute the inverse cosine of the given expression

pub fn arcsin(self) -> Self

Available on crate feature trigonometry only.

Compute the inverse sine of the given expression

pub fn arctan(self) -> Self

Available on crate feature trigonometry only.

Compute the inverse tangent of the given expression

pub fn arctan2(self, x: Self) -> Self

Available on crate feature trigonometry only.

Compute the inverse tangent of the given expression, with the angle expressed as the argument of a complex number

pub fn cosh(self) -> Self

Available on crate feature trigonometry only.

Compute the hyperbolic cosine of the given expression

pub fn sinh(self) -> Self

Available on crate feature trigonometry only.

Compute the hyperbolic sine of the given expression

pub fn tanh(self) -> Self

Available on crate feature trigonometry only.

Compute the hyperbolic tangent of the given expression

pub fn arccosh(self) -> Self

Available on crate feature trigonometry only.

Compute the inverse hyperbolic cosine of the given expression

pub fn arcsinh(self) -> Self

Available on crate feature trigonometry only.

Compute the inverse hyperbolic sine of the given expression

pub fn arctanh(self) -> Self

Available on crate feature trigonometry only.

Compute the inverse hyperbolic tangent of the given expression

pub fn degrees(self) -> Self

Available on crate feature trigonometry only.

Convert from radians to degrees

pub fn radians(self) -> Self

Available on crate feature trigonometry only.

Convert from degrees to radians

pub fn sign(self) -> Self

Available on crate feature sign only.

Compute the sign of the given expression

impl Expr

pub fn to_field(&self, schema: &Schema, ctxt: Context) -> PolarsResult<Field>

Get Field result of the expression. The schema is the input data.

impl Expr

pub fn map_python(self, func: PythonUdfExpression, agg_list: bool) -> Expr

Available on crate feature python only.

impl Expr

pub fn shuffle(self, seed: Option<u64>) -> Self

Available on crate feature random only.

pub fn sample_n( self, n: Expr, with_replacement: bool, shuffle: bool, seed: Option<u64>, ) -> Self

Available on crate feature random only.

pub fn sample_frac( self, frac: Expr, with_replacement: bool, shuffle: bool, seed: Option<u64>, ) -> Self

Available on crate feature random only.

impl Expr

pub fn std(self, ddof: u8) -> Self

Standard deviation of the values of the Series.

pub fn var(self, ddof: u8) -> Self

Variance of the values of the Series.

pub fn min(self) -> Self

Reduce groups to minimal value.

pub fn max(self) -> Self

Reduce groups to maximum value.

pub fn nan_min(self) -> Self

Reduce groups to minimal value.

pub fn nan_max(self) -> Self

Reduce groups to maximum value.

pub fn mean(self) -> Self

Reduce groups to the mean value.

pub fn median(self) -> Self

Reduce groups to the median value.

pub fn sum(self) -> Self

Reduce groups to the sum of all the values.

pub fn hist( self, bins: Option<Expr>, bin_count: Option<usize>, include_category: bool, include_breakpoint: bool, ) -> Self

Available on crate feature hist only.

Compute the histogram of a dataset.

impl Expr

pub fn eq<E: Into<Expr>>(self, other: E) -> Expr

Compare Expr with other Expr on equality.

pub fn eq_missing<E: Into<Expr>>(self, other: E) -> Expr

Compare Expr with other Expr on equality where None == None.

pub fn neq<E: Into<Expr>>(self, other: E) -> Expr

Compare Expr with other Expr on non-equality.

pub fn neq_missing<E: Into<Expr>>(self, other: E) -> Expr

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

pub fn lt<E: Into<Expr>>(self, other: E) -> Expr

Check if Expr < Expr.

pub fn gt<E: Into<Expr>>(self, other: E) -> Expr

Check if Expr > Expr.

pub fn gt_eq<E: Into<Expr>>(self, other: E) -> Expr

Check if Expr >= Expr.

pub fn lt_eq<E: Into<Expr>>(self, other: E) -> Expr

Check if Expr <= Expr.

pub fn not(self) -> Expr

Negate Expr.

pub fn alias(self, name: &str) -> Expr

Rename Column.

pub fn is_null(self) -> Self

Run is_null operation on Expr.

pub fn is_not_null(self) -> Self

Run is_not_null operation on Expr.

pub fn drop_nulls(self) -> Self

Drop null values.

pub fn drop_nans(self) -> Self

Drop NaN values.

pub fn n_unique(self) -> Self

Get the number of unique values in the groups.

pub fn first(self) -> Self

Get the first value in the group.

pub fn last(self) -> Self

Get the last value in the group.

pub fn implode(self) -> Self

GroupBy the group to a Series.

pub fn quantile(self, quantile: Expr, interpol: QuantileInterpolOptions) -> Self

Compute the quantile per group.

pub fn agg_groups(self) -> Self

Get the group indexes of the group by operation.

pub fn flatten(self) -> Self

Alias for explode.

pub fn explode(self) -> Self

Explode the String/List column.

pub fn slice<E: Into<Expr>, F: Into<Expr>>(self, offset: E, length: F) -> Self

Slice the Series. offset may be negative.

pub fn append<E: Into<Expr>>(self, other: E, upcast: bool) -> Self

Append expressions. This is done by adding the chunks of other to this Series.

pub fn head(self, length: Option<usize>) -> Self

Get the first n elements of the Expr result.

pub fn tail(self, length: Option<usize>) -> Self

Get the last n elements of the Expr result.

pub fn unique(self) -> Self

Get unique values of this expression.

pub fn unique_stable(self) -> Self

Get unique values of this expression, while maintaining order. This requires more work than Expr::unique.

pub fn arg_unique(self) -> Self

Get the first index of unique values of this expression.

pub fn arg_min(self) -> Self

Get the index value that has the minimum value.

pub fn arg_max(self) -> Self

Get the index value that has the maximum value.

pub fn arg_sort(self, sort_options: SortOptions) -> Self

Get the index values that would sort this expression.

pub fn search_sorted<E: Into<Expr>>( self, element: E, side: SearchSortedSide, ) -> Expr

Available on crate feature search_sorted only.

Find indices where elements should be inserted to maintain order.

pub fn strict_cast(self, data_type: DataType) -> Self

Cast expression to another data type. Throws an error if conversion had overflows.

pub fn cast(self, data_type: DataType) -> Self

Cast expression to another data type.

pub fn cast_with_options( self, data_type: DataType, cast_options: CastOptions, ) -> Self

Cast expression to another data type.

pub fn gather<E: Into<Expr>>(self, idx: E) -> Self

Take the values by idx.

pub fn get<E: Into<Expr>>(self, idx: E) -> Self

Take the values by a single index.

pub fn sort(self, options: SortOptions) -> Self

Sort with given options.

Example

let lf = df! {
   "a" => [Some(5), Some(4), Some(3), Some(2), None]
}?
.lazy();

let sorted = lf
    .select(
        vec![col("a").sort(SortOptions::default())],
    )
    .collect()?;

assert_eq!(
    sorted,
    df! {
        "a" => [None, Some(2), Some(3), Some(4), Some(5)]
    }?
);

See SortOptions for more options.

pub fn top_k(self, k: Expr) -> Self

Available on crate feature top_k only.

Returns the k largest elements.

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

pub fn top_k_by<K: Into<Expr>, E: AsRef<[IE]>, IE: Into<Expr> + Clone>( self, k: K, by: E, descending: Vec<bool>, ) -> Self

Available on crate feature top_k only.

Returns the k largest rows by given column.

For single column, use Expr::top_k.

pub fn bottom_k(self, k: Expr) -> Self

Available on crate feature top_k only.

Returns the k smallest elements.

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

pub fn bottom_k_by<K: Into<Expr>, E: AsRef<[IE]>, IE: Into<Expr> + Clone>( self, k: K, by: E, descending: Vec<bool>, ) -> Self

Available on crate feature top_k only.

Returns the k smallest rows by given column.

For single column, use Expr::bottom_k.

pub fn reverse(self) -> Self

Reverse column

pub fn map<F>(self, function: F, output_type: GetOutput) -> Self

where F: Fn(Series) -> PolarsResult<Option<Series>> + 'static + Send + Sync,

Apply a function/closure once the logical plan get executed.

This function is very similar to Expr::apply, but differs in how it handles aggregations.

• map should be used for operations that are independent of groups, e.g. multiply * 2, or raise to the power
• apply should be used for operations that work on a group of data. e.g. sum, count, etc.

It is the responsibility of the caller that the schema is correct by giving the correct output_type. If None given the output type of the input expr is used.

pub fn map_many<F>( self, function: F, arguments: &[Expr], output_type: GetOutput, ) -> Self

where F: Fn(&mut [Series]) -> PolarsResult<Option<Series>> + 'static + Send + Sync,

Apply a function/closure once the logical plan get executed with many arguments.

See the Expr::map function for the differences between map and apply.

pub fn map_list<F>(self, function: F, output_type: GetOutput) -> Self

where F: Fn(Series) -> PolarsResult<Option<Series>> + 'static + Send + Sync,

Apply a function/closure once the logical plan get executed.

This function is very similar to apply, but differs in how it handles aggregations.

• map should be used for operations that are independent of groups, e.g. multiply * 2, or raise to the power
• apply should be used for operations that work on a group of data. e.g. sum, count, etc.
• map_list should be used when the function expects a list aggregated series.

pub fn function_with_options<F>( self, function: F, output_type: GetOutput, options: FunctionOptions, ) -> Self

where F: Fn(Series) -> PolarsResult<Option<Series>> + 'static + Send + Sync,

A function that cannot be expressed with map or apply and requires extra settings.

pub fn apply<F>(self, function: F, output_type: GetOutput) -> Self

where F: Fn(Series) -> PolarsResult<Option<Series>> + 'static + Send + Sync,

Apply a function/closure over the groups. This should only be used in a group_by aggregation.

It is the responsibility of the caller that the schema is correct by giving the correct output_type. If None given the output type of the input expr is used.

This difference with map is that apply will create a separate Series per group.

• map should be used for operations that are independent of groups, e.g. multiply * 2, or raise to the power
• apply should be used for operations that work on a group of data. e.g. sum, count, etc.

pub fn apply_many<F>( self, function: F, arguments: &[Expr], output_type: GetOutput, ) -> Self

where F: Fn(&mut [Series]) -> PolarsResult<Option<Series>> + 'static + Send + Sync,

Apply a function/closure over the groups with many arguments. This should only be used in a group_by aggregation.

See the Expr::apply function for the differences between map and apply.

pub fn apply_many_private( self, function_expr: FunctionExpr, arguments: &[Expr], returns_scalar: bool, cast_to_supertypes: bool, ) -> Self

pub fn map_many_private( self, function_expr: FunctionExpr, arguments: &[Expr], returns_scalar: bool, cast_to_supertypes: bool, ) -> Self

pub fn is_finite(self) -> Self

Get mask of finite values if dtype is Float.

pub fn is_infinite(self) -> Self

Get mask of infinite values if dtype is Float.

pub fn is_nan(self) -> Self

Get mask of NaN values if dtype is Float.

pub fn is_not_nan(self) -> Self

Get inverse mask of NaN values if dtype is Float.

pub fn shift(self, n: Expr) -> Self

Shift the values in the array by some period. See the eager implementation.

pub fn shift_and_fill<E: Into<Expr>, IE: Into<Expr>>( self, n: E, fill_value: IE, ) -> Self

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

pub fn cum_count(self, reverse: bool) -> Self

Available on crate feature cum_agg only.

Cumulatively count values from 0 to len.

pub fn cum_sum(self, reverse: bool) -> Self

Available on crate feature cum_agg only.

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

pub fn cum_prod(self, reverse: bool) -> Self

Available on crate feature cum_agg only.

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

pub fn cum_min(self, reverse: bool) -> Self

Available on crate feature cum_agg only.

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

pub fn cum_max(self, reverse: bool) -> Self

Available on crate feature cum_agg only.

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

pub fn product(self) -> Self

Get the product aggregation of an expression.

pub fn backward_fill(self, limit: FillNullLimit) -> Self

Fill missing value with next non-null.

pub fn forward_fill(self, limit: FillNullLimit) -> Self

Fill missing value with previous non-null.

pub fn round(self, decimals: u32) -> Self

Available on crate feature round_series only.

Round underlying floating point array to given decimal numbers.

pub fn round_sig_figs(self, digits: i32) -> Self

Available on crate feature round_series only.

Round to a number of significant figures.

pub fn floor(self) -> Self

Available on crate feature round_series only.

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

pub fn pi() -> Self

Available on crate feature round_series only.

Constant Pi

pub fn ceil(self) -> Self

Available on crate feature round_series only.

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

pub fn clip(self, min: Expr, max: Expr) -> Self

Available on crate feature round_series only.

Clip underlying values to a set boundary.

pub fn clip_max(self, max: Expr) -> Self

Available on crate feature round_series only.

Clip underlying values to a set boundary.

pub fn clip_min(self, min: Expr) -> Self

Available on crate feature round_series only.

Clip underlying values to a set boundary.

pub fn abs(self) -> Self

Available on crate feature abs only.

Convert all values to their absolute/positive value.

pub fn over<E: AsRef<[IE]>, IE: Into<Expr> + Clone>( self, partition_by: E, ) -> Self

Apply window function over a subgroup. This is similar to a group_by + aggregation + self join. Or similar to window functions in Postgres.

Example

#[macro_use] extern crate polars_core;
use polars_core::prelude::*;
use polars_lazy::prelude::*;

fn example() -> PolarsResult<()> {
    let df = df! {
            "groups" => &[1, 1, 2, 2, 1, 2, 3, 3, 1],
            "values" => &[1, 2, 3, 4, 5, 6, 7, 8, 8]
        }?;

    let out = df
     .lazy()
     .select(&[
         col("groups"),
         sum("values").over([col("groups")]),
     ])
     .collect()?;
    println!("{}", &out);
    Ok(())
}

Outputs:

╭────────┬────────╮
│ groups ┆ values │
│ ---    ┆ ---    │
│ i32    ┆ i32    │
╞════════╪════════╡
│ 1      ┆ 16     │
│ 1      ┆ 16     │
│ 2      ┆ 13     │
│ 2      ┆ 13     │
│ …      ┆ …      │
│ 1      ┆ 16     │
│ 2      ┆ 13     │
│ 3      ┆ 15     │
│ 3      ┆ 15     │
│ 1      ┆ 16     │
╰────────┴────────╯

pub fn over_with_options<E: AsRef<[IE]>, IE: Into<Expr> + Clone>( self, partition_by: E, order_by: Option<(E, SortOptions)>, options: WindowMapping, ) -> Self

pub fn fill_null<E: Into<Expr>>(self, fill_value: E) -> Self

Replace the null values by a value.

pub fn fill_null_with_strategy(self, strategy: FillNullStrategy) -> Self

pub fn fill_nan<E: Into<Expr>>(self, fill_value: E) -> Self

Replace the floating point NaN values by a value.

pub fn count(self) -> Self

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

pub fn len(self) -> Self

pub fn is_duplicated(self) -> Self

Available on crate feature is_unique only.

Get a mask of duplicated values.

pub fn is_unique(self) -> Self

Available on crate feature is_unique only.

Get a mask of unique values.

pub fn approx_n_unique(self) -> Self

Available on crate feature approx_unique only.

Get the approximate count of unique values.

pub fn and<E: Into<Expr>>(self, expr: E) -> Self

“and” operation.

pub fn xor<E: Into<Expr>>(self, expr: E) -> Self

“xor” operation.

pub fn or<E: Into<Expr>>(self, expr: E) -> Self

“or” operation.

pub fn logical_or<E: Into<Expr>>(self, expr: E) -> Self

“or” operation.

pub fn logical_and<E: Into<Expr>>(self, expr: E) -> Self

“or” operation.

pub fn filter<E: Into<Expr>>(self, predicate: E) -> Self

Filter a single column.

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

pub fn is_in<E: Into<Expr>>(self, other: E) -> Self

Available on crate feature is_in only.

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

pub fn sort_by<E: AsRef<[IE]>, IE: Into<Expr> + Clone>( self, by: E, sort_options: SortMultipleOptions, ) -> Expr

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.

Example

let lf = df! {
    "a" => [1, 2, 3, 4, 5],
    "b" => [5, 4, 3, 2, 1]
}?.lazy();

let sorted = lf
    .select(
        vec![col("a").sort_by(col("b"), SortOptions::default())],
    )
    .collect()?;

assert_eq!(
    sorted,
    df! { "a" => [5, 4, 3, 2, 1] }?
);

pub fn repeat_by<E: Into<Expr>>(self, by: E) -> Expr

Available on crate feature repeat_by only.

Repeat the column n times, where n is determined by the values in by. This yields an Expr of dtype List.

pub fn is_first_distinct(self) -> Expr

Available on crate feature is_first_distinct only.

Get a mask of the first unique value.

pub fn is_last_distinct(self) -> Expr

Available on crate feature is_last_distinct only.

Get a mask of the last unique value.

pub fn dot<E: Into<Expr>>(self, other: E) -> Expr

Compute the dot/inner product between two expressions.

pub fn mode(self) -> Expr

Available on crate feature mode only.

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

pub fn exclude(self, columns: impl IntoVec<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<D: AsRef<[DataType]>>(self, dtypes: D) -> Expr

pub fn interpolate(self, method: InterpolationMethod) -> Expr

Available on crate feature interpolate only.

Fill null values using interpolation.

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

Available on crate feature interpolate_by only.

Fill null values using interpolation.

pub fn rolling_min_by( self, by: Expr, options: RollingOptionsDynamicWindow, ) -> Expr

Available on crate feature rolling_window_by only.

Apply a rolling minimum based on another column.

pub fn rolling_max_by( self, by: Expr, options: RollingOptionsDynamicWindow, ) -> Expr

Available on crate feature rolling_window_by only.

Apply a rolling maximum based on another column.

pub fn rolling_mean_by( self, by: Expr, options: RollingOptionsDynamicWindow, ) -> Expr

Available on crate feature rolling_window_by only.

Apply a rolling mean based on another column.

pub fn rolling_sum_by( self, by: Expr, options: RollingOptionsDynamicWindow, ) -> Expr

Available on crate feature rolling_window_by only.

Apply a rolling sum based on another column.

pub fn rolling_quantile_by( self, by: Expr, interpol: QuantileInterpolOptions, quantile: f64, options: RollingOptionsDynamicWindow, ) -> Expr

Available on crate feature rolling_window_by only.

Apply a rolling quantile based on another column.

pub fn rolling_var_by( self, by: Expr, options: RollingOptionsDynamicWindow, ) -> Expr

Available on crate feature rolling_window_by only.

Apply a rolling variance based on another column.

pub fn rolling_std_by( self, by: Expr, options: RollingOptionsDynamicWindow, ) -> Expr

Available on crate feature rolling_window_by only.

Apply a rolling std-dev based on another column.

pub fn rolling_median_by( self, by: Expr, options: RollingOptionsDynamicWindow, ) -> Expr

Available on crate feature rolling_window_by only.

Apply a rolling median based on another column.

pub fn rolling_min(self, options: RollingOptionsFixedWindow) -> Expr

Available on crate feature rolling_window only.

Apply a rolling minimum.

See: [RollingAgg::rolling_min]

pub fn rolling_max(self, options: RollingOptionsFixedWindow) -> Expr

Available on crate feature rolling_window only.

Apply a rolling maximum.

See: [RollingAgg::rolling_max]

pub fn rolling_mean(self, options: RollingOptionsFixedWindow) -> Expr

Available on crate feature rolling_window only.

Apply a rolling mean.

See: [RollingAgg::rolling_mean]

pub fn rolling_sum(self, options: RollingOptionsFixedWindow) -> Expr

Available on crate feature rolling_window only.

Apply a rolling sum.

See: [RollingAgg::rolling_sum]

pub fn rolling_median(self, options: RollingOptionsFixedWindow) -> Expr

Available on crate feature rolling_window only.

Apply a rolling median.

See: [RollingAgg::rolling_median]

pub fn rolling_quantile( self, interpol: QuantileInterpolOptions, quantile: f64, options: RollingOptionsFixedWindow, ) -> Expr

Available on crate feature rolling_window only.

Apply a rolling quantile.

See: [RollingAgg::rolling_quantile]

pub fn rolling_var(self, options: RollingOptionsFixedWindow) -> Expr

Available on crate feature rolling_window only.

Apply a rolling variance.

pub fn rolling_std(self, options: RollingOptionsFixedWindow) -> Expr

Available on crate feature rolling_window only.

Apply a rolling std-dev.

pub fn rolling_skew(self, window_size: usize, bias: bool) -> Expr

Available on crate features rolling_window and moment only.

Apply a rolling skew.

pub fn rolling_map( self, f: Arc<dyn Fn(&Series) -> Series + Send + Sync>, output_type: GetOutput, options: RollingOptionsFixedWindow, ) -> Expr

Available on crate feature rolling_window only.

Apply a custom function over a rolling/ moving window of the array. This has quite some dynamic dispatch, so prefer rolling_min, max, mean, sum over this.

pub fn rolling_map_float<F>(self, window_size: usize, f: F) -> Expr

where F: 'static + FnMut(&mut Float64Chunked) -> Option<f64> + Send + Sync + Copy,

Available on crate feature rolling_window only.

Apply a custom function over a rolling/ moving window of the array. Prefer this over rolling_apply in case of floating point numbers as this is faster. This has quite some dynamic dispatch, so prefer rolling_min, max, mean, sum over this.

pub fn peak_min(self) -> Expr

Available on crate feature peaks only.

pub fn peak_max(self) -> Expr

Available on crate feature peaks only.

pub fn rank(self, options: RankOptions, seed: Option<u64>) -> Expr

Available on crate feature rank only.

Assign ranks to data, dealing with ties appropriately.

pub fn replace<E: Into<Expr>>(self, old: E, new: E) -> Expr

Available on crate feature replace only.

Replace the given values with other values.

pub fn replace_strict<E: Into<Expr>>( self, old: E, new: E, default: Option<E>, return_dtype: Option<DataType>, ) -> Expr

Available on crate feature replace only.

Replace the given values with other values.

pub fn cut( self, breaks: Vec<f64>, labels: Option<Vec<String>>, left_closed: bool, include_breaks: bool, ) -> Expr

Available on crate feature cutqcut only.

Bin continuous values into discrete categories.

pub fn qcut( self, probs: Vec<f64>, labels: Option<Vec<String>>, left_closed: bool, allow_duplicates: bool, include_breaks: bool, ) -> Expr

Available on crate feature cutqcut only.

Bin continuous values into discrete categories based on their quantiles.

pub fn qcut_uniform( self, n_bins: usize, labels: Option<Vec<String>>, left_closed: bool, allow_duplicates: bool, include_breaks: bool, ) -> Expr

Available on crate feature cutqcut only.

Bin continuous values into discrete categories using uniform quantile probabilities.

pub fn rle(self) -> Expr

Available on crate feature rle only.

Get the lengths of runs of identical values.

pub fn rle_id(self) -> Expr

Available on crate feature rle only.

Similar to rle, but maps values to run IDs.

pub fn diff(self, n: i64, null_behavior: NullBehavior) -> Expr

Available on crate feature diff only.

Calculate the n-th discrete difference between values.

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

Available on crate feature pct_change only.

Computes percentage change between values.

pub fn skew(self, bias: bool) -> Expr

Available on crate feature moment only.

Compute the sample skewness of a data set.

For normally distributed data, the skewness should be about zero. For uni-modal continuous distributions, a skewness value greater than zero means that there is more weight in the right tail of the distribution. The function skewtest can be used to determine if the skewness value is close enough to zero, statistically speaking.

see: scipy

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

Available on crate feature moment only.

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 upper_bound(self) -> Expr

Get maximal value that could be hold by this dtype.

pub fn lower_bound(self) -> Expr

Get minimal value that could be hold by this dtype.

pub fn reshape(self, dimensions: &[i64], nested_type: NestedType) -> Self

pub fn ewm_mean(self, options: EWMOptions) -> Self

Available on crate feature ewma only.

Calculate the exponentially-weighted moving average.

pub fn ewm_mean_by(self, times: Expr, half_life: Duration) -> Self

Available on crate feature ewma_by only.

Calculate the exponentially-weighted moving average by a time column.

pub fn ewm_std(self, options: EWMOptions) -> Self

Available on crate feature ewma only.

Calculate the exponentially-weighted moving standard deviation.

pub fn ewm_var(self, options: EWMOptions) -> Self

Available on crate feature ewma only.

Calculate the exponentially-weighted moving variance.

pub fn any(self, ignore_nulls: bool) -> Self

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 all(self, ignore_nulls: bool) -> Self

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 true values, the output is null.

pub fn shrink_dtype(self) -> Self

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 value_counts( self, sort: bool, parallel: bool, name: String, normalize: bool, ) -> Self

Available on crate feature dtype-struct only.

Count all unique values and create a struct mapping value to count. (Note that it is better to turn parallel off in the aggregation context).

pub fn unique_counts(self) -> Self

Available on crate feature unique_counts only.

Returns a count of the unique values in the order of appearance. This method differs from [Expr::value_counts] in that it does not return the values, only the counts and might be faster.

pub fn log(self, base: f64) -> Self

Available on crate feature log only.

Compute the logarithm to a given base.

pub fn log1p(self) -> Self

Available on crate feature log only.

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

pub fn exp(self) -> Self

Available on crate feature log only.

Calculate the exponential of all elements in the input array.

pub fn entropy(self, base: f64, normalize: bool) -> Self

Available on crate feature log only.

Compute the entropy as -sum(pk * log(pk). where pk are discrete probabilities.

pub fn null_count(self) -> Expr

Get the null count of the column/group.

pub fn set_sorted_flag(self, sorted: IsSorted) -> Expr

Set this Series as sorted so that downstream code can use fast paths for sorted arrays.

Warning

This can lead to incorrect results if this Series is not sorted!! Use with care!

pub fn hash(self, k0: u64, k1: u64, k2: u64, k3: u64) -> Expr

Available on crate feature row_hash only.

Compute the hash of every element.

pub fn to_physical(self) -> Expr

pub fn gather_every(self, n: usize, offset: usize) -> Expr

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

pub fn str(self) -> StringNameSpace

Available on crate feature strings only.

Get the string::StringNameSpace

pub fn binary(self) -> BinaryNameSpace

Get the binary::BinaryNameSpace

pub fn dt(self) -> DateLikeNameSpace

Available on crate feature temporal only.

Get the dt::DateLikeNameSpace

pub fn list(self) -> ListNameSpace

Get the list::ListNameSpace

pub fn name(self) -> ExprNameNameSpace

Get the name::ExprNameNameSpace

pub fn arr(self) -> ArrayNameSpace

Available on crate feature dtype-array only.

Get the array::ArrayNameSpace.

pub fn cat(self) -> CategoricalNameSpace

Available on crate feature dtype-categorical only.

Get the CategoricalNameSpace.

pub fn struct_(self) -> StructNameSpace

Available on crate feature dtype-struct only.

Get the struct_::StructNameSpace.

pub fn meta(self) -> MetaNameSpace

Available on crate feature meta only.

Get the meta::MetaNameSpace

impl Expr

pub fn nodes<'a>(&'a self, container: &mut UnitVec<&'a Expr>)

pub fn nodes_owned(self, container: &mut UnitVec<Expr>)

pub fn map_expr<F: FnMut(Self) -> Self>(self, f: F) -> Self

pub fn try_map_expr<F: FnMut(Self) -> PolarsResult<Self>>( self, f: F, ) -> PolarsResult<Self>

Trait Implementations

impl Add for Expr

type Output = Expr

The resulting type after applying the + operator.

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

Performs the + operation.

impl AsRef<Expr> for AggExpr

fn as_ref(&self) -> &Expr

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Expr

fn clone(&self) -> Expr

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Expr

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

Formats the value using the given formatter.

impl Default for Expr

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Expr

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Expr

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

Formats the value using the given formatter.

impl Div for Expr

type Output = Expr

The resulting type after applying the / operator.

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

Performs the / operation.

impl From<&str> for Expr

fn from(s: &str) -> Self

Converts to this type from the input type.

impl From<AggExpr> for Expr

fn from(agg: AggExpr) -> Self

Converts to this type from the input type.

impl From<bool> for Expr

fn from(val: bool) -> Self

Converts to this type from the input type.

impl From<f32> for Expr

fn from(val: f32) -> Self

Converts to this type from the input type.

impl From<f64> for Expr

fn from(val: f64) -> Self

Converts to this type from the input type.

impl From<i16> for Expr

fn from(val: i16) -> Self

Converts to this type from the input type.

impl From<i32> for Expr

fn from(val: i32) -> Self

Converts to this type from the input type.

impl From<i64> for Expr

fn from(val: i64) -> Self

Converts to this type from the input type.

impl From<i8> for Expr

fn from(val: i8) -> Self

Converts to this type from the input type.

impl From<u16> for Expr

fn from(val: u16) -> Self

Converts to this type from the input type.

impl From<u32> for Expr

fn from(val: u32) -> Self

Converts to this type from the input type.

impl From<u64> for Expr

fn from(val: u64) -> Self

Converts to this type from the input type.

impl From<u8> for Expr

fn from(val: u8) -> Self

Converts to this type from the input type.

impl Hash for Expr

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a> IntoIterator for &'a Expr

type Item = &'a Expr

The type of the elements being iterated over.

type IntoIter = ExprIter<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl Mul for Expr

type Output = Expr

The resulting type after applying the * operator.

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

Performs the * operation.

impl Neg for Expr

type Output = Expr

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl PartialEq for Expr

fn eq(&self, other: &Expr) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Rem for Expr

type Output = Expr

The resulting type after applying the % operator.

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

Performs the % operation.

impl Serialize for Expr

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Sub for Expr

type Output = Expr

The resulting type after applying the - operator.

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

Performs the - operation.

impl TreeWalker for Expr

type Arena = ()

fn apply_children<F: FnMut(&Self, &Self::Arena) -> PolarsResult<VisitRecursion>>( &self, op: &mut F, arena: &Self::Arena, ) -> PolarsResult<VisitRecursion>

fn map_children<F: FnMut(Self, &mut Self::Arena) -> PolarsResult<Self>>( self, f: &mut F, _arena: &mut Self::Arena, ) -> PolarsResult<Self>

fn visit<V: Visitor<Node = Self, Arena = Self::Arena>>( &self, visitor: &mut V, arena: &Self::Arena, ) -> PolarsResult<VisitRecursion>

Walks all nodes in depth-first-order.

fn rewrite<R: RewritingVisitor<Node = Self, Arena = Self::Arena>>( self, rewriter: &mut R, arena: &mut Self::Arena, ) -> PolarsResult<Self>

impl Eq for Expr

impl StructuralPartialEq for Expr