Python - 追加 VS 扩展效率

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 更快，但与创建tuple 相比，创建list 相对昂贵

---

编辑

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

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

它们所用的时间完全相同。

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

与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 3

还值得指出的是，这个问题的答案取决于每次迭代中添加的列表/元组的小尺寸。对于较大的列表，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_tup(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_tup([], repetitions)', setup='from __main__ import extend_tup, repetitions')

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

时间是：

53.8211231232
57.1711571217
19.8829259872
28.5986201763

正如我们所见，使用列表推导式扩展仍然比追加快两倍多。此外，元组理解似乎比列表理解慢得多，并且append_comp 只会引入不必要的列表创建开销。