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

Question

在python中,可以以这种方式链接运算符:

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的基于堆栈的字节码执行引擎中,b为链式比较保存额外的引用并不是免费的.它是"认真的,不用担心它"的廉价水平,但它并不是真正免费的,你将它与稍微便宜的加载局部变量的操作进行比较.

该COMPARE_OP操作码删除它从栈中比较的对象,所以链式比较,Python有创造的又一个引用b(DUP_TOP)和推它在筹码减少两个地方(ROT_THREE)把它弄出来的方式.

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