I think my most common use case is with dictionary lookups.

if (val := dct.get(key)) is not None:
    # do something with val

I've also found some cases where the walrus is useful in something like a list comprehension. I suppose expanding on the above example, you you make one that looks up several keys in a dict and gives you their corresponding values where available.

vals =  [val for key in (key1, key2, key3) if (val := dct.get(key)) is not None]

What to know about f strings

!r is a thing

!s is a thing

There is some syntax for formatting a float which will completely be forgotten that'll have to be looked up.

There is nothing else worth knowing.

Now lets moan and complain about something actually important. Like repos with languishing PRs, like SQLModel.

Python has an "Optional" type, but it's merely an alias for T | None. I wish Python had better support for FP, but each time it gets close, it doesn't quite go far enough.

For example, it now has match blocks, but there's no error if the match is exhaustive, which hurts formal proofs of correctness. Likewise, tons of other features fall a bit short, but in general it's workable with some discipline.

Walrus is more useful in a while loop.

while (data := f.read(1024)):
    pass

In lots of functional languages, you'd have some_function() return an Option type and then you'd use .map() or similar on it to only do something when the value is defined. I think, that can be done in Python's syntax, but you need a library for the Option type...

Walrus operator does an inline assignment to a variable and resolves to the value assigned. If it is in a condition statement, like "if x := y:", it assigns the value of y to x then interprets the expression of the condition as of it just said "if x:". Functionally, that means the assignment happens regardless of the value of y, but the condition only passes if the value of y is "truthy", i.e. if it's not None, an empty collection, numerically equal to zero, or just False.

Sure but that's orthogonal to f-strings.

12/26, need more practice.

This is fun, as was the JS date one. I hope people do more.

Still though, I don't think doing well or not on these necessarily mean you're good or bad with the language.

I love the walrus operator:

if (x := some_function()):
    do_something(x)
else:
    # x is None or False or something, consider it invalid

The only thing I wish was different is adding a scope, which would make x invalid outside the block. But Python's scoping rules are too dumb to handle this case.

Hmm: 17/26

Failures were:

• didn't know about the = option, but once I saw it once, I guessed right a few times
• never used ^ in Python, and didn't make the connection to XOR (I figured I'd need the math library or something)
• the r and a with =! (again, never used = option)
• edge cases in walrus operator and other things unrelated to f-strings

Most of those I missed (and many I got) I'd reject a PR over because it's not obvious enough what's going on. But I think given that, I did reasonably well.

But I learned something. Thanks for the post!

Bool being an int was part of this.

To be fair this was quite wtf-free. Mostly just unimportant formatting subtleties and stuff you'd never write.

Python definitely has bigger WTFs, like bool being an int, implicit bool conversion, implicit iteration of strings, etc.

Walrus operator. What did I just read?

Your final score: 9/26

There were more nuances and surprised than anticipated. But it should be expected, because its on this website. :D But any language with duck typing and lot of magic and interpretation, and a long history of changes and additions, used in a huge variety of environments, is bound to be surprising. I am not surprised that JavaScript and Python are surprising.

Upvote for the sanity check.

As the OP mentioned, this is a proposed/draft feature that may or may not ever happen.

With these kinda posts, should start a betting pool. To put money down on whether this feature sees the light of day within an agreed upon fixed time frame.

Does not seems to work on 3.12:

Python 3.12.11 (main, Jun 29 2025, 16:18:35) [MSC v.1944 64 bit (AMD64)] on win32
>>> def toto(tata=>[]):
  File "<stdin>", line 1
    def toto(tata=>[]):
                  ^
SyntaxError: invalid syntax

Oh wow! This would be great I really hope it's accepted and implemented, makes a lot of sense!

This is only a Draft for now though

Thank you

Yeah, but you can also write it like I proposed which is less boilerplaty and gives the same advantages

You can use mutable default arguments now with a new syntax:

https://peps.python.org/pep-0671/

def bisect_right(a, x, lo=0, hi=>len(a), *, key=None):
def connect(timeout=>default_timeout):
def add_item(item, target=>[]):
def format_time(fmt, time_t=>time.time()):

This is the way you're supposed to write it in Python.

It is something you get used to, yet I think it's sad.

Why the commercial license for pngquant? Maybe rewriting pngcrush IP and slapping a commercial license on it is copyright infringement. This is my impression of Rust. Take others IP, rewrite it in Rust, poof copyright magically transferred. The C99 version how much of that is from prior art?

Lets just ignore prior art and associated license terms

pngquant commercial license

written by Kornel Lesiński

ImageOptim Ltd. registered in England and Wales under company number 10288649 whose registered office is at International House, 142 Cromwell Road, London, England, SW7 4EF

First commit Sep 17th, 2009

pngcrush license

Copyright (C) 1998-2002, 2006-2016 Glenn Randers-Pehrson

glennrp at users.sf.net

Portions copyright (C) 2005 Greg Roelofs

Bookmarking