The walrus operator collapses the classic 'read once, check, read again' pattern into a single line: while (chunk := stream.readline()):. The expression evaluates to the assigned value, so an empty string (the EOF sentinel from readline) makes the loop exit naturally. This is the cleanest pattern for streams, generators with sentinels, and any iterator-like API that does not implement the iterator protocol. The parentheses around the walrus expression are required when it is the entire condition.

Without the walrus operator, you would call parse_amount(s) twice in this comprehension: once to filter and once to project. The walrus assigns the result to n inside the predicate, then the output expression n reuses it. This pattern is everywhere in real code: regex matches, type conversions, dictionary lookups. The trade-off is reduced readability for simple cases; reach for it when the expression on the left is genuinely expensive or has side effects.

Before the walrus operator, the canonical regex match required either a separate m = re.match(...) line before each if, or an outer assignment that polluted scope unnecessarily. With if (m := re.match(...)), the assignment is bound only when the branch is taken, and you can use m.group(...) inside the body without wondering whether m was set. Chaining multiple patterns with elif makes the dispatch read like a parser. This is the example most PEP-572 advocates lead with, and for good reason.