Странное поведение `==` и `in` в однострочном выражении Python

def foo1():
   return True == 3 in [1,2,3]

def foo2():
    return 3 in [1,2,3] == True

def foo3():
     return True == ( 3 in [1,2,3] )

def foo4():
   return ( 3 in [1,2,3] ) == True 

foo1() => False
foo2() => False
foo3() => True
foo4() => True

import dis

dis.dis(foo1)

  2           0 LOAD_CONST               1 (True)
              2 LOAD_CONST               2 (3)
              4 DUP_TOP
              6 ROT_THREE
              8 COMPARE_OP               2 (==)
             10 JUMP_IF_FALSE_OR_POP    18
             12 LOAD_CONST               5 ((1, 2, 3))
             14 COMPARE_OP               6 (in)
             16 RETURN_VALUE
        >>   18 ROT_TWO
             20 POP_TOP
             22 RETURN_VALUE

dis.dis( foo2 )
  2           0 LOAD_CONST               1 (3)
              2 LOAD_CONST               2 (1)
              4 LOAD_CONST               3 (2)
              6 LOAD_CONST               1 (3)
              8 BUILD_LIST               3
             10 DUP_TOP
             12 ROT_THREE
             14 COMPARE_OP               6 (in)
             16 JUMP_IF_FALSE_OR_POP    24
             18 LOAD_CONST               4 (True)
             20 COMPARE_OP               2 (==)
             22 RETURN_VALUE
        >>   24 ROT_TWO
             26 POP_TOP
             28 RETURN_VALUE

>>> dis.dis( foo3 )
  2           0 LOAD_CONST               1 (True)
              2 LOAD_CONST               2 (3)
              4 LOAD_CONST               5 ((1, 2, 3))
              6 COMPARE_OP               6 (in)
              8 COMPARE_OP               2 (==)
             10 RETURN_VALUE

>>> dis.dis( foo4 )
  2           0 LOAD_CONST               1 (3)
              2 LOAD_CONST               5 ((1, 2, 3))
              4 COMPARE_OP               6 (in)
              6 LOAD_CONST               4 (True)
              8 COMPARE_OP               2 (==)
             10 RETURN_VALUE

Из кода дизассемблирования я вижу, что foo1() должен возвращать False, поскольку он не выполняет сравнение in и, следовательно, False.

Но что происходит с foo2 (), почему он возвращает False?

В то время как foo3 () и foo4 () работают отлично, как мы можем убедиться из дизассемблированного кода.

Ссылка: https://docs.python.org/2/library/dis.html

Python2.7

Я видел подобное поведение python3 +; дизассемблированный код отличается, но логика в дизассемблированном коде кажется такой же.

Приоритет оператора Python: https://docs.python.org/2/reference/expressions.html#operator-precedence

Приоритет операторов для == и in одинаков, но не соответствует ожиданиям.