Answer

The walrus operator (:=), or assignment expression operator, was introduced in Python starting from version 3.8. It was introduced to allow assignment of a value to a variable directly within expressions (for example, in loop conditions or if statements), allowing you to obtain and use the result of a function or computation immediately without repeating the call twice.

The problem that the walrus operator solves is the need to duplicate computations or write extra lines of code just for assignment: before its introduction, one had to make a separate call and then use the result.

The solution: now an expression can be assigned to a variable within a condition, making the code more concise and sometimes more readable. It's important to remember that sometimes excessive use of the walrus operator can hinder code understanding, especially for less experienced colleagues.

Code example:

while (line := input('Enter a string: ')) != 'exit':
    print(f'You entered: {line}')

Key features:

Allows declaring and using variables in a single expression (for example, within conditions)
Works with any type of returned values
Must be used cautiously: not sacrificing readability for compactness

Trick questions.

Can the walrus operator be used to assign a value to a global variable?

Yes, it can, however, the walrus operator works within the scope where it was applied. One must remember the LEGB rule and use variables outside functions carefully.

What is the difference between x = expr and (x := expr)?

x = expr is a standalone assignment statement, while (x := expr) is an expression that returns the result of expr and assigns it to x within another expression. In many cases, the latter can be used in if conditions, in a while loop, or in list comprehensions.

Can the walrus operator be used inside list comprehensions and generators?

Yes, the walrus operator is commonly used in comprehensions, which is especially convenient for avoiding repeated computations.

numbers = [int(s) for s in ['1', '2', '3', '4'] if (n := int(s)) > 2]
# Here n holds the result of int(s), saving computations

Typical mistakes and anti-patterns

Overusing the walrus operator in complex expressions
Assigning in conditions, making it hard to read
Misunderstanding the scope of the result

Real-life example

Negative case

A developer writes one long and tangled if statement with several nested walrus operators:

if (a := get_a()) and (b := a.get_b()) and (c := b.do_c()):
    print(c)

Pros:

Code is more compact

Cons:

Hard to read, complicates debugging and maintenance

Positive case

Conscious use for saving computations and readability:

while (line := sys.stdin.readline()) != '':
    process(line)