迭代列表的奇怪速度差异

Question

我创建了两个长列表，重复两个不同的值。在第一个列表中，值交替出现，在第二个列表中，一个值出现在另一个值之前：

a1 = [object(), object()] * 10**6
a2 = a1[::2] + a1[1::2]

然后我迭代它们，对它们不做任何操作：

for _ in a1: pass
for _ in a2: pass

两者哪个迭代更快？取决于我如何测量！我用每种计时方法跑了50场比赛：

timing method: timeit.timeit
  list a1 won 50 times
  list a2 won 0 times

timing method: timeit.default_timer
  list a1 won 0 times
  list a2 won 50 times

为什么这两种计时方法给我的结果完全相反？为什么这两个列表之间存在速度差异？我希望有两次25-25，而不是50-0和0-50。

之前类似问题的原因以及我认为他们不应该对此负责的原因：

• 分支预测：我没有任何分支可以有所作为。
• 缓存未命中：不应该发生，因为我只有两个值（我甚至没有用它们做任何事情）。
• 垃圾回收机制：这里不涉及。
• 无论如何，这些都无法解释两种计时方法之间相反的速度差异。

我使用的是Python3.10，在一台较弱的Windows笔记本电脑和一个强大的LinuxGoogle计算引擎实例上得到了相同的结果。

完整代码：

from timeit import timeit, default_timer

a1 = [object(), object()] * 10**6
a2 = a1[::2] + a1[1::2]

for method in 'timeit', 'default_timer':
    wins1 = wins2 = 0

    for _ in range(50):

        time1 = time2 = float('inf')
        for _ in range(5):

            if method == 'timeit':
                t1 = timeit('for _ in a1: pass', 'from __main__ import a1', number=1)
                t2 = timeit('for _ in a2: pass', 'from __main__ import a2', number=1)
            else:
                start = default_timer();
                for _ in a1: pass
                end = default_timer()
                t1 = end - start

                start = default_timer();
                for _ in a2: pass
                end = default_timer()
                t2 = end - start

            time1 = min(time1, t1)
            time2 = min(time2, t2)

        wins1 += time1 < time2
        wins2 += time2 < time1

    print(f'timing method: timeit.{method}')
    print(f'  list a1 won {wins1} times')
    print(f'  list a2 won {wins2} times')
    print()

Answer 1

不是“答案”，而是一条线索：添加

def f(a):
    for _ in a: pass

然后在default\u timer分支中替换

for _ in a1: pass

对于f（a1），对于a2上的迭代也是如此。

我看到两件事：

1. 输出更改为更统一

timing method: timeit.timeit

  list a1 won 50 times
  list a2 won 0 times

timing method: timeit.default_timer
  list a1 won 50 times
  list a2 won 0 times

#2是如此明显，可能很难注意到原因；-）在原始版本中，for循环目标\uu是一个全局模块，因此在每次迭代中更新它需要dict查找和存储。但是timeit用传递给它的内容构建一个函数，因此在运行的代码timeit中，\uu是一个局部变量，更快的STORE\u FAST索引存储就足够了。

引入了函数f（），以便在这两种情况下对局部变量进行“繁重的提升”。

在这里被计时的代码做的非常少，以致于一个判断查找和一个带有一个int的索引向量操作之间的差异可能是非常显著的