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

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）。

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

但是...我注意到链式表达式和等效表达式之间存在细微的性能差异，无论是 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 的额外引用并不是免费的。它处于 "seriously, don't worry about it" 级别的便宜，但它并不是真正的免费，并且您将其与加载局部变量的稍微便宜的操作进行比较。

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

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

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

Why are chained operator expressions slower than their expanded equivalent?

python

comparison

python-internals