Setting slice of column to list of values on polars dataframe

Actually, in-place updates similar to pandas are supported in polars. Especially, the following works as expected.

df_pl[[0, 1, 2, 3], "C"] = [-1, -2, -3, -4]

Instead of a list of indices, a dataframe with single integer column may also be passed. Especially, we can do the following.

idx = df_pl.with_row_index().filter(pl.col("A") == "x").select("index")
df_pl[idx, "C"] = [-1, -2, -3, -4]

shape: (8, 3)
┌─────┬─────┬─────┐
│ A   ┆ B   ┆ C   │
│ --- ┆ --- ┆ --- │
│ str ┆ i64 ┆ i64 │
╞═════╪═════╪═════╡
│ x   ┆ 1   ┆ -1  │
│ x   ┆ 1   ┆ -2  │
│ x   ┆ 2   ┆ -3  │
│ x   ┆ 2   ┆ -4  │
│ y   ┆ 1   ┆ 5   │
│ y   ┆ 1   ┆ 6   │
│ y   ┆ 2   ┆ 7   │
│ y   ┆ 2   ┆ 8   │
└─────┴─────┴─────┘

See this answer for an alternative solution using pl.DataFrame.update.

In Polars, there is not really a notion of assigning to a slice of a DataFrame.

Edit: the above statement was incorrect. See the answer by @Hericks for how this can be achieved. Do note thought that doing so is not considered idiomatic in Polars.

Also, in when/then/otherwise, Polars expects lengths of everything to be compatible. They have to all be the same length, or be scalars that are then broadcasted.

With those things in mind, here are a few options:

Given you know that there are 4 values "x" in column A, you can split the df, update the column and concat the result back together. This works regardless of which rows the 4 "x" values are in.

pl.concat([
  df_pl.filter(pl.col("A") == "x").with_columns(C=pl.Series([-1, -2, -3, -4])),
  df_pl.filter(pl.col("A") != "x"),
])

If you also know that the "x" rows are the first 4 rows, you can pad the new values with nulls and then use when/then/otherwise or coalesce. This only works when you know they are the first 4 rows.

new_values = [-1, -2, -3, -4]
new_c = pl.Series(new_values).extend_constant(None, df_pl.height - len(new_values))
df_pl.with_columns(C=pl.coalesce(new_c, "C"))

On your example data, both of the above snippets output

shape: (8, 3)
┌─────┬─────┬─────┐
│ A   ┆ B   ┆ C   │
│ --- ┆ --- ┆ --- │
│ str ┆ i64 ┆ i64 │
╞═════╪═════╪═════╡
│ x   ┆ 1   ┆ -1  │
│ x   ┆ 1   ┆ -2  │
│ x   ┆ 2   ┆ -3  │
│ x   ┆ 2   ┆ -4  │
│ y   ┆ 1   ┆ 5   │
│ y   ┆ 1   ┆ 6   │
│ y   ┆ 2   ┆ 7   │
│ y   ┆ 2   ┆ 8   │
└─────┴─────┴─────┘

Note to anyone else reading this answer that if you are only needing to assign a scalar (literal value) or have a new list the same length as the DataFrame, just use a plain when/then/otherwise as outlined here in the user guide and here in the docs instead of the suggestions above.

If you don't know position of your x values, then you could generate "row index" on the fly and use it. For example, with pl.DataFrame.update():

new_values = [-1, -2, -3, -4]

(
    df_pl
    .with_columns(index = pl.int_range(pl.len()).over("A").cast(pl.UInt32))
    .update(
        pl.DataFrame({"A": "x", "C": new_values}).with_row_index(),
        on=["A","index"],
        how="left"
    )
    .drop("index")
)

shape: (8, 3)
┌─────┬─────┬─────┐
│ A   ┆ B   ┆ C   │
│ --- ┆ --- ┆ --- │
│ str ┆ i64 ┆ i64 │
╞═════╪═════╪═════╡
│ x   ┆ 1   ┆ -1  │
│ x   ┆ 1   ┆ -2  │
│ x   ┆ 2   ┆ -3  │
│ x   ┆ 2   ┆ -4  │
│ y   ┆ 1   ┆ 5   │
│ y   ┆ 1   ┆ 6   │
│ y   ┆ 2   ┆ 7   │
│ y   ┆ 2   ┆ 8   │
└─────┴─────┴─────┘

Or something like

(
    df_pl.with_row_index()
    .update(
        pl.DataFrame({
            "C": pl.Series(new_values),
            "index": df_pl.select((pl.col.A == "x").arg_true())
        }),
        on=["index"],
        how="left"
    )
    .drop("index")
)

shape: (8, 3)
┌─────┬─────┬─────┐
│ A   ┆ B   ┆ C   │
│ --- ┆ --- ┆ --- │
│ str ┆ i64 ┆ i64 │
╞═════╪═════╪═════╡
│ x   ┆ 1   ┆ -1  │
│ x   ┆ 1   ┆ -2  │
│ x   ┆ 2   ┆ -3  │
│ x   ┆ 2   ┆ -4  │
│ y   ┆ 1   ┆ 5   │
│ y   ┆ 1   ┆ 6   │
│ y   ┆ 2   ┆ 7   │
│ y   ┆ 2   ┆ 8   │
└─────┴─────┴─────┘

If you know that x rows positioned at the beginning of the DataFrame, you can do:

df_pl.with_columns(
    pl.Series(new_values)
    .append(df_pl["C"].tail(-len(new_values)))
    .alias("C")
)

And, if x might not be in the front of the DataFrame, but you don't care about original order of the rows, you can sort it first:

(
    df_pl.sort(
        pl.when(pl.col.A == "x").then(0).otherwise(1),
        maintain_order = True
    )
    .with_columns(
        pl.Series(new_values)
        .append(df_pl["C"].tail(-len(new_values)))
        .alias("C")
    )
)