[thaumasiotes]

Read it "if y" - that's what's being tested.

The walrus simultaneously names the value being tested so you can refer to it within the condition; it's sort of the inverse of Perl code using $_. So instead of

    if (do_something()) {
        act_on($_);
    }

you have

    if placeholder := do_something():
        act_on(placeholder)

But when reading aloud, however you'd read the perl will flow as more natural english. "If the string contains z, do something with it".

If you really want to read the Python as it's written, it corresponds to the second of these sentences:

- If the substring from 3 to 5 is "fg", crash.

- If variable_name, the substring from 3 to 5, is "fg", crash.

[txcwpalpha]

>Read it "if y" - that's what's being tested.

Once way to test if this works is to take the code, read it aloud, and then use the read-aloud version to rewrite the code. If you don't have a high degree of certainty that you end up with the same code, something has failed along the way.

In this case, if I take "if x:= y()" and read it aloud as "if y", I think the vast majority of people would translate that to code as "if y():", which isn't the same thing.

[thaumasiotes]

You will end up with the same code under two conditions:

1. You read more than one line of code.

2. Executing the code in the conditional more than once doesn't matter.

If you meet those two assumptions, then the reading I suggested will transform this

    if x := y():
        act_on(x)

into this

    if y():
        act_on(y())

which is, in fact, the same thing.

[txcwpalpha]

That second point is quite an assumption to make. If it's okay to end up with the second one of your examples (without the ":=" operator), why did we need to add the walrus opeprator at all?

And if you're referring to this statement from your original comment:

> If variable_name, the substring from 3 to 5, is "fg", crash.

I don't find this to be a clear statement at all. If I read this aloud to any of my programming students, I doubt any of them would be able to decipher it into any code, let alone the code string which you've suggested.

[thaumasiotes]

> If it's okay to end up with the second one of your examples (without the ":=" operator), why did we need to add the walrus operator at all?

A couple of reasons:

- The walrus eliminates a line of code in the very common scenario where you would prefer not to recalculate (or retype) y().

- The walrus makes it easy to avoid recalculating y() in the less common scenario where you need to avoid doing that.

> I don't find this to be a clear statement at all.

Nonetheless, it is the normal English syntax used to name something and then immediately define the meaning of that name. If you want to map the Python structure to an equivalent English structure, that is the equivalent English structure. ("Thomas Jefferson, the third president, was a man about whom much can be said.") If you want to map the Python code to an English statement of what the code does, use the reading I first suggested, "if y(), do something with it". If you want to dictate Python code to an English speaker, use the reading "if x colon-equals y()".

So let me ask you: is the problem you'd like to solve "I want to understand what this code does", is it "I like thinking about English grammar", or is it "I'm too busy to type my own code; that's what my secretary is for"?

[txcwpalpha]

>So let me ask you: is the problem you'd like to solve "I want to understand what this code does", is it "I like thinking about English grammar", or is it "I'm too busy to type my own code; that's what my secretary is for"?

The problem that has already been solved by every version <3.8 of Python, and that I would hate to see become un-solved by Python in the future, is that Python's greatest attribute, by far, is that it has always stuck to a code of being "pythonic", increasing accessibility, readability, and teachability to wide audiences. A hugely significant reason for Python's incredible rise in popularity and its use today is specifically because of it's readability. As much as it gets meme'd about, the fact that Python pseudocode is so close to real Python code is an enormous boon for the language.

I teach programming at a university level, and Python is the go-to, default language to teach programming. Dictating code so that it can be discussed in a classroom setting is very important, and as I mentioned before, your suggestion for reading it aloud just wouldn't cut it. Python is also the go-to, default language for programming-adjacent fields like data science, a lot of statistics, and every other non-programming-but-still-IT field. And again, this is because the people in these fields love the fact that, even with zero previous programming experience, they can look at or hear a piece of code and almost immediately understand what it is doing.

Python's strict adherence to being "pythonic" is hugely responsible for an entire generation of programmers, and hopefully will continue to be pythonic enough to continue lowering the barriers of entry to future programmers. I get that many seasoned developers are adopting an "well I got mine" attitude and don't care if future developers have a harder time learning the trade, but I personally find that to be very selfish, and I would hate to see future generations of programmers suffer just because the current generation apparently can't be arsed to do something like write one single, short extra line of code every now and then.

[thaumasiotes]

> I would hate to see future generations of programmers suffer just because the current generation apparently can't be arsed to do something like write one single, short extra line of code every now and then.

Every now and then? If you look at the example in the post, you'll see it saving one line of code per branch of the if-elif ladder.

Python code is characteristically tall, and this saves a lot of lines, and it saves them all in exactly the same way.

[shakna]

There's absolutely no guarantee that two calls to y result in the same value.

Even if y isn't mutating itself, it may be calling from a database updated from another thread.

You end up storing the value. The walrus simplifies the code.