为什么这个切片代码比更多程序代码更快？

Question

我有一个 Python 函数，它接受一个列表并返回一个生成器，生成每个相邻对的 2 元组，例如

>>> list(pairs([1, 2, 3, 4]))
[(1, 2), (2, 3), (3, 4)]

我考虑过使用 2 个切片的实现：

def pairs(xs):
    for p in zip(xs[:-1], xs[1:]): 
        yield p

还有一个以更程序化的风格编写的：

def pairs(xs):
    last = object()
    dummy = last
    for x in xs:
        if last is not dummy:
            yield last,x
        last = x

使用range(2 ** 15) 作为输入进行测试会产生以下时间（您可以找到我的测试代码并输出here）：

2 slices: 100 loops, best of 3: 4.23 msec per loop
0 slices: 100 loops, best of 3: 5.68 msec per loop

无切片实现的部分性能损失是循环中的比较 (if last is not dummy)。删除它（使输出不正确）提高了它的性能，但它仍然比 zip-a-pair-of-slices 实现慢：

2 slices: 100 loops, best of 3: 4.48 msec per loop
0 slices: 100 loops, best of 3: 5.2 msec per loop

所以，我被难住了。为什么将 2 个切片压缩在一起，有效地并行迭代列表两次，比迭代一次更快，随时更新 last 和 x？

编辑

Dan Lenski proposed第三个实现：

def pairs(xs):
    for ii in range(1,len(xs)):
        yield xs[ii-1], xs[ii]

这是它与其他实现的比较：

2 slices: 100 loops, best of 3: 4.37 msec per loop
0 slices: 100 loops, best of 3: 5.61 msec per loop
Lenski's: 100 loops, best of 3: 6.43 msec per loop

它甚至更慢！这让我感到莫名其妙。

编辑 2：

ssm suggested 使用itertools.izip 代替zip，甚至比zip 还要快：

2 slices, izip: 100 loops, best of 3: 3.68 msec per loop

所以，izip 是迄今为止的赢家！但仍然出于难以检查的原因。

Answer 1

在这个线程的其他地方有很多有趣的讨论。基本上，我们开始比较这个函数的两个版本，我将用以下愚蠢的名字来描述它：

1. “zip-py”版本：

   def pairs(xs):
       for p in zip(xs[:-1], xs[1:]): 
           yield p
   

2. “循环”版本：

   def pairs(xs):
       last = object()
       dummy = last
       for x in xs:
           if last is not dummy:
               yield last,x
           last = x
   

那么为什么 loopy 版本会变慢呢？基本上，我认为这归结为几件事：

1. loopy 版本明确地做了额外的工作：它在内部循环的每个对生成迭代中比较两个对象的身份 (if last is not dummy: ...)。

   • @mambocab 的编辑表明，不进行此比较确实会使版本变得循环
     稍微快一点，但并没有完全缩小差距。
     
     

2. zippy 版本在编译的 C 代码中比 loopy 版本在 Python 代码中的作用更多：

   • 将两个对象组合成一个tuple。 loopy 版本是yield last,x，而在zippy 版本中，元组p 直接来自zip，所以它只是yield p。

   • 将变量名称绑定到对象：循环版本在每个循环中执行两次，在 for 循环中分配 x 和 last=x。 zippy 版本仅在 for 循环中执行此操作。

3. 有趣的是，zippy 版本实际上有一种更多工作的方式：它使用两个listiterators、iter(xs[:-1])和iter(xs[1:])，传递给zip。 loopy 版本仅使用 一个 listiterator (for x in xs)。

   • 创建listiterator 对象（iter([]) 的输出）可能是一个高度优化的操作，因为 Python 程序员经常使用它。
   • 迭代列表切片xs[:-1] 和xs[1:] 是一个非常轻量级的操作，与迭代整个列表相比，它几乎不会增加任何开销。本质上，它只是意味着移动迭代器的起点或终点，而不是改变每次迭代发生的事情。

Answer 2

这是iZip 的结果，实际上更接近您的实现。看起来像你所期望的那样。 zip 版本在函数内的内存中创建整个列表，因此它是最快的。循环版本只是在列表中丢失，所以它有点慢。 izip 与代码最相似，但我猜有一些内存管理后端进程会增加执行时间。

In [11]: %timeit pairsLoop([1,2,3,4,5])
1000000 loops, best of 3: 651 ns per loop

In [12]: %timeit pairsZip([1,2,3,4,5])
1000000 loops, best of 3: 637 ns per loop

In [13]: %timeit pairsIzip([1,2,3,4,5])
1000000 loops, best of 3: 655 ns per loop

代码版本按要求如下所示：

from itertools import izip


def pairsIzip(xs):
    for p in izip(xs[:-1], xs[1:]): 
        yield p

def pairsZip(xs):
    for p in zip(xs[:-1], xs[1:]): 
        yield p

def pairsLoop(xs):
    last = object()
    dummy = last
    for x in xs:
        if last is not dummy:
            yield last,x
        last = x

Answer 3

我怀疑第二个版本较慢的主要原因是因为它对它yields 的每一对都进行了比较操作：

# pair-generating loop
for x in xs:
    if last is not dummy:
       yield last,x
    last = x

第一个版本除了吐出值什么都不做。将循环变量重命名后，相当于这样：

# pair-generating loop
for last,x in zip(xs[:-1], xs[1:]):
    yield last,x 

它不是特别漂亮或 Pythonic，但您可以编写一个程序版本，而无需在内循环中进行比较。这个跑得有多快？

def pairs(xs):
    for ii in range(1,len(xs)):
        yield xs[ii-1], xs[ii]