单行python语句中“==”和“in”的奇怪行为

从反汇编代码中，我可以看到

foo1（）

应该返回

False

，因为它不会执行比较中的

，因此
False

但是foo2（）发生了什么，为什么返回False

而foo3（）和foo4（）工作得非常完美，我们可以从反汇编代码中确认这一点

参考：

蟒蛇2.7

我见过类似的行为python3+；反汇编代码不同，但反汇编代码中的逻辑似乎相同

Python运算符优先级：

中的

==

和

的运算符优先级相同，但不符合预期。
中的
和
==
都是关系运算符，也是Python链中的关系运算符<[1，2，3]==True
中的code>3同时执行[1，2，3]

中的

3和
[1，2，3]==True

但无论如何，你不应该和布尔人比较。如果需要，将结果传递给
bool（）
，但是
中的
已经生成布尔值。
中的
和
==
都是关系运算符，也是Python链中的关系运算符<[1，2，3]==True
中的code>3同时执行[1，2，3]
中的
3和
[1，2，3]==True

但无论如何，你不应该和布尔人比较。如果需要，将结果传递到
bool（）
，但是
中的
已经生成了布尔值。
哦！太傻了，错过了：（以防万一）这里是指向文档的链接：哦！太傻了，错过了：（以防万一）这里是指向文档的链接：
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