How can I perform a rolling aggregation without manually adding a temporary index column?

Pure expressions approach (apparently slow)

You can use concat_list with shift

PYTHONCopied
(
    df
    .with_columns(
        y=pl.concat_list(
            pl.col('x').shift(x) 
            for x in range(2,-2,-1)
            )
        .list.drop_nulls()
        )
)
shape: (4, 2)
┌─────┬───────────────────┐
│ x   ┆ y                 │
│ --- ┆ ---               │
│ f64 ┆ list[f64]         │
╞═════╪═══════════════════╡
│ 1.2 ┆ [1.2, 1.3]        │
│ 1.3 ┆ [1.2, 1.3, 3.4]   │
│ 3.4 ┆ [1.2, 1.3, … 3.5] │
│ 3.5 ┆ [1.3, 3.4, 3.5]   │
└─────┴───────────────────┘

There are a couple things to note here.

1. When the input to shift is positive, that means to go backwards which is the opposite of your notation.
2. range can count backwards with (start, stop, increment) but stop is non-inclusive so when entering that parameter, it needs an extra -1.
3. At the end of the concat_list you need to manually drop the nulls that it will have for items at the beginning and end of the series.

As always, you can wrap this into a function, including a translation of your preferred notation to what you actually need in range for it to work.

PYTHONCopied
from typing import Sequence


def my_roll(in_column: str | pl.Expr, window: Sequence):
    if isinstance(in_column, str):
        in_column = pl.col(in_column)
    pl_window = range(-window[0], -window[1] - 1, -1)
    return pl.concat_list(in_column.shift(x) for x in pl_window).list.drop_nulls()

which then allows you to do

PYTHONCopied
df.with_columns(y=my_roll("x", [-2,1]))

If you don't care about static typing you can even monkey patch it to pl.Expr like this pl.Expr.my_roll = my_roll and then do df.with_columns(y=pl.col("x").my_roll([-2,1])) but your pylance/pyright/mypy/etc will complain about it not existing.

Another approach that's kind of cheating if you're an expression purist

You can combine the built in way featuring .with_row_index and .rolling into a .map_batches that just turns your column into a df and spits back the series you care about.

PYTHONCopied
def my_roll(in_column: str | pl.Expr, window):
    if isinstance(in_column, str):
        in_column = pl.col(in_column)
    period = f"{window[1]-window[0]+1}i"
    offset = f"{window[0]-1}i"
    return in_column.map_batches(
        lambda s: (
            s.to_frame()
            .with_row_index()
            .select(
                pl.col(s.name).rolling(
                    index_column="index", 
                    period=period, 
                    offset=offset
                )
            )
            .get_column(s.name)
        )
    )

The way this works is that map_batches will turn your column into a Series and then run a function on it where the function returns another Series. If we make the function turn that Series into a DF, then attach the row_index, do the rolling, and get the resultant Series then that gives you exactly what you want all contained in an expression. It should be just as performant as the verbose way, assuming you don't have any other use of the row_index.

then you do

PYTHONCopied
df.with_columns(y=my_roll("x", [-2,1]))

It looks like pl.Expr.rolling() expects string as as an index column, so need a fixed column. You can use pl.DataFrame.select() instead of pl.DataFrame.with_columns() if it makes it better:

PYTHONCopied
df.with_row_index().select(
    df.columns,
    y = pl.col("x").rolling(index_column="index", period = "4i", offset = "-3i")
)

PLAINTEXTCopied
shape: (4, 2)
┌─────┬───────────────────┐
│ x   ┆ y                 │
│ --- ┆ ---               │
│ f64 ┆ list[f64]         │
╞═════╪═══════════════════╡
│ 1.2 ┆ [1.2, 1.3]        │
│ 1.3 ┆ [1.2, 1.3, 3.4]   │
│ 3.4 ┆ [1.2, 1.3, … 3.5] │
│ 3.5 ┆ [1.3, 3.4, 3.5]   │
└─────┴───────────────────┘

You could also use pl.DataFrame.rolling() which allows expressions as index column, and use pl.int_range() but it doesn't look much better to be honest:

PYTHONCopied
df.with_columns(
    df
    .rolling(index_column=pl.int_range(pl.len()), period = "4i", offset = "-3i")
    .agg(pl.col.x.alias("y"))["y"]
)

PLAINTEXTCopied
shape: (4, 2)
┌─────┬───────────────────┐
│ x   ┆ y                 │
│ --- ┆ ---               │
│ f64 ┆ list[f64]         │
╞═════╪═══════════════════╡
│ 1.2 ┆ [1.2, 1.3]        │
│ 1.3 ┆ [1.2, 1.3, 3.4]   │
│ 3.4 ┆ [1.2, 1.3, … 3.5] │
│ 3.5 ┆ [1.3, 3.4, 3.5]   │
└─────┴───────────────────┘