Polars · Class

Expr

polars.Expr is Polars' composable expression type for describing column computations. Expressions support operators and methods and can be evaluated in DataFrame, LazyFrame, grouping, and window contexts.

How it works

An Expr is Polars' composable description of a column computation. Create expressions with helpers such as pl.col, combine them with operators or methods, and pass them to DataFrame or LazyFrame contexts for evaluation.

Syntax

class polars.Expr

Returns

An expression object used to describe computations; individual Expr methods return Expr unless their documentation specifies another return type.

Key points

Expr objects describe reusable column computations that Polars can evaluate in multiple contexts.
Addition can be written with the + operator or the corresponding Expr.add method.
Use alias to assign a name to the resulting expression.
The cast method changes an expression's output data type.
The all method reduces a boolean expression by checking whether every value is true.

Common mistakes

Using a negative index with Expr.get is supported, but it prevents streaming execution.

Example: Compose expressions in a DataFrame transformation

import polars as pl

df = pl.DataFrame({"value": [1, 2, 3], "group": ["a", "a", "b"]})
result = df.with_columns(
    (pl.col("value") * 2).alias("doubled"),
    pl.col("value").sum().over("group").alias("group_total"),
)
print(result)

Build column expressions, combine them with arithmetic, rename them, and evaluate them in a DataFrame transformation.

When to use it

Feature engineering

Create derived columns by combining existing columns with arithmetic, comparisons, or conditional methods.

Grouped and window calculations

Apply aggregations or transformations within groups while preserving expression-based query composition.

Type conversion

Convert expression results to a required Polars data type before downstream operations.

Interview questions

QWhat is an Expr in Polars?

Expr represents a computation that can be used in different Polars contexts. Expressions are composed first and evaluated when supplied to a DataFrame or LazyFrame operation.

Follow-up: How would you create a column expression? Use pl.col("name"), then compose it with methods or operators before evaluating it in a transformation.

QHow can expressions be combined?

Polars overloads common Python operators for Expr, including arithmetic, comparisons, logical operations, and bitwise operations. These operators also have corresponding Expr methods, such as add, eq, and and_.

Follow-up: What is the distinction between logical and integer use of and_? It combines boolean expressions logically, while operating bitwise when the operands are integers.

QWhere are Expr objects evaluated?

Expressions can be evaluated in contexts such as DataFrame transformations and grouped or windowed calculations. For example, an aggregation can be applied over a grouping key with sum().over("group").

Follow-up: What is a window expression? It computes an expression over groups while retaining row-level output alignment, unlike a plain aggregation that reduces rows.

polars.col
polars.Expr.add
polars.Expr.alias
polars.Expr.and_
polars.Expr.cast
polars.Expr.get
polars.Expr.sum
polars.Expr.over

Source: Expressions — Polars documentation. Checked 2026-10-15.