Thread by @svpino

If you look at this code and think the answer is False, you aren't alone.

Nevertheless, we are all wrong: it returns True.

Read on to see what's happening.

↓

The clue here is the two consecutive operators next to each other.

Operator 1: ==
Operator 2: in

And we have "False" sandwiched in the middle.

The logical reaction is to parse the statement piece by piece. That's what I did.

But that's not how it works.

When it comes to answering this question, there are two camps:

1. Those who claim that "==" takes precedence.

2. Those who claim that "in" takes precedence.

Let's see what we get on both of these cases.

Assuming that "==" takes precedence:

• False == False is True
• True in [False] is False

People on this camp claimed the answer was False.

Assuming that "in" takes precedence:

• False in [False] is True
• False == True is False

People on this camp also claimed the answer was False.

The problem is that this has nothing to do with operator precedence.

Instead, this statement translates to the following:

This is called "Chained Operators" in Python.

A similar (and probably more intuitive example) is attached.

It translates to 10 < x and x < 20.

After understanding how you "unroll" chained operators, it becomes evident that the answer is True.

There's a lesson here.

Regardless of how cool you think chained operators are, I find them confusing.

Judging by the attached post, most people feel the same.

This is a good indication that you should stay away from them as much as possible.

https://twitter.com/svpino/status/1490385489601257472?s=20&t=9CRGOlv4CSjwCJxvQehfRg

I'm usually in favor of mastering your language and using as much of it as you possibly can.

That being said, there's a difference between using something that people don't understand and something that people misunderstand.

The latter is very problematic.

So, although a fun exercise, I prefer to stay away from chained operators.

What do you think?