In today's article, we will talk about the Walrus Operator := in Python. The walrus operator is an assignment operator which was introduced in Python 3.8. But it is not just an assignment operator, it also returns the value after the assignment.
This is the general syntax of the walrus operator
(var := expression/ function)
Although the parenthesis is not necessary, it is a good practice
So what does the Walrus operator do?
- The value of the expression is assigned to the variable var
- After assignment, the value is also returned.
Before Python 3.8, if you wanted to assign the value returned by an expression/function to a variable and print the value, below is how you would do it
var = expression/function
print(var)
But using the walrus operator, this can be done in a single line
print(var := expression/function)
Let's compare some code snippets with and without the walrus operator
Print statements
Python 3.7
def func(x):
return x+1
var = 0
var = func(var)
print(var)
Python 3.8
def func(x):
return x+1
var = 0
print( var := func(var) )
The value returned by the function func is first assigned to the variable var. After the assignment, the value is returned and the print statement displays it on the command line.
If statements
Python 3.7
lst = [1,2,3]
n = len(lst)
if n < 10:
print("It is a small list")
print(n)
Python 3.8
lst = [1,2,3]
if (n:= len(lst)) < 10:
print("It is a small list")
print(n)
while loop
Python 3.7
n = 0
while(n < 10):
print(n)
n +=1
Python 3.8
n = 0
while(n := n +1) < 10:
print(n)
Lists
Python 3.7
def func(x):
return x + 1
y = func(2)
lst = [y , y*y , y*y*y]
print(lst)
Python 3.8
def func(x):
return x + 1
lst = [y:=func(2),y*y,y*y*y]
print(lst)
List Comprehension
Python 3.7
def computationally_expensive_function(x):
'''
Imagine this is some computatationally expensive function
'''
return 2
nums = [1,2,3]
lst = [computationally_expensive_function(num) for num in nums if computationally_expensive_function(num) > 0]
print(lst)
Python 3.8
def computationally_expensive_function(x):
'''
Imagine this is some computatationally expensive function
'''
return 2
nums = [1,2,3]
lst = [var for num in nums if (var := computationally_expensive_function(num))> 0]
print(lst)
Instead of calling the computation expensive function twice, we only call it once when using the walrus operator.