Python 中 and 与多个 if 的效率

Question

在 if 语句中使用 and 与使用多个 if 语句在效率上有区别吗？换句话说，

if expr1 == expr2 and expr3==expr4:
  dostuff()

从效率的角度来看，有什么不同吗：

if expr1 == expr2:
  if expr3 == expr4:
    dostuff()

我非常基本的测试并没有揭示出差异，但是具有更多知识（或至少更彻底的测试）的人是否有明确的答案？

Answer 1

使用 and 和嵌套 if 之间的速度差异很小。你找错了树。考虑这棵树：

if oftenTrueCondition and rarelyTrueCondition:

与

if rarelyTrueCondition and oftenTrueCondition:

So 相比，除非必须首先评估第一个条件（它是阻止下一个表达式崩溃或做一些愚蠢/昂贵的事情的保护），请考虑交换评估顺序。

Answer 2

这不足以影响您的决定（如果有的话）。 IMO，这里的决定应该纯粹从可读性的角度做出。我认为第一个通常更标准，但在某些情况下第二个可能更清晰。选择最能传达您意图的方法。

Answer 3

无论哪种情况，if 中 expr1 == expr2 的计算结果为 false，第二个值将不会被计算。

Answer 4

如有疑问，您可以使用 dis 模块检查 python 编译语句的内容：

>>> import dis
>>> def test1():
...     if expr1 == expr2 and expr3==expr4:
...        dostuff()
... 
>>> def test2():
...     if expr1 == expr2:
...        if expr3 == expr4:
...           dostuff()
... 
>>> dis.dis(test1)
  2           0 LOAD_GLOBAL              0 (expr1)
              3 LOAD_GLOBAL              1 (expr2)
              6 COMPARE_OP               2 (==)
              9 JUMP_IF_FALSE           24 (to 36)
             12 POP_TOP             
             13 LOAD_GLOBAL              2 (expr3)
             16 LOAD_GLOBAL              3 (expr4)
             19 COMPARE_OP               2 (==)
             22 JUMP_IF_FALSE           11 (to 36)
             25 POP_TOP             

  3          26 LOAD_GLOBAL              4 (dostuff)
             29 CALL_FUNCTION            0
             32 POP_TOP             
             33 JUMP_FORWARD             1 (to 37)
        >>   36 POP_TOP             
        >>   37 LOAD_CONST               0 (None)
             40 RETURN_VALUE        
>>> dis.dis(test2)
  2           0 LOAD_GLOBAL              0 (expr1)
              3 LOAD_GLOBAL              1 (expr2)
              6 COMPARE_OP               2 (==)
              9 JUMP_IF_FALSE           28 (to 40)
             12 POP_TOP             

  3          13 LOAD_GLOBAL              2 (expr3)
             16 LOAD_GLOBAL              3 (expr4)
             19 COMPARE_OP               2 (==)
             22 JUMP_IF_FALSE           11 (to 36)
             25 POP_TOP             

  4          26 LOAD_GLOBAL              4 (dostuff)
             29 CALL_FUNCTION            0
             32 POP_TOP             
             33 JUMP_ABSOLUTE           41
        >>   36 POP_TOP             
             37 JUMP_FORWARD             1 (to 41)
        >>   40 POP_TOP             
        >>   41 LOAD_CONST               0 (None)
             44 RETURN_VALUE        

因此，如您所见，在 python 字节码级别，两个语句是相同的 - 即使您在第一个语句中使用单个 if ，它也会在之后执行 JUMP_IF_FALSE首先比较。

Answer 5

第一个（一个 if 与 and）更快:-)

我使用 timeit 进行了尝试。结果如下：

Variant 1: 9.82836714316
Variant 2: 9.83886494559
Variant 1 (True): 9.66493159804
Variant 2 (True): 10.0392633241

对于最后两个比较，第一个比较为 True，因此跳过第二个比较。有趣的结果。

---

import timeit


print "Variant 1: %s" % timeit.timeit("""
for i in xrange(1000):
    if i == 2*i and i == 3*i:
        pass
        """,
        number = 1000)

print "Variant 2: %s" % timeit.timeit("""
for i in xrange(1000):
    if i == 2*i:
        if i == 3*i:
            pass
        """,
        number = 1000)

print "Variant 1 (True): %s" % timeit.timeit("""
for i in xrange(1000):
    if i == i and i == 3*i:
        pass
        """,
        number = 1000)

print "Variant 2 (True): %s" % timeit.timeit("""
for i in xrange(1000):
    if i == i:
        if i == 3*i:
            pass
        """,
        number = 1000)