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的额外引用并不是免费的。它是认真的，不用担心它＆＃34;便宜的水平，但它没有字面上的自由，你将它与加载局部变量的稍微便宜的操作进行比较。

COMPARE_OP操作码会从堆栈中删除它所比较的对象，因此对于链式比较，Python必须创建另一个对b（DUP_TOP）的引用并推送它在堆栈中放置了两个位置（ROT_THREE）以使其不受影响。

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

为什么链接的运算符表达式比它们的扩展等价物慢？

1 个答案: