python - 为什么链式运算符表达式比扩展的运算符表达式慢？

Question

在python中，可以chain operators以这种方式:

a op b op c

评估为

a op b and b op c 

唯一的区别是 b 只计算一次(所以，更像 t = eval(b); a op t and t op c)。

从非常可读的角度来看，这是有利的，并且比具有显式连接(使用和)的等效版本更简洁。

但是...我注意到链式表达式和等效表达式之间存在细微的性能差异，无论是 3 个操作数还是 20 个操作数。当您对这些操作计时时，这一点会变得很明显。

import timeit 

timeit.timeit("a <= b <= c", setup="a,b,c=1,2,3")
0.1086414959972899

timeit.timeit("a <= b and b <= c", setup="a,b,c=1,2,3")
0.09434155100097996

还有，

timeit.timeit("a <= b <= c <= d <= e <= f", setup="a,b,c,d,e,f=1,2,3,4,5,6")
0.2151330839988077

timeit.timeit("a <= b and b <= c and c <= d and d <= e and e <= f", setup="a,b,c,d,e,f=1,2,3,4,5,6")
0.19196406500122976

注意:所有测试均使用 Python-3.4 完成。

检查两个表达式的字节码后，我注意到其中一个比另一个执行更多(实际上多 4 个)操作。

import dis

dis.dis("a <= b <= c")
  1           0 LOAD_NAME                0 (a)
              3 LOAD_NAME                1 (b)
              6 DUP_TOP
              7 ROT_THREE
              8 COMPARE_OP               1 (<=)
             11 JUMP_IF_FALSE_OR_POP    21
             14 LOAD_NAME                2 (c)
             17 COMPARE_OP               1 (<=)
             20 RETURN_VALUE
        >>   21 ROT_TWO
             22 POP_TOP
             23 RETURN_VALUE 

对比一下，

dis.dis("a <= b and b <= c")
  1           0 LOAD_NAME                0 (a)
              3 LOAD_NAME                1 (b)
              6 COMPARE_OP               1 (<=)
              9 JUMP_IF_FALSE_OR_POP    21
             12 LOAD_NAME                1 (b)
             15 LOAD_NAME                2 (c)
             18 COMPARE_OP               1 (<=)
        >>   21 RETURN_VALUE

我没有阅读字节码的经验，但第一个代码片段肯定在字节码级别执行的操作比第二个多。

我是这样解释的。在第一种情况下，变量被压入某种堆栈，然后依次弹出以进行比较。所有变量只弹出一次。第二种情况，虽然没有栈，但是至少有(N-2)个操作数要两次加载到内存中进行比较。看起来堆栈弹出操作比加载 (N - 2) 个变量两次进行比较更昂贵，这是速度差异的原因。

简而言之，我试图理解为什么一个操作总是比另一个慢一个常数。我的假设正确吗？还是我缺少更多关于 python 内部的东西？

---

更多基准:

| System | a <= b <= c         | a <= b and b <= c   | a <= b <= ... <= e <= f | a <= b and ... and e <= f | Credit         |
|--------|---------------------|---------------------|-------------------------|---------------------------|----------------|
| 3.4    | 0.1086414959972899  | 0.09434155100097996 | 0.2151330839988077      | 0.19196406500122976       | @cᴏʟᴅsᴘᴇᴇᴅ     |
| 3.6.2  | 0.06788300536572933 | 0.059271858073771   | 0.1505890181288123      | 0.12044331897050142       | @Bailey Parker |
| 2.7.10 | 0.05009198188781738 | 0.04472208023071289 | 0.11113405227661133     | 0.09062719345092773       | @Bailey Parker |

Answer 1

在 CPython 的 stack-based bytecode execution engine 中, 保存对 b 的额外引用因为链式比较不是免费的。它处于“说真的，不用担心”的廉价级别，但它并不是真正的免费，并且您将它与加载局部变量的稍微便宜的操作进行比较。

COMPARE_OP操作码从堆栈中删除它正在比较的对象，因此对于链式比较，Python 必须创建另一个对 b 的引用。 ( DUP_TOP ) 并将其向下推到堆栈中的两个位置 ( ROT_THREE ) 以将其移开。

在a <= b and b <= c ，而不是上面的引用改组，Python 只是复制另一个对 b 的引用出栈帧的fastlocals大批。这涉及更少的指针改组和更少的字节码评估循环，因此它稍微便宜一些。