Python的奇怪行为'；是'；运算符（如果与'组合）；在'；

Python如何解释“abc”中的“a”是真的？我试图计算以下两个表达式：

>>> 'a' in 'abc' is True:
False
>>> ('a' in 'abc') is True:
True

（我知道“is”关键字通常不应该用来与

True

，这只是一个例子）

有趣的问题

下面是abc中a的字节码是真的

>>> import dis
>>> dis.disassemble((lambda: 'a' in 'abc' is True).func_code)
2           0 LOAD_CONST               1 ('a')   # stack: 'a'
            3 LOAD_CONST               2 ('abc') # stack: 'a' 'abc'
            6 DUP_TOP                            # stack: 'a' 'abc' 'abc'
            7 ROT_THREE                          # stack: 'abc' 'a' 'abc'
            8 COMPARE_OP               6 (in)    # stack: 'abc' True
           11 JUMP_IF_FALSE_OR_POP    21         # stack: 'abc'
           14 LOAD_GLOBAL              0 (True)  # stack: 'abc' True
           17 COMPARE_OP               8 (is)    # stack: False
           20 RETURN_VALUE        
      >>   21 ROT_TWO
           22 POP_TOP
           23 RETURN_VALUE                      

>>> import dis
>>> dis.disassemble((lambda: ('a' in 'abc') is True).func_code)
1           0 LOAD_CONST               1 ('a')   # stack: 'a'
            3 LOAD_CONST               2 ('abc') # stack: 'a' 'abc'
            6 COMPARE_OP               6 (in)    # stack: True
            9 LOAD_GLOBAL              0 (True)
           12 COMPARE_OP               8 (is)
           15 RETURN_VALUE        

与

（'abc'中的'a'）中的值相比，它是真的

：

>>> import dis
>>> dis.disassemble((lambda: 'a' in 'abc' is True).func_code)
2           0 LOAD_CONST               1 ('a')   # stack: 'a'
            3 LOAD_CONST               2 ('abc') # stack: 'a' 'abc'
            6 DUP_TOP                            # stack: 'a' 'abc' 'abc'
            7 ROT_THREE                          # stack: 'abc' 'a' 'abc'
            8 COMPARE_OP               6 (in)    # stack: 'abc' True
           11 JUMP_IF_FALSE_OR_POP    21         # stack: 'abc'
           14 LOAD_GLOBAL              0 (True)  # stack: 'abc' True
           17 COMPARE_OP               8 (is)    # stack: False
           20 RETURN_VALUE        
      >>   21 ROT_TWO
           22 POP_TOP
           23 RETURN_VALUE                      

>>> import dis
>>> dis.disassemble((lambda: ('a' in 'abc') is True).func_code)
1           0 LOAD_CONST               1 ('a')   # stack: 'a'
            3 LOAD_CONST               2 ('abc') # stack: 'a' 'abc'
            6 COMPARE_OP               6 (in)    # stack: True
            9 LOAD_GLOBAL              0 (True)
           12 COMPARE_OP               8 (is)
           15 RETURN_VALUE        

因此，“abc”中的表达式

'a'似乎是正确的

的计算结果大致如下：

>>> 'a' in 'abc' and 'abc' is True

这似乎是操作符链接的结果：-同样的魔力使

1<5<10

正常工作

非常有趣

---

（注意：这是使用CPython 2.7.2完成的）

您正在链接操作符。抱歉，请参阅编辑以获取解释。请参阅Martjin附加的链接：）太好了。很好，我无法从汇编语言输出中推断出这一点。谢谢你没有完全理解<“abc”中的“a”是真的到“a”中的“abc”和“abc”是真的，使用

和
，而不是
或
。只有当这两个比较都是真的时，整个表达才是真的！这就是我太快给出答案的原因。谢谢