Why is `(2 == 2) == True` equal `True` but `2 == 2 == True` is equal `False`?

Question

My problem are these two statements:

> 2 == 2 == True
False
> (2 == 2) == True
True

I am confused. I expected both expressions to be the same since Python would evaluate the expression from left to right, so:

# 2 == 2 == True
# |    |
# ------
#   |
#  True  == True

and

# (2 == 2) == True
#  |    |
#  ------
#    |
#   True   == True

Even if I change the order (if Python evaluated from right to left), I get the same confusing result:

> True == 2 == 2
False
> True == (2 == 2)
True

Can somebody help me here?

Because `2 == 2 == True` is _chained_ to `2 == 2 and 2 == True`. — jonrsharpe, Jul 18 '22 at 13:18
The integer value of `True` is 1, which is why you're getting `False`. — MattDMo, Jul 18 '22 at 13:18
Do not assume == will have the same order of execution as simple mathematical operator +, -, * or /. In this case your second == asks if 2 == True, which results in false. — user5214530, Jul 18 '22 at 13:18
[The documentation](https://docs.python.org/3/reference/expressions.html#comparisons) might help. — Some programmer dude, Jul 18 '22 at 13:22
Oh, that makes sense. I didn't know about this special behaviour in Python. I didn't find the other post during my research. — mrzo, Jul 18 '22 at 13:24

chepner · Accepted Answer · 2022-07-18T13:30:15.937

Comparison chaining. 2 == 2 == True is evaluated as 2 == 2 and 2 == True, and the second comparison is clearly false. (2 may be truthy, but it is not True.)

You can use the ast module to see the different abstract syntax trees (ASTs) produced from each expression.

>>> print(ast.dump(ast.parse("2 == 2 == True").body[0], indent=2))
Expr(
  value=Compare(
    left=Constant(value=2),
    ops=[
      Eq(),
      Eq()],
    comparators=[
      Constant(value=2),
      Constant(value=True)]))

>>> print(ast.dump(ast.parse("(2 == 2) == True").body[0], indent=2))
Expr(
  value=Compare(
    left=Compare(
      left=Constant(value=2),
      ops=[
        Eq()],
      comparators=[
        Constant(value=2)]),
    ops=[
      Eq()],
    comparators=[
      Constant(value=True)]))

Looking at the AST alone doesn't make it obvious that A op1 B op2 C is equivalent to A op1 B and B op2 C (You can see that there is a single Compare expression with two operators and two "comparators", rather than a Compare expression with a single operator and another Compare expression as one operand.) For that, you need the documentation:

Formally, if a, b, c, …, y, z are expressions and op1, op2, …, opN are comparison operators, then a op1 b op2 c ... y opN z is equivalent to a op1 b and b op2 c and ... y opN z, except that each expression is evaluated at most once.

The AST provides the information, the code generator provides the semantics of that information.

>>> import dis
>>> dis.dis('2==2==True')
  1           0 LOAD_CONST               0 (2)
              2 LOAD_CONST               0 (2)
              4 DUP_TOP
              6 ROT_THREE
              8 COMPARE_OP               2 (==)
             10 JUMP_IF_FALSE_OR_POP    18
             12 LOAD_CONST               1 (True)
             14 COMPARE_OP               2 (==)
             16 RETURN_VALUE
        >>   18 ROT_TWO
             20 POP_TOP
             22 RETURN_VALUE
>>> dis.dis('(2==2)==True')
  1           0 LOAD_CONST               0 (2)
              2 LOAD_CONST               0 (2)
              4 COMPARE_OP               2 (==)
              6 LOAD_CONST               1 (True)
              8 COMPARE_OP               2 (==)
             10 RETURN_VALUE

Why is `(2 == 2) == True` equal `True` but `2 == 2 == True` is equal `False`?

1 Answers1