What does colon equal (:=) in Python mean?

What does the := operand mean, more specifically for Python?

Can someone explain how to read this snippet of code?

node := root, cost = 0
frontier := priority queue containing node only
explored := empty set

Updated answer

In the context of the question, we are dealing with pseudocode, but starting in Python 3.8, := is actually a valid operator that allows for assignment of variables within expressions:

# Handle a matched regex
if (match := pattern.search(data)) is not None:
    # Do something with match

# A loop that can't be trivially rewritten using 2-arg iter()
while chunk := file.read(8192):
   process(chunk)

# Reuse a value that's expensive to compute
[y := f(x), y**2, y**3]

# Share a subexpression between a comprehension filter clause and its output
filtered_data = [y for x in data if (y := f(x)) is not None]

See PEP 572 for more details.

Original Answer

What you have found is pseudocode

> Pseudocode is an informal high-level description of the operating > principle of a computer program or other algorithm.

:= is actually the assignment operator. In Python this is simply =.

To translate this pseudocode into Python you would need to know the data structures being referenced, and a bit more of the algorithm implementation.

Some notes about psuedocode:

• := is the assignment operator or = in Python
• = is the equality operator or == in Python
• There are certain styles, and your mileage may vary:

Pascal-style

procedure fizzbuzz
For i := 1 to 100 do
    set print_number to true;
    If i is divisible by 3 then
        print "Fizz";
        set print_number to false;
    If i is divisible by 5 then
        print "Buzz";
        set print_number to false;
    If print_number, print i;
    print a newline;
end

C-style

void function fizzbuzz
For (i = 1; i <= 100; i++) {
    set print_number to true;
    If i is divisible by 3
        print "Fizz";
        set print_number to false;
    If i is divisible by 5
        print "Buzz";
        set print_number to false;
    If print_number, print i;
    print a newline;
}

Note the differences in brace usage and assignment operator.

PEP572 proposed support for the := operator in Python to allow variable assignments within expressions.

This syntax is available in Python 3.8.

The code in the question is pseudo-code; there, := represents assignment.

For future visitors, though, the following might be more relevant: the next version of Python (3.8) will gain a new operator, :=, allowing assignment expressions (details, motivating examples, and discussion can be found in PEP 572, which was provisionally accepted in late June 2018).

With this new operator, you can write things like these:

if (m := re.search(pat, s)):
    print m.span()
else if (m := re.search(pat2, s):
    …

while len(bytes := x.read()) > 0:
    … do something with `bytes`

[stripped for l in lines if len(stripped := l.strip()) > 0]

instead of these:

m = re.search(pat, s)
if m:
    print m.span()
else:
    m = re.search(pat2, s)
    if m:
        …

while True:
    bytes = x.read()
    if len(bytes) <= 0:
        return
    … do something with `bytes`

[l for l in (l.stripped() for l in lines) if len(l) > 0]

This symbol := is an assignment operator in Python (mostly called as the Walrus Operator). In a nutshell, the walrus operator compresses our code to make it a little shorter.

---

Here's a very simple example:

# without walrus
n = 30
if n > 10:
    print(f"{n} is greater than 10")

# with walrus
if (n := 30) > 10:
    print(f"{n} is greater than 10")

These codes are the same (and outputs the same thing), but as you can see, the version with the walrus operator is compressed in just two lines of code to make things more compact.

---

Now, why would you use the walrus operator?

First off, don't feel obligated.

I myself even rarely use this one. I'm just using the walrus operator to compress my code a little bit, mostly when I'm working with regular expressions.

You can also find your own use case of this. What's important is you have a rough idea about it and knows when it might be helpful when you encountered a problem like this one.

And this is by far how can I explain walrus operator in a higher level. Hope you learned something.

Happy 3.8 Release on 14th of October!

> There is new syntax := that assigns values to variables as part of a larger expression. It is affectionately known as “the walrus operator” due to its resemblance to the eyes and tusks of a walrus. > > In this example, the assignment expression helps avoid calling len() twice: > > if (n := len(a)) > 10: print(f"List is too long ({n} elements, expected <= 10)") >

What’s New In Python 3.8 - Assignment expressions