你能在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中的链式比较实际上是如何工作的？），但实际上我会坚持使用和版本的快捷方式，并且非常可读（想想未来的维护者....）。

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

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

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