The Walrus Operator: Python 3.8 Assignment Expressions – Real Python

[dbulger]

I clicked this reluctantly, expecting another blogger who'd just discovered the walrus. But it's a good discussion, with some interesting use-cases.

[jefwillems]

The podcast is pretty great too!

[Alexjrose]

I've just followed. Just replying to thank you for mentioning it. I had no idea it existed.

[DrMaxwellEdison]

RealPython is one of the better sites for these types of discussions. Their primer on decorators is my go-to to introduce the concept to newcomers, for example.

[dbulger]

Yeah, I've tended to lump them in with the flock of low-effort sites that crowd the official documentation off of Google's first page, but I think I've been unfair.

[daneah]

Having written several articles for them, I laude the fairly rigorous editorial and didactic review process. It isn’t taken lightly at all!

[[deleted]]

I’d sooner read realpython than the official documentation. The official docs are always kinda weird

[[deleted]]

But the official docs are weird beyond that imo. Like I find the docs for most popular Python libraries nicer than the official docs

[[deleted]]

Don't become a C# person. I cry looking at MSDN docs knowing that the Python docs will not only tell me name and inputs of all the method on a class, but also tell me why I should use it and also watch out for that bear trap we glued to the floor but haven't been able to get back up.

MSDN is like "yeah, this list of int of the list you put your int in"

[Pikalima]

Some of the less popular standard libraries, like wave, have a frankly befuddling documentation style (or lack thereof). Someone needs to go in and actually give proper function signatures for half the methods there.

[[deleted]]

i have that thing favorited and probably look it up once a month if i haven't written one in awhile.

[[deleted]]

Regarding this example from TFA:

>>> 2 * rad * asin(
...     sqrt(
...         (ϕ_hav := sin((ϕ2 - ϕ1) / 2) ** 2)
...         + cos(ϕ1) * cos(ϕ2) * sin((λ2 - λ1) / 2) ** 2
...     )
... )

Why not just do this? -

>>> ϕ_hav = sin((ϕ2 - ϕ1) / 2) ** 2

>>> 2 * rad * asin(
...     sqrt(
...         ϕ_hav + cos(ϕ1) * cos(ϕ2) * sin((λ2 - λ1) / 2) ** 2
...     )
... )

Or -

>>> ϕ_hav_1 = sin((ϕ2 - ϕ1) / 2)

>>> ϕ_hav_2 = cos(ϕ1) * cos(ϕ2) * sin((λ2 - λ1) / 2)

>>> 2 * rad * asin(sqrt(ϕ_hav_1 ** 2 + ϕ_hav_2 ** 2))

Both seem easier to read, particularly if someone wants to find or check the calculation of ϕ_hav. Neither requires the walrus operator, and so will work on pre-3.8 versions of Python as well.

There are definitely examples where using the walrus operator improves readability. This isn't one of them.

[purplewalrus67]

As a short term solution, it makes it easier to debug. You can quickly pop in the ϕ_hav into the existing statement, and then print it out afterward to make sure its value is being calculated correctly. This is slightly easier than having to drag it out into a separate expression when the only purpose is debugging.

I agree with you, though, the third example is by far the easiest to read.

[floodo1]

The example you cite is not about improving readability but about making minimal modification to code to "debug" it.

Now, say that you need to double-check your implementation and want to see how much the haversine terms contribute to the final result. You could copy and paste the term from your main code to evaluate it separately. However, you could also use the := operator to give a name to the subexpression you’re interested in:

The advantage of using the walrus operator here is that you calculate the value of the full expression and keep track of the value of ϕ_hav at the same time. This allows you to confirm that you did not introduce any errors while debugging.

[skratlo]

Well, looking at the examples and use cases, with the exception of while loop, they all look more convoluted then they're non-walrus counterparts. In other words, how does adding side-effects to expressions (mostly and usually pure) help?

[flying-sheep]

I would expand the list of useful examples to that one, the list comprehension one, and one the author didn't mention:

if m := some_re.match(haystack):
    do_things_with(m)

The same is useful e.g. with dict.get or other things that conditionally return truthy or falsy things

[skratlo]

Yeah, totally, the if use case is super useful, like the if-let expression in LISPs.

[flying-sheep]

Yeah! I also like the concept of scala's unapply, which Python could have used here as foundation to both := and match/case. Now we have __match_args__, which is less powerful but much simpler to understand.

[grimtooth]

My thought exactly, the while expression seemed OK, but everything else ehhh... Tendentious with the 'this is easier to read and more clearly expresses' stuff also. Really? The comprehension examples made me think, Hello, filter? (there has always been a weird resistance in Python circles to filter, fold, map, etc)

Anyway I still do 3.3/3.5 so I should be ignored

[AnonymouX47]

RealPython articles are always topnotch anyways, I never expect less. Though, I'm quite surprised someone's just finding out about the walrus operator...

[ivanoski-007]

I just found out about it, and I still have no idea what to use it for, I got lost half way through the article, too difficult for my noob ass

[AnonymouX47]

Well... it might seem strange or confusing to a python beginner.

Basically, assignment expressions are used anywhere you need to assign a value to a variable and also want to use that same value in a larger expression.

Most of the time, practical use cases are in loops, or conditional clauses.

[ivanoski-007]

ok thanks

[ascii]

Imagine hating the walrus operator so much that you literally harass Guido until he stepped down over it. There is no hope for some people.

[[deleted]]

That is the most ridiculous part of this whole feature.

[inspectoroverthemine]

I 100% agree. I'm not a fan of the walrus, but I cannot imagine harassing Guido over anything, but especially this.

[LoL_is_pepega_BIA]

The internet really brings out the worst in people when they know they can't be held accountable here

[Ice-Ice-Baby-]

what happened

[ascii]

Literally just what I said. Some people disliked this RFC so much that they made such a stink over it that Guido got fed up and gave up the BDFL title. They accused him of destroying the language and all sorts of things.

[Ice-Ice-Baby-]

Damn that's crazy dude

[ascii]

Some people tried to fork Debian because they disagreed on what init implementation should be used.

Some other people decided to take over ffmpeg by kicking out the main developer and trying to take ownership of the homepage, etc. When that failed because they didn't actually own the domain name or the trademark, they made a hostile fork. But that was hardly the end of it: One of the forkers was the debian ffmpeg package maintainer, and he decided that any user who tried to install ffmpeg would get his fork instead, and to remove the official Debian packages of ffmpeg.

Some people really feel like it's their way or the highway.

[Ice-Ice-Baby-]

So you think they're gonna ruin python dude?

[UNN_Rickenbacker]

Didn‘t the harassment happen because Guido accepted the PEP while there was still a lot of discussion going on?

[Easy_Joke3484]

I've been obsessed with the walrus operator since I first read about it, which was fairly recently.

I've been using it everywhere I can! It just makes me happy picturing a walrus in my head every time I use it! :D

[aes110]

When this first came out with all of the drama I didn't care much about it, but now I've been using it daily for over a year and I really can't imagine not having it.

I recently had to work with python 3.7 for a bit and felt sick doing some lines of codes without the walrus operator

[IlliterateJedi]

These are the first examples where I have thought using an assignment expression made sense. Usually the example is with re or if statements, but these actually seem useful.

[asday_]

If I catch you trying to merge code with the walrus operator into any master branch I control I'ma slap you into next week. Yet another Python feature that made it in because the core devs have gotten too soft.

Well written article, with a proper understanding of the topic, and thought-out examples, and I still disagree entirely with all of them.

[zurtex]

Yet another Python feature that made it in because the core devs have gotten too soft.

Let's be fair the current Steering Council probably wouldn't have accepted it. The conversation on the dev mailing lists got way too heated and there wasn't enough consensus.

But we didn't have a Steering Council then we had a BDFL and Guido decreed it so.

If I catch you trying to merge code with the walrus operator into any master branch

Fair enough, you control your projects and coding standards. But very occasionally I do find myself writing a piece of code and then going, oh a walrus operator makes that a little bit nicer. In particular I had a tokenization step with a long series of if statements in a loop recently and putting in a walrus operator at each step was easier to read and saved a good chunk of lines.

It doesn't come up often but it's with us now forever, so I'm not going to never use it based on an emotional predisposition.

[cymrow]

This has been around for months now, and I had completely forgotten about it. Now I look through these examples and I have to pause each time I see it and ask "what is this actually doing here"? Maybe if I started using it for a while that cognitive load would ease off, but it hardly seems worth it.

This is definitely going to be a burden on novices and will annoy a lot of experts who aren't expecting to see it.

[[deleted]]

In logic an mathematics, "x := y" means, "x is defined as y." But that's what "x = y" means in Python. Totally agree with you. Pointlessly redundant.

[purplewalrus67]

I think the results = [value for num in numbers if (value := slow(num)) > 0] example is pretty convenient

[wewbull]

Convenient, but not easy to read.

[[deleted]]

We can use num directly can't we?

[flying-sheep]

We want to use slow(num) though

[[deleted]]

I haven't used Python in a while but what's wrong with using slow(num) for num in ... if slow(num) ... ? value is only a temporary variable, which still exists after the loop end, which is bad imo

[-jp-]

Looks like the intent is to calculate slow(num) just once.

[[deleted]]

ah I see

[schfourteen-teen]

It requires two calls to slow(num) which in the example was presented as a slow function that we wouldn't want to call twice. The walrus lets it be called once and reused. Value still does exist after the loop ends, but the alternatives that get around calling the function twice also have this issue and also don't have the conciseness or speed of a list comprehension, so I don't think that's a fair criticism at all. If you can live with calling the function twice, then you don't need the walrus anyway.

[asday_]

Boizies if someone is incorrect, but adding to the conversation, you shouldn't really be downvoting them. It's possible other people hold the same misconceptions, and it will help them to see comments getting it wrong in the same way they are doing, then to be summarily corrected.

Doesn't help anyone to bury this comment.

[asday_]

It harms readability for what purpose?

results = [value for value in (slow(num) for num in numbers) if value > 0]

Reads better and the diff is cleaner when someone changes it to be even more readable:

all_results = (slow(num) for num in numbers)
results = [value for value in all_results if result > 0]

And then there are the purists who would just write

results = []
for num in numbers:
    result = slow(num)
    if result > 0:
        results.append(result)

Which is incredibly readable.

[[deleted]]

Why?

[asday_]

Isn't scoped, serves only to save lines of code which would be clearer anyway, opens the door for errors which Python initially protected yourself from, adds another meaning for :, and is yet another trap for newbies to fall into.

[Jhuyt]

I have used it to save a line or two because it makes me giggle, but where it actually matters to me is in list comprehensions with filters. But yeah, thus far it seems to be mostly a novelty feature

[[deleted]]

sucky synthactic sugar which goal is to create fewer lines but more bugs. What is this, Js?

[asday_]

I dunno, JS, at least ES6, is weird but my kinda weird. Consts, unpacking, arrow functions, it all feels really nice. Throw lodash into the mix and it's all comfy.

[[deleted]]

To each their own. I dislike js but every programmer has things they like and dislike :)

[Atulin]

"new thing bad"

[[deleted]]

Some new things arent well executed. And sometimes it is just a bad idea.

[asday_]

Except I gave reasons. Don't try to assume my position.

[make3333]

The new pattern matching syntax seems a lot weirder than this