追加与扩展效率

Question

这是我使用 Python 编写的一些代码：

from math import sqrt
abundant_list = []

for i in range(12,28123+1):
    dividor_list = [1]
    for j in range(2, int(sqrt(i))+1):
        if i%j == 0:
            dividor_list.extend([i/j,j])
    if sum(dividor_list) > i:
        abundant_list.append(i)

print abundant_list

正如您所看到的，代码确实在努力尽可能提高效率。

使用

list.append

两次或仅使用

list.extend

一次有什么区别吗？ 我知道这可能是微小的差异，但我真的很想知道:)

Answer 1

import timeit

def append2x(foo):
    foo.append(1)
    foo.append(1)

def extend_lst(foo):
    foo.extend([1,1])

def extend_tup(foo):
    foo.extend((1,1))


l1 = []
l2 = []
l3 = []

print timeit.timeit('append2x(l1)',setup = 'from __main__ import append2x,l1')
print timeit.timeit('extend_lst(l2)',setup = 'from __main__ import extend_lst,l2')
print timeit.timeit('extend_tup(l3)',setup = 'from __main__ import extend_tup,l3')

这是一个简单的基准。我的结果（os-X、10.5.8、core2duo、FWIW）：

0.520906925201  #append
0.602569103241  #extend-list
0.357008934021  #extend-tuple

我的 linux 机器（Ubuntu，x86-64 core i7）的结果顺序相同：

0.307395935059  #append
0.319436073303  #extend-list
0.238317012787  #extend-tuple

对我来说，这表明

extend

比

append

更快，但是与创建

list

 相比，创建 

tuple

相对昂贵

---

编辑

在下面的评论中指出，由于元组的不变性，解释器可以优化元组的创建（它创建一次元组并一遍又一遍地重复使用它）。如果我们将代码更改为：

def extend_lst(foo):  
    v = 1
    foo.extend([v,v]) 

def extend_tup(foo):
    v = 1
    foo.extend((v,v))

时间几乎相同：

0.297003984451  #append
0.344678163528  #extend-list
0.292304992676  #extend-tuple

尽管

tuple

仍然始终击败列表版本，并且在我所做的所有试验中勉强超越

append

版本。

我从中学到的一件事是，如果您要迭代包含所有文字的对象，请选择

tuple

而不是

list

。如果它不完全由文字组成，那么选择

list

或

tuple

并不重要。

Answer 2

编辑：正如其他人在评论中指出的那样，Python 中没有元组理解，因为该语法已用于生成器表达式。我已经澄清了描述。

还值得指出的是，这个问题的答案取决于每次迭代中添加的列表/元组的小尺寸。对于较大的列表，extend 显然更优越（列表与元组没有区别）。从 mgilson 的 answer 开始，我检查了包含 600 个项目（而不是 2 个）的集合的行为： 调用append 600次需要的时间是使用

extend()

和手动定义的列表/元组（即

[v,v,v,v,v,v,v...]

）的8倍：

42.4969689846
5.45146393776
5.38034892082

这五秒的大部分时间实际上是列表/元组的创建。在

timeit

通话之前做好准备，可以将时间延长至

1.42491698265
0.657584905624

分别用于列表和元组。

对于更现实（更公平）的情况，可以在函数调用中动态生成数据：

import timeit

def append_loop(foo, reps):
    for i in range(reps):
        foo.append(i)

def append_comp(foo, reps):
    [foo.append(i) for i in range(reps)]

def extend_lst(foo, reps):
    foo.extend([i for i in range(reps)])

def extend_genexp(foo, reps):
    foo.extend((i for i in range(reps)))

repetitions = 600

print timeit.timeit('append_loop([], repetitions)', setup='from __main__ import append_loop, repetitions')
print timeit.timeit('append_comp([], repetitions)', setup='from __main__ import append_comp, repetitions')
print timeit.timeit('extend_lst([], repetitions)', setup='from __main__ import extend_lst, repetitions')
print timeit.timeit('extend_genexp([], repetitions)', setup='from __main__ import extend_genexp, repetitions')

（Append 是通过 for 循环和列表理解来实现的，以消除两种循环方式之间的效率差异。）

时间为：

53.8211231232
57.1711571217
19.8829259872
28.5986201763

正如我们所看到的，使用列表理解进行扩展仍然比追加快两倍多。生成器表达式看起来明显比列表理解慢。

append_comp

只会引入不必要的列表创建开销。

Answer 3

他们花费完全相同的时间。

这是您的代码所花费的时间：

与

dividor_list.extend([i/j,j])

>>> 
0:00:00.410000
>>> 
0:00:00.383000
>>> 
0:00:00.389000

与

dividor_list.append(i/j); dividor_list.append(j)

>>> 
0:00:00.400000
>>> 
0:00:00.390000
>>> 
0:00:00.381000

Answer 4

只是另一个基准

这次是在ipython。如果您懒得创建新的 python 脚本，也许有用。

In [12]: %%time
    ...: l = []
    ...: for ii in range(10000):
    ...:     l += [ii]
    ...: 
CPU times: user 886 µs, sys: 0 ns, total: 886 µs
Wall time: 889 µs

In [13]: %%time
    ...: l = []
    ...: for ii in range(10000):
    ...:     l.append(ii)
    ...: 
CPU times: user 669 µs, sys: 92 µs, total: 761 µs
Wall time: 763 µs