What does Python's walrus operator `:=` do, and how does it differ from `=`?

### Statements have no value; expressions do Python draws a hard line between statements and expressions. An expression evaluates to an object: `len(s)`, `a + b`, `f(x)`. A statement performs an action and yields nothing you can capture: `import`, `return`, `for`, and — crucially — ordinary assignment. In C you can write `while ((c = getchar()) != EOF)` because `=` there is an operator that produces a value. Python deliberately made `=` a statement, largely to stop `if (x = 1)` typos from silently passing where `if (x == 1)` was meant. That decision cost something. Any time you wanted to *use* a value and *test* it, you had to write the value twice, or bind it on a line before and lose the tight coupling between the test and its subject. ### What `:=` actually is PEP 572 (Python 3.8) added the **assignment expression**, spelled `NAME := expression` and nicknamed the walrus operator for its resemblance to eyes and tusks. It does two things in one evaluation: 1. it evaluates the right-hand expression and binds the result to the name, exactly as `=` would; 2. the assignment expression itself evaluates to that same object. So `(n := len("hello"))` is an expression worth `5` that also leaves `n` bound to `5`. It is the same binding machinery — the name lands in the enclosing function, class or module scope, exactly where a normal `=` on the same line would put it. Nothing is copied; the name is bound to the same object the right-hand side produced. ### The three idioms it exists for **Capture and test.** Instead of calling a matcher, storing the result, then testing it on the next line, you fold the two together: ```python import re if m := re.fullmatch(r"(\w+)_(\d+)", name): print(m[1], m[2]) ``` The body only runs when the match succeeded, and `m` is right there to use. **Read until the source is exhausted.** Without `:=`, you either duplicate the read or write `while True:` with a `break`. With it, the loop condition carries the read. **Avoid computing an expensive value twice.** `if (total := expensive(x)) > limit: report(total)` calls `expensive` once, where the naive version either calls it twice or needs a preceding line. ### The rules that trip people up The **target must be a single plain identifier**. `obj.attr := 1`, `d["k"] := 1` and `(a, b) := pair` are all `SyntaxError`; if you need those, use a normal assignment statement. There is also no augmented form — `x += 1` has no expression counterpart. An assignment expression is **not allowed to stand alone as a statement**: `x := 5` on its own line is a `SyntaxError`, precisely so that nobody writes it where `=` was intended. Parenthesise it, or just use `=`. The same rule bites on the right-hand side of an assignment (`y = (x := 0)` is fine, `y = x := 0` is not) and on the value of a keyword argument in a call (`f(mode=(m := "RGB"))` needs the parentheses; a positional `f(m := "RGB")` does not). Because `:=` binds more loosely than every other operator, `if n := len(s) > 10:` does not do what it looks like — it binds `n` to a boolean. That is a silent wrong-value bug rather than a syntax error, which is why the parenthesised form is the one you see in every example. ### Where you will actually see it Two positions account for almost every real use. In a `while` condition it carries the call that both advances the loop and decides when to stop. In an `if` condition it captures the thing the test is about — a match object, a lookup result, a parsed value — so the body can use it without recomputing. Outside conditions the operator is legal but rarely worth it: at the top of a statement you already have `=`, which is shorter and puts the name where a reader's eye expects to find it. ### When it earns its place The operator is a readability tool, and it can cut both ways. It pays when it removes a repeated computation, a priming read, or a temporary variable whose only job was to be tested on the next line. It stops paying when several walruses share one condition, when the bound name is used far away from where it was bound, or when the expression grows long enough that a reader has to hunt for the binding. The style rule most teams settle on is simple: one assignment expression per condition, used immediately, or don't use it. Everything above is true on Python 3.14; the semantics have not changed since 3.8, and the only compatibility question is whether your minimum supported interpreter is 3.8 or newer.