Python 解释字符串布尔测试结果

我有以下代码：

>>> char = 'A'
>>> 'A' == char
True
>>> ('A' or 'B') == char
True

为什么这不等于

True

>>> ('B' or 'A') == char
False

---

不同之处在于这些表达式的计算方式：

In [1]: 'A' or 'B'
Out[1]: 'A'

In [3]: 'B' or 'A'
Out[3]: 'B'

…因此，在您的情况下，“B”或“A”不应等于

char

有关

或
应如何工作的详细信息，请参阅：

表达式x或y首先计算x；如果x为true，则返回其值；否则，计算y并返回结果值

上面描述的排序非常关键，包括一个名为“.”的概念。您的表达式没有达到预期的效果

'A' or 'B'

这实际上计算为
'A'
，请在解释器中试用

当你说

('A' or 'B') == char

解释器实际上正在执行以下步骤：

('A' or 'B') == char
('A') == char
True

但当你这么做的时候

('B' or 'A') == char

口译员执行以下操作：

('B' or 'A') == char
('B') == char
False

你可能想要的是：

'A' == char or 'B' == char
True

您正在进行的比较实际上比较了
'A'
和
'B'
的布尔值

所以：
（'A'或'B'）
实际上是
（bool（'A'）或bool（'B'）
，因为它是
或
条件，而
bool（'A'）
在第一种情况下是
真的
，所以它比较
'A'==char
，在第二种情况下是
bool（'B'）
，所以它比较
'B'==char
（这是
假的
）

这就是它在后台发生的方式：\

In [104]: def func():
    char="A"
    return ('A' or 'B')==char
   .....: 

In [107]: def func1():
    char="A"
    return ("B" or "A")==char
   .....: 

In [110]: dis.dis(func)
  2           0 LOAD_CONST               1 ('A')  
              3 STORE_FAST               0 (char)

  3           6 LOAD_CONST               1 ('A')   #loads 'A'
              9 JUMP_IF_TRUE             4 (to 16)  # if 'A' is True then go to 16
                                                    # As 'A' is not a falsy value so it                                                                                                         
                                                     goes to  16
             12 POP_TOP                  
             13 LOAD_CONST               2 ('B')
        >>   16 LOAD_FAST                0 (char)  #load char , i.e 'A'
             19 COMPARE_OP               2 (==)    #compare 'A'=='A' , i,e True
             22 RETURN_VALUE        

In [111]: dis.dis(func1)
  2           0 LOAD_CONST               1 ('A')
              3 STORE_FAST               0 (char)

  3           6 LOAD_CONST               2 ('B')      #load 'B', it's a true value
                                                      # so go to 16
              9 JUMP_IF_TRUE             4 (to 16)
             12 POP_TOP             
             13 LOAD_CONST               1 ('A')
        >>   16 LOAD_FAST                0 (char)     #load chr ,i.e 'A'
             19 COMPARE_OP               2 (==)       #'B'=='A' , False
             22 RETURN_VALUE        

谢谢，但我觉得这很反直觉。为什么在这种情况下（'A'或'B'）==char选项是允许的？因为这是一个合法的比较。我想你会发现，python在不让你做不应该做的事情方面是一样好或更好的。
In [104]: def func():
    char="A"
    return ('A' or 'B')==char
   .....: 

In [107]: def func1():
    char="A"
    return ("B" or "A")==char
   .....: 

In [110]: dis.dis(func)
  2           0 LOAD_CONST               1 ('A')  
              3 STORE_FAST               0 (char)

  3           6 LOAD_CONST               1 ('A')   #loads 'A'
              9 JUMP_IF_TRUE             4 (to 16)  # if 'A' is True then go to 16
                                                    # As 'A' is not a falsy value so it                                                                                                         
                                                     goes to  16
             12 POP_TOP                  
             13 LOAD_CONST               2 ('B')
        >>   16 LOAD_FAST                0 (char)  #load char , i.e 'A'
             19 COMPARE_OP               2 (==)    #compare 'A'=='A' , i,e True
             22 RETURN_VALUE        

In [111]: dis.dis(func1)
  2           0 LOAD_CONST               1 ('A')
              3 STORE_FAST               0 (char)

  3           6 LOAD_CONST               2 ('B')      #load 'B', it's a true value
                                                      # so go to 16
              9 JUMP_IF_TRUE             4 (to 16)
             12 POP_TOP             
             13 LOAD_CONST               1 ('A')
        >>   16 LOAD_FAST                0 (char)     #load chr ,i.e 'A'
             19 COMPARE_OP               2 (==)       #'B'=='A' , False
             22 RETURN_VALUE