你能用 Python 中的不等于或等于来简化链式比较吗？

Question

可能你们中的一些人可能认为这是重复的，是的，我发现了很多类似的例子：

但是 Pycharm 说我可以简单地这样：

if y > x and x != -1:
    #  do something

我做了一些搜索，找不到类似的东西。我的问题是这样简化这个函数是否正确：

if y > x != -1:
    #  do something

如果是这样，它是否安全？除了更短之外，此版本与非简化版本之间是否有任何区别？如果简化它不是正确的方法，那又是什么？

Answer 1

这在功能上是等价的，但是当这个：

10 < x < 40

很好读，混合不同的运算符来使用链式比较并不是最好的选择。

是真的一样吗？让我们拆开看看：

def f1(x,y):
    if y > x and x != -1:
        return 0

def f2(x,y):
    if y > x != -1:
        return 0

import dis

print("function 1")
dis.dis(f1)
print("function 2")
dis.dis(f2)

结果：

function 1
  2           0 LOAD_FAST                1 (y)
              3 LOAD_FAST                0 (x)
              6 COMPARE_OP               4 (>)
              9 POP_JUMP_IF_FALSE       28
             12 LOAD_FAST                0 (x)
             15 LOAD_CONST               3 (-1)
             18 COMPARE_OP               3 (!=)
             21 POP_JUMP_IF_FALSE       28

  3          24 LOAD_CONST               2 (0)
             27 RETURN_VALUE
        >>   28 LOAD_CONST               0 (None)
             31 RETURN_VALUE
function 2
  6           0 LOAD_FAST                1 (y)
              3 LOAD_FAST                0 (x)
              6 DUP_TOP
              7 ROT_THREE
              8 COMPARE_OP               4 (>)
             11 JUMP_IF_FALSE_OR_POP    23
             14 LOAD_CONST               3 (-1)
             17 COMPARE_OP               3 (!=)
             20 JUMP_FORWARD             2 (to 25)
        >>   23 ROT_TWO
             24 POP_TOP
        >>   25 POP_JUMP_IF_FALSE       32

  7          28 LOAD_CONST               2 (0)
             31 RETURN_VALUE
        >>   32 LOAD_CONST               0 (None)
             35 RETURN_VALUE
>>> 

令人惊讶的是，它们并不相同，链式版本有更多说明。

不确定这里发生了什么（有些人花了更多时间来更好地解释它：Python 中的链式比较实际上如何工作？），但我真的会坚持使用and快捷方式且可读性强的版本（也考虑未来的维护者） ……）。

也就是说，关于链式比较的一件有趣的事情是，如果计算中心参数/需要很长时间来计算/在计算中有副作用，并且您不想将其存储在变量中：

if y > super_long_computation(x) != -1:

在这种情况下，中心参数只计算一次。在 的情况下and，您必须事先存储它。