Functions#

These functions are available from the polars module root and can be used as expressions, and sometimes also in eager contexts.


Available in module namespace:

all()

Either return an expression representing all columns, or evaluate a bitwise AND operation.

all_horizontal(*exprs)

Compute the bitwise AND horizontally across columns.

any()

Evaluate a bitwise OR operation.

any_horizontal(*exprs)

Compute the bitwise OR horizontally across columns.

apply(exprs, function[, return_dtype, ...])

Apply a custom/user-defined function (UDF) in a GroupBy context.

approx_n_unique(column)

Approximate count of unique values.

arange()

Generate a range of integers.

arctan2(y, x)

Compute two argument arctan in radians.

arctan2d(y, x)

Compute two argument arctan in degrees.

arg_sort_by(exprs, *more_exprs[, descending])

Return the row indices that would sort the columns.

arg_where()

Return indices where condition evaluates True.

avg()

Alias for mean.

coalesce(exprs, *more_exprs)

Folds the columns from left to right, keeping the first non-null value.

concat_list(exprs, *more_exprs)

Horizontally concatenate columns into a single list column.

concat_str(exprs, *more_exprs[, separator])

Horizontally concatenate columns into a single string column.

corr(a, b, *[, method, ddof, propagate_nans])

Compute the Pearson's or Spearman rank correlation correlation between two columns.

count()

Count the number of values in this column/context.

cov(a, b)

Compute the covariance between two columns/ expressions.

cumfold(acc, function, exprs, *[, include_init])

Cumulatively accumulate over multiple columns horizontally/ row wise with a left fold.

cumreduce(function, exprs)

Cumulatively accumulate over multiple columns horizontally/ row wise with a left fold.

cumsum()

Cumulatively sum all values.

cumsum_horizontal(*exprs)

Cumulatively sum all values horizontally across columns.

date(year, month, day)

Create a Polars literal expression of type Date.

datetime(year, month, day[, hour, minute, ...])

Create a Polars literal expression of type Datetime.

date_range()

Generate a date range.

date_ranges()

Create a column of date ranges.

duration(*[, days, seconds, nanoseconds, ...])

Create polars Duration from distinct time components.

element()

Alias for an element being evaluated in an eval expression.

exclude(columns, *more_columns)

Represent all columns except for the given columns.

first()

Get the first value.

fold(acc, function, exprs)

Accumulate over multiple columns horizontally/ row wise with a left fold.

format(f_string, *args)

Format expressions as a string.

from_epoch()

Utility function that parses an epoch timestamp (or Unix time) to Polars Date(time).

groups(column)

Syntactic sugar for pl.col("foo").agg_groups().

head()

Get the first n rows.

implode(name)

Aggregate all column values into a list.

int_range()

Generate a range of integers.

int_ranges()

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

last()

Get the last value.

lit(value[, dtype, allow_object])

Return an expression representing a literal value.

map(exprs, function[, return_dtype])

Map a custom function over multiple columns/expressions.

max()

Get the maximum value.

max_horizontal(*exprs)

Get the maximum value horizontally across columns.

mean()

Get the mean value.

median()

Get the median value.

min()

Get the minimum value.

min_horizontal(*exprs)

Get the minimum value horizontally across columns.

n_unique()

Count unique values.

ones()

Construct a column of length n filled with ones.

quantile(column, quantile[, interpolation])

Syntactic sugar for pl.col("foo").quantile(..).

reduce(function, exprs)

Accumulate over multiple columns horizontally/ row wise with a left fold.

repeat()

Construct a column of length n filled with the given value.

rolling_corr(a, b, *, window_size[, ...])

Compute the rolling correlation between two columns/ expressions.

rolling_cov(a, b, *, window_size[, ...])

Compute the rolling covariance between two columns/ expressions.

select(*exprs, **named_exprs)

Run polars expressions without a context.

std()

Get the standard deviation.

struct()

Collect columns into a struct column.

sum()

Sum all values.

sum_horizontal(*exprs)

Sum all values horizontally across columns.

sql_expr()

Parse one or more SQL expressions to polars expression(s).

tail()

Get the last n rows.

time([hour, minute, second, microsecond])

Create a Polars literal expression of type Time.

time_range()

Generate a time range.

time_ranges()

Create a column of time ranges.

var()

Get the variance.

when(condition)

Start a when-then-otherwise expression.

zeros()

Construct a column of length n filled with zeros.

Available in expression namespace:

Expr.all([drop_nulls])

Check if all boolean values in a Boolean column are True.

Expr.any([drop_nulls])

Check if any boolean value in a Boolean column is True.

Expr.apply(function[, return_dtype, ...])

Apply a custom/user-defined function (UDF) in a GroupBy or Projection context.

Expr.approx_n_unique()

Approximate count of unique values.

Expr.count()

Count the number of values in this expression.

Expr.cumsum(*[, reverse])

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

Expr.exclude(columns, *more_columns)

Exclude columns from a multi-column expression.

Expr.first()

Get the first value.

Expr.head([n])

Get the first n rows.

Expr.implode()

Aggregate values into a list.

Expr.map(function[, return_dtype, agg_list])

Apply a custom python function to a Series or sequence of Series.

Expr.max()

Get maximum value.

Expr.mean()

Get mean value.

Expr.median()

Get median value using linear interpolation.

Expr.min()

Get minimum value.

Expr.n_unique()

Count unique values.

Expr.quantile(quantile[, interpolation])

Get quantile value.

Expr.std([ddof])

Get standard deviation.

Expr.sum()

Get sum value.

Expr.tail([n])

Get the last n rows.

Expr.var([ddof])

Get variance.