python - 打印号码和号码列表的执行时间

Question

我正在尝试打印 1 到 1000 之间的数字。

print(*range(1,1001))比打印列表花费更多时间 print([*range(1,1001)]) .

打印列表比打印数字行快得多的原因是什么？

Answer 1

您可以在这里询问两件不同的事情。

<小时/>

第二个会更快，因为以下原因:

• 传递单个参数而不是 1000 个。(在最新版本的 CPython 中，这实际上并不意味着在堆栈上传递 1000 个值，但它确实意味着您必须通过 CALL_FUNCTION_EX 而不是经历更简单的CALL_FUNCTION，事实上它是优化的快速路径。)
• 在优化的 list.__repr__ 内循环列表元素，而不是使用通用迭代器循环。
• print 在每个元素的 __str__ 之间所做的事情比 list.__repr__ 在 之间所做的事情稍微复杂一些每个元素的 __repr__ (有条件地打印局部变量，而不是总是附加常量字符串)。

这应该是微秒的问题 - 足以测量，但不足以注意到。

<小时/>

但第二个也会更快，因为它进行的 I/O 调用更少。这很可能会掩盖所有这些微小的差异。如果您的终端速度很慢，例如 Windows cmd 或 IDLE 假终端，这很容易引起注意。

<小时/>

首先让我们尝试调用一个完全不执行任何操作的函数:

In [765]: def dummy(*args): pass    
In [766]: %timeit dummy(*range(1, 1001))
19 µs ± 71.1 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)    
In [767]: %timeit dummy([*range(1, 1001)])
13 µs ± 609 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

因此，由于参数传递，第二个速度快了大约 50%，但也只有 6us。

<小时/>

如果它像 print 那样有效地迭代其参数会怎样？

In [768]: def dummy(*args):
     ...:     for _ in args: pass
In [769]: %timeit dummy(*range(1, 1001))
22.8 µs ± 1.31 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)    
In [770]: %timeit dummy([*range(1, 1001)])
13.1 µs ± 148 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

现在已经接近2:1了，但仍然只有9us的差距。

当然，我在这里有点作弊，因为 print 是一个 C 函数，但是，无论哪种方式，*args 都会变成他们拥有的元组以某种方式循环。

<小时/>

如果它也调用每个参数的 __str__ 来进行更公平的比较怎么办？

In [776]: def dummy(*args):
     ...:     for arg in args: str(arg)
In [776]: %timeit dummy(*range(1, 1001))
185 µs ± 1.67 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)    
In [777]: %timeit dummy([*range(1, 1001)])
86.3 µs ± 826 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

即使尝试让事情对第一个更公平，它仍然大约是 2:1。

<小时/>

让我们实际调用 print，但打印到一个文件对象，该对象只是丢弃其输入:

In [747]: class Nully:
     ...:     def write(self, *args): pass
In [749]: null = Nully()    
In [750]: %timeit print(*range(1, 1001), file=null)
390 µs ± 7.44 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)   
In [751]: %timeit print([*range(1, 1001)], file=null)
88.4 µs ± 2.35 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

现在第二个速度大约是原来的 4 倍，但我们仍然只讨论零点几毫秒。

<小时/>

现在让我们尝试连接实际的 I/O，但连接到空设备:

In [745]: %timeit with open(os.devnull, 'w') as null: print(*range(1, 1001), file=null)
436 µs ± 13.3 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)    
In [746]: %timeit with open(os.devnull, 'w') as null: print([*range(1, 1001)], file=null)
140 µs ± 1.74 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

它们都减慢了大约相同的小幅度。

<小时/>

现在让我们尝试写入一个每次写入都需要很长时间(例如 10 毫秒)的文件:

In [767]: class Slowy:
     ...:     def write(self, *args): time.sleep(0.01)
In [768]: null = Slowy()
In [770]: %timeit print(*range(1, 1001), file=null)
26.8 s ± 15.9 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

In [771]: %timeit print([*range(1, 1001)], file=null)
28.2 ms ± 39.1 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

原来的 300us 差异大概仍然存在，但谁在乎呢？这里重要的是由 1000 次写入而不是 1 次写入造成的 3 个数量级的 27 秒差异。

当然，即使是 cmd.exe 和 IDLE 也没有那么慢。但它们的速度相当慢。

所以，我的猜测是，最后一部分就是您要问的内容。

<小时/>

事实上，从后来添加的评论来看:

It is human noticeable delay .

timeit.timeit("print(*range(1,1001))",number=1) => 10 s 
timeit.timeit("print([*range(1,1001)])",number=1) => 95 ms

BTW, I am using Windows and running this code on Python IDLE .

所以我错了:IDLE几乎完全那么慢。 (哇!)