The walrus operator := is a nice way to avoid repetitions of function calls and statements. It simplifies your code. You can compare the two following code snippets:
grades = [1, 12, 14, 17, 5, 8, 20]
stats = {
'nb_grades': len(grades),
'sum': sum(grades),
'mean': sum(grades)/len(grades)
}
grades = [1, 12, 14, 17, 5, 8, 20]
stats = {
'nb_grades': (nb_grades := len(grades)),
'sum': (sum_grades := sum(grades)),
'mean': sum_grades/nb_grades
}
Note: The parentheses are mandatory for the plain assignment to work.
Same goes for function calls:
foo = "hello world!"
if (n := len(foo)) > 4:
print(f"foo is of length {n}")
foo is of length 12
In the above snippet, the len() method has only been called once instead of twice. More generally, you can assign values to variables on the fly without having to call the same methods more than once.
Important: The python walrus operator := (officially known as assignment expression operator) has been introduced by Python 3.8. This mean, once implemented, your code won’t be backward compatible anymore.
Note: The “walrus operator” affective appellation is due to its resemblance to the eyes and tusks of a walrus.
More examples
python> [name for _name in ["OLIVIER", "OLIVIA", "OLIVER"] if "vi" in (name := _name.lower())]
['olivier', 'olivia']
In this example, we are iterating through the list, storing each item of the list into the temporary _name variable. Then, we apply the lower() string method on the _name object, turning the upper case string into lower case. Next, we store the lower case value into the name variable using the walrus operator. Finally, we filter the values using the predicate to only keep the names containing “vi”.
The alternative without the walrus operator would have been:
python> [name.lower() for name in ["OLIVIER", "OLIVIA", "OLIVER"] if "vi" in name.lower()]
['olivier', 'olivia']
As you can see, this above code snipped is less “optimized” as you call the len() method twice on the same object.
You can also use the walrus operator without performing any filtering. The following code works like a charm:
python> [name for _name in ["OLIVIER", "OLIVIA", "OLIVER"] if (name := _name.lower())]
['olivier', 'olivia', 'oliver']
However, this is highly counter-intuitive and calls for errors. The presence of if let’s assume that there is a conditional check and filtering in place. Which is not the case. The codebase does not benefit from such design since the following snippet – on top of being clearer – is strictly equivalent in term of outcome:
python> [name.lower() for name in ["OLIVIER", "OLIVIA", "OLIVER"]]
['olivier', 'olivia', 'oliver']
Note: Developers tend to be very smart people. We sometime like to show off our smarts by demonstrate our mental juggling abilities. Resist the tentation of writing complex code. Programming is a social activity (e.g. all the collaborative open source projects). Be professional and keep the nerdy brilliant workarounds for your personal projects. Follow the KISS principle: Keep It Simple Stupid. Clarity is all that matters. You want to maximize the codebase discoverability.
Last but not least, you can also use the walrus operator inside while conditional statements:
while (answer := int(input())) != 42:
print("This is not the Answer to the Ultimate Question of Life, the Universe, and Everything.")
python> python script.py
7
This is not the Answer to the Ultimate Question of Life, the Universe, and Everything.
3
This is not the Answer to the Ultimate Question of Life, the Universe, and Everything.
42
Note: In the above examples we have used list comprehension. This article (in progress) explains this design in more detail.
One more thing
You cannot do a plain assignment with the walrus operator. At least, it is not that easy:
python> a := 42
File "<stdin>", line 1
a := 42
^^
SyntaxError: invalid syntax
For the above code snippet to work, you need to enclose the assignment expression around parentheses:
python> a = 42
python> (a := 18)
18
python> print(a)
18
Who told you that Software Developers were not sentimental? ❤️