Why Python's Walrus Operator Is a Mistake

Python’s decision to introduce the walrus operator (:=) in Python 3.8 was, in my opinion, a misstep. It’s not that I dislike fresh ideas—far from it—but this specific tool feels like it was designed to solve a problem that didn’t exist, while introducing new ones that make code harder to read and maintain.

Let’s start with a concrete example. Before the walrus operator, if you wanted to read a file line by line and process it, you would write:

with open("data.txt") as file:
    for line in file:
        if "error" in line:
            print(line.strip())

That’s clean, straightforward, and every Python developer knows what’s happening. With the walrus operator, you might be tempted to write:

with open("data.txt") as file:
    while (line := file.readline()):
        if "error" in line:
            print(line.strip())

Both achieve the same result, but the second version introduces a new element: assignment inside an expression. For a beginner, this is confusing. Even experienced developers at PythonSkillset often argue over whether this style is “more Pythonic” or just messy.

The real problem is readability. The walrus operator tempts you to pack more logic into fewer lines, but at the cost of clarity. Consider this common pattern in user input validation:

# Without walrus
while True:
    user_input = input("Enter a number: ")
    if user_input == "quit":
        break
    try:
        value = int(user_input)
    except ValueError:
        print("Invalid number")
        continue
    # Process value

# With walrus
while (user_input := input("Enter a number: ")) != "quit":
    try:
        value = int(user_input)
    except ValueError:
        print("Invalid number")
        continue
    # Process value

The walrus version seems shorter, but it buries the assignment inside the condition. If you’re scanning the code quickly, it’s easy to miss that user_input is being updated. In the original version, the assignment is explicit and obvious.

Another issue is its misuse in list comprehensions. Python’s comprehensions are already powerful, but adding the walrus operator can create cryptic expressions that are hard to debug. At PythonSkillset, we’ve seen code like:

# This is confusing
data = [expensive_function(x) for x in items if (result := expensive_function(x)) > threshold]

Without the walrus, you’d write:

# This is clearer
results = [expensive_function(x) for x in items]
filtered = [r for r in results if r > threshold]

The first version tries to save one line but sacrifices any trace of readability. If the function is expensive, you’re also calling it twice in the walrus version unless you’re careful—which defeats the purpose.

Critics will argue that the walrus operator is great for reducing repetition in while loops or capturing values in if statements. Yes, there are cases where it truly helps, like:

if (match := pattern.search(text)):
    print(f"Found: {match.group()}")

But these cases are rare in real projects. Most of the time, the walrus operator is used to write code that looks clever but actually alienates other developers. When you revisit that code six months later, you’ll struggle to understand what you were thinking.

The Python community prides itself on readability. “Code is written once but read many times” is a mantra. The walrus operator violates that principle by encouraging compact, dense syntax that prioritizes brevity over clarity. It’s a solution looking for a problem, and now that it’s here, we spend more time arguing about when to use it than actually benefiting from it.

If you’re new to Python, I’d recommend avoiding the walrus operator entirely until you have a solid grasp of the language’s fundamentals. Even then, ask yourself: does this really make my code better? In most cases, the answer is no. Stick with what’s clear, and let the walrus stay in the zoo.