为什么 Python 中的表达式 0 < 0 == 0 返回 False？（如何解释链式比较？）
- 2024-12-03 08:44:00
- admin 原创
- 179
问题描述：
Queue.py我在Python 2.6标准库中的这段代码中发现了一个奇怪的结构：
def full(self):
"""Return True if the queue is full, False otherwise
(not reliable!)."""
self.mutex.acquire()
n = 0 < self.maxsize == self._qsize()
self.mutex.release()
return n
显然，如果maxsize为 0，队列就永远不会满。但这是如何工作的呢？为什么0 < 0 == 0求值为 False？无论先应用哪个操作，结果似乎都应该是 True，而且我确实在添加括号时得到了这个结果：
>>> 0 < 0 == 0
False
>>> (0 < 0) == 0
True
>>> 0 < (0 == 0)
True
另请参阅“x < y < z”是否比“x < y and y < z”更快？以了解有关如何实现该功能的详细信息。
解决方案 1：
Python 对关系运算符序列有特殊情况处理，使范围比较更容易表达。能够说0 < x <= 5比说要好得多(0 < x) and (x <= 5)。
这些被称为链式比较。
对于您谈到的其他情况，括号会强制先应用一个关系运算符，然后再应用另一个关系运算符，因此它们不再是链式比较。由于True和False的值都是整数，因此您可以从带括号的版本中获得答案。
解决方案 2：
因为
(0 < 0) and (0 == 0)
是False。您可以将比较运算符链接在一起，它们会自动扩展到成对比较中。
编辑——关于 Python 中 True 和 False 的说明
在 Python 中True，和False只是 的实例bool，而 是 的子类int。换句话说，True实际上只是 1。
这样做的目的是，你可以像使用整数一样使用布尔比较的结果。这会导致一些令人困惑的事情，例如
>>> (1==1)+(1==1)
2
>>> (2<1)<1
True
但只有当你用括号括住比较运算符以便首先对其进行求值时，才会发生这种情况。否则 Python 将扩展比较运算符。
解决方案 3：
您遇到的奇怪行为来自 Python 链接条件的能力。由于它发现 0 不小于 0，因此它决定整个表达式的计算结果为 false。一旦将其分解为单独的条件，就会改变功能。它最初本质上是测试a < b && b == c您原始的 语句a < b == c。
另一个例子：
>>> 1 < 5 < 3
False
>>> (1 < 5) < 3
True
解决方案 4：
>>> 0 < 0 == 0
False
这是一个链式比较。如果每个成对比较依次为真，则返回真。它相当于(0 < 0) and (0 == 0)
>>> (0) < (0 == 0)
True
这相当于0 < True计算结果为 True。
>>> (0 < 0) == 0
True
这相当于False == 0计算结果为 True。
>>> 0 < (0 == 0)
True
0 < True与上述等同，计算结果为 True。
解决方案 5：
通过查看反汇编（字节代码），很明显为什么0 < 0 == 0是False。
以下是对这个表达式的分析：
>>>import dis
>>>def f():
... 0 < 0 == 0
>>>dis.dis(f)
2 0 LOAD_CONST 1 (0)
3 LOAD_CONST 1 (0)
6 DUP_TOP
7 ROT_THREE
8 COMPARE_OP 0 (<)
11 JUMP_IF_FALSE_OR_POP 23
14 LOAD_CONST 1 (0)
17 COMPARE_OP 2 (==)
20 JUMP_FORWARD 2 (to 25)
>> 23 ROT_TWO
24 POP_TOP
>> 25 POP_TOP
26 LOAD_CONST 0 (None)
29 RETURN_VALUE
注意第 0-8 行：这些行检查是否0 < 0显然返回False到 python 堆栈。
现在注意第 11 行：JUMP_IF_FALSE_OR_POP 23
这意味着如果0 < 0返回False则跳转到第 23 行。
现在，0 < 0是False，因此进行跳转，这会使堆栈留下一个False，它是整个表达式的返回值0 < 0 == 0，即使该== 0部分甚至没有被检查。
因此，总而言之，答案就像这个问题的其他答案中所说的那样。0 < 0 == 0具有特殊含义。编译器将其评估为两个项：0 < 0和0 == 0。与and它们之间的任何复杂布尔表达式一样，如果第一个失败，则第二个甚至不会被检查。
希望这能对大家有所启发，我也真心希望我用来分析这种意外行为的方法能够鼓励其他人在未来尝试同样的做法。
解决方案 6：
正如其他人提到的那样，x comparison_operator y comparison_operator z这是一种语法糖(x comparison_operator y) and (y comparison_operator z)，其好处是 y 只需要评估一次。
因此，您的表达式0 < 0 == 0实际上是(0 < 0) and (0 == 0)，其计算结果False and True恰好是False。
解决方案 7：
也许文档中的这段摘录可以提供帮助：
这些是所谓的“丰富比较”方法，在以下情况下优先调用比较运算符
__cmp__()。运算符号与方法名的对应关系如下：x<ycalls
x.__lt__(y)、x<=ycallsx.__le__(y)、
x==ycallsx.__eq__(y)、x!=ycalls 、calls
、calls
。x<>y`x.__ne__(y)x>yx.__gt__(y)x>=yx.__ge__(y)`如果富比较方法
NotImplemented未针对给定的一对参数实现操作，则可能会返回单例。按照惯例，False比较True成功时会返回和。但是，这些方法可以返回任何值，因此如果在布尔上下文中使用比较运算符（例如，在 if 语句的条件中），Python 将调用bool()该值来确定结果是真还是假。比较运算符之间没有隐含关系。 的真值
x==y并不意味着 的x!=y
假值。因此，在定义 时
__eq__()，还应定义__ne__()以使运算符的行为符合预期。请参阅 段落，了解__hash__()有关创建支持自定义比较操作并可用作字典键的可哈希对象的一些重要说明。这些方法没有交换参数的版本（当左参数不支持操作但右参数支持时使用）；相反，
__lt__()和__gt__()
是彼此的反射，__le__()
和__ge__()是彼此的反射，和__eq__()是__ne__()
它们自己的反射。丰富的比较方法的论点永远不会被强迫。
这些都是比较，但由于您正在进行链接比较，因此您应该知道：
比较可以任意链接，例如，
x < y <= z相当于x < y and y <= z，除了 y 仅被评估一次（但在这两种情况下，当发现 x < y 为假时，z 根本不被评估）。形式上，如果 a、b、c、...、y、z 是表达式，而 op1、op2、...、opN 是比较运算符，则 a op1 b op2 c ... y opN z 等同于 a op1 b and b op2 c and ... y opN z，不同之处在于每个表达式最多被求值一次。
解决方案 8：
这就是它的全部辉煌。
>>> class showme(object):
... def __init__(self, name, value):
... self.name, self.value = name, value
... def __repr__(self):
... return "<showme %s:%s>" % (self.name, self.value)
... def __cmp__(self, other):
... print "cmp(%r, %r)" % (self, other)
... if type(other) == showme:
... return cmp(self.value, other.value)
... else:
... return cmp(self.value, other)
...
>>> showme(1,0) < showme(2,0) == showme(3,0)
cmp(<showme 1:0>, <showme 2:0>)
False
>>> (showme(1,0) < showme(2,0)) == showme(3,0)
cmp(<showme 1:0>, <showme 2:0>)
cmp(<showme 3:0>, False)
True
>>> showme(1,0) < (showme(2,0) == showme(3,0))
cmp(<showme 2:0>, <showme 3:0>)
cmp(<showme 1:0>, True)
True
>>>
解决方案 9：
我认为 Python 在魔法之间做了一些奇怪的事情。与1 < 2 < 32 介于 1 和 3 之间相同。
在这种情况下，我认为它正在执行 [中间 0] 大于 [左 0] 且等于 [右 0]。中间 0 不大于左 0，因此其计算结果为 false。
