python比较运算符返回结果是,Python的在（__contains__）运算符返回一个布尔值，其值非真非假...

As expected, 1 is not contained by the empty tuple

>>> 1 in ()

False

but the False value returned is not equal to False

>>> 1 in () == False

False

Looking at it another way, the in operator returns a bool which is neither True nor False:

>>> type(1 in ())

>>> 1 in () == True, 1 in () == False

(False, False)

However, normal behaviour resumes if the original expression is parenthesized

>>> (1 in ()) == False

True

or its value is stored in a variable

>>> value = 1 in ()

>>> value == False

True

This behaviour is observed in both Python 2 and Python 3.

Can you explain what is going on?

解决方案

You are running into comparison operator chaining; 1 in () == False does not mean (1 in ()) == False.

Rather, comparisons are chained and the expression really means:

(1 in ()) and (() == False)

Because (1 in ()) is already false, the second half of the chained expression is ignored altogether (since False and something_else returns False whatever the value of something_else would be).

Comparisons can be chained arbitrarily, e.g., x < y <= z is equivalent to x < y and y <= z, except that y is evaluated only once (but in both cases z is not evaluated at all when x < y is found to be false).

For the record, , ==, >=, <=, !=, is, is not, in and not in are all comparison operators (as is the deprecated <>).

In general, don't compare against booleans; just test the expression itself. If you have to test against a boolean literal, at least use parenthesis and the is operator, True and False are singletons, just like None:

>>> (1 in ()) is False

True

This gets more confusing still when integers are involved. The Python bool type is a subclass of int1. As such, False == 0 is true, as is True == 1. You therefor can conceivably create chained operations that almost look sane:

3 > 1 == True

is true because 3 > 1 and 1 == True are both true. But the expression:

3 > 2 == True

is false, because 2 == True is false.

1bool is a subclass of int for historic reasons; Python didn't always have a bool type and overloaded integers with boolean meaning just like C does. Making bool a subclass kept older code working.