SettingWithCopyWarning after df[df.a > 0]['b'] = 1 leaves the DataFrame unchanged

Why the warning appears and the DataFrame stays unchanged

When you write df[df.a > 0]['b'] = 1 pandas evaluates the expression in two steps:

1. df[df.a > 0] – row‑wise indexing.
2. ['b'] – column selection on the result of step 1.

If the intermediate object from step 1 is a view of the original data, the column selection also returns a view and the assignment updates df. If the intermediate object is a copy, the column selection returns a copy and the assignment modifies only that temporary copy, leaving df unchanged. Pandas emits a SettingWithCopyWarning when it suspects the intermediate result might be a copy.

How the decision is made

The view‑vs‑copy choice depends on the internal memory layout of the DataFrame:

• If the selected rows and columns belong to a single contiguous block of homogeneous dtype, pandas returns a view.
• Otherwise (non‑contiguous blocks, mixed dtypes, or after certain operations) it returns a copy.

This heuristic is an implementation detail; it is not guaranteed across pandas versions and is not documented as a contract.

Effect of Copy‑on‑Write (CoW)

When mode.copy_on_write is enabled (True), any chained assignment that would modify a copy is defined to be a guaranteed no‑op on the original DataFrame. Consequently:

• The SettingWithCopyWarning is suppressed, regardless of mode.chained_assignment.
• Setting mode.chained_assignment = 'raise' does not raise an exception under CoW because the operation is considered safe (it does nothing).

If CoW is disabled (False or not set), the legacy behavior applies: the warning may appear and the assignment succeeds only when a view is returned.

Reliable alternative: .loc

Using df.loc[df.a > 0, 'b'] = 1 bypasses the chained‑indexing path. The .loc setter works on the underlying data block directly, so the update is applied to df in both CoW modes and across all pandas 2.x minor releases. It is not affected by the view/copy heuristic.

What to check next

To know which semantics your pipeline is actually running under, verify the CoW flag:

import pandas as pd
print(pd.options.mode.copy_on_write)   # True → CoW enabled, False → legacy

If the flag is False, you can either keep using .loc or explicitly work on a copy (df = df.copy()) before chained assignment. If it is True, the chained assignment will silently do nothing and you should replace it with .loc or another explicit method.
Can you confirm whether pd.options.mode.copy_on_write is True? This determines whether the chained assignment is a guaranteed no‑op or may still succeed under the legacy view/copy heuristic.