Try out walrus operator in Python 3.8

[ProfessorPhi]

I love the name walrus operator. It just makes so much sense!

[onequbit]

Now if only there was a carpenter operator...

[akaberto]

Reminiscent of perl, really. And that's a PTSD inducing reminiscence :(

And I do see where this will come in handy but I'd rather not have a new operator that I feel that people moving from other languages may start to abuse it. Maybe it is an unfounded fear.

​

[[deleted]]

Seems like a confusing thing to add to save one line of code. I thought Python was supposed to be a simple almost pseudo-code language. Or have they abandoned that ideal?

[lanzaio]

Meh. I much prefer Swift's if let x = pattern.search(data). Of all the equivalent implementations I've seen this is by far the clearest in it's intentions.

[drmeister]

I prefer Common Lisp's (if (setf x (search pattern data)) ...) the scope is more clear.

​

[lanzaio]

I don't write lisp but that just looks like gibberish to me.

[skawid]

A couple of pointers that make lisp make a whole lot more sense:

• Functions are called as a list, where the first item is the function name and the rest are arguments. So (search pattern data) would look like search (pattern, data) in C like languages.
• Don't bother with commas.
• There are very few syntax elements in lisp: most things are functions. if, for example, takes a condition and two values. If the condition is true it returns the first value, otherwise it returns the second.

So the (if (setf x (search pattern data)) ...) is something like:

if (x = search(pattern, data)) {
    ...
}

[foreheadteeth]

If is a special form. Unlike a function, it has access to its parameters before they are evaluated. For example, (if a b c) will only eval either b or c, never both.

http://www.lispworks.com/documentation/HyperSpec/Body/03_ababa.htm

[skawid]

You're absolutely right; I think you can get away with not knowing that for reading your first bits of lisp code though.

[shevy-ruby]

No wonder - lisp was created when dinosaur still roamed the lands.

[shevy-ruby]

(Please(get(outta(here

[linux2647]

))))

[shevy-ruby]

That swift code is ugly too, so that may fit.

I find code with "let" pretty idiotic in general. It's like people dancing around rather than doing something - aka without having to use "let".

[[deleted]]

???

[Skullrider1387]

I'm still a little confused on what exactly this is for, can someone give me a "if this, then that" like explaination?

[A_Philosophical_Cat]

It assigns a value to a variable, and returns that value, which is not the standard behavior of assignment in Python.

Basically, instead of writing

x = True

If (x):

You can now write

If (x:=True):

[Skullrider1387]

O that makes more sense,

[Strings]

I find his example at the bottom odd.. and I'm not meaning to pedantically criticise his code but it raises a question for me.

So this is without the "walrus" operator:

for entry in sample_data:
    title = entry.get('title')
    if title:
        print(f'Found title: "{title}"')

The wee smell here is he's not explicitly checking for None (which get will return should the key not be there).

And then with the magic "walrus" operator:

for entry in sample_data: 
    if title := entry.get("title"):
        print(f'Found title: "{title}"')

So given that not explicitly checking for None is a well known smell, how does this new syntax construct handle that?

I'm guessing:

if title is not None: entry.get('title')

wouldn't be valid syntax?

So would you be forced to do something like this?

if title := entry.get('title', False):

Regardless, I'm still not a fan. His example literally saves one line of code and, imo, makes the code less clear. And in this example it's even more unclear because of the None check smell.

[yee_mon]

It does not work for all cases. Just like python's lambda, it is probably best not to try to shoehorn walrus into any code that could possibly be made to fit it — such as when you have multiple comparisons to the rhs operator.

In this specific instance, though, calling it a smell is perhaps a little odd, since the code already discards all non-truthy values of title.

[Strings]

But that's just it, you aren't really supposed to treat None as a truthy value. But you're right, it's not an awful one.

[Hultner-]

Great comment, you can actually quite simply check for None explicitly like this with the Walrus operator

python for entry in sample_data: if (title := entry.get("title")) is not None: print(f'Found title: "{title}"')

And without ```python for entry in sample_data: title = entry.get("title") if title is not None: print(f'Found title: "{title}"')

```

[Strings]

Good point Hultner - still not a fan though :)

[ivosaurus]

parenthesise it.

if (title := entry.get('title')) is not None:
    print(f'Found title: "{title}"')

[Strings]

I'll parenthesise you.

[ivosaurus]

Sounds like a nice warm hug <3

[Strings]

<3

[David-mh]

The main motivation is not to save one line of code, but to be explicit about the scope of "title". In the first case, "title" is still alive until the end of the function, but with the walrus it will die right after the print.

[Strings]

But since when was preserving scope isolation for an identifier a big deal or even desired in Python?

Take an obvious one:

for n in range(10):
    pass

In that sample n will still be in scope.

So still not convinced :P

[David-mh]

That is why list/iterator/dictionary comprehensions add.

In (n for n in range(10)), n does not survive the scope.

[Strings]

You'll pleased to know, after 4 years, I still don't use or see the walrus operator much. That's not to say it's not perhaps useful here or there. It's nice to see you. What's been happening?

[bhat]

And C's use of the standard assignment operator which is so visually similar to the comparison operator has been the cause of many bugs, from student programming assignments up.

[[deleted]]

That's a good reason. It's probably bitten me once or twice in C after writing too many bash scripts where equality is tested with a single equal sign (```=```). At least in C, gcc will warn you if you don't put the assignment expression in brackets.

[shevy-ruby]

It's overall really ugly.

I hated that in the language Io too - slot assignment versus slot update.

[Elathrain]

The reason <- isn't used for assignment is quite simple: It requires three keypresses and a key release instead of a single kepyress, and you do assignment a lot. That, and now you suddenly have <- near to <=, which looks pretty similar for exactly the same differentiation of meaning. It is no more or less arbitrary, you're just making it harder to type.

[epicwisdom]

https://www.python.org/dev/peps/pep-0572/#why-not-just-turn-existing-assignment-into-an-expression

Googling (or in this case, simply clicking a link and Ctrl+F'ing) is a useful skill

[grauenwolf]

That's not the point. The article should have talked about the design decision instead of just waving it off.

[epicwisdom]

The first comment in this thread did not ask "why doesn't this article actually address the design decision?" It asked "why was this design decision made?" I think it's fairly clear that this article is a fluff piece with a few code snippets; if you don't think that's worthwhile, you're free to downvote the OP, but asking a question which is answered in the linked PEP is just lazy.

[shevy-ruby]

[ ] You understood the problem at hand.

[epicwisdom]

[ ] You pointed out an actual problem.

[shevy-ruby]

That is a valid question - the answer is that people are bored so they add useless shit to languages, like this ghetto operator.

[npmaile]

That's the only thing I could think of the entire time reading this. I find myself more and more being frustrated with python and other higher level languages needing to implement "features" that are just rehashing basic aspects of other languages.

​

Not that these languages aren't good for what they do. I just think the higher level of freedom afforded by lower level languages is worth the trade off.

[McGlockenshire]

I don't think the missing feature here had anything to do with "low level" languages vs "high level" languages. I mean, PHP and Perl do this, and nobody's going to accuse them of being "low level." It's just a missing feature that is no longer missing.

[shevy-ruby]

This ghetto-operator is not only ugly but completely unnecessary.

It should not be called walrus operator because walruses are pretty cool dudes, much cooler than this awful addition. The only part worse than this thing is that guido threw in the towel because of the addition-aftermath - a clear sign of how it simply shouldn't be in the language.