假设我有一个函数func(i)，它为整数i创建一个对象，N是非负整数。那么创建一个与该列表相等的列表（不是范围），最快的方法是什么？
mylist = [func(i) for i in range(N)]
不需要使用高级方法，如在C中创建函数，是否有其他方法？ 我对上述列表理解的主要担忧是，我不确定Python是否预先知道范围（N）的长度来预分配mylist，因此必须逐步重新分配列表。 是这种情况还是Python足够聪明，可以先将mylist分配到长度N，然后计算它的元素？ 如果不行，创建mylist的最佳方法是什么？ 或许这样做？
mylist = [None]*N
for i in range(N): mylist[i] = func(i)
重新编辑：已从以前的编辑中删除了误导性信息。
有人写道：“Python很聪明。只要您正在迭代的对象具有__len__或__length_hint__方法，Python将调用它来确定大小并预分配数组。”
据我所知，在列表推导式中没有预分配。Python无法从输入的大小中得知输出的大小。
看看这个Python 2.6代码：
>>> def foo(func, iterable):
... return [func(i) for i in iterable]
...
>>> import dis; dis.dis(foo)
2 0 BUILD_LIST 0 #### build empty list
3 DUP_TOP
4 STORE_FAST 2 (_[1])
7 LOAD_FAST 1 (iterable)
10 GET_ITER
>> 11 FOR_ITER 19 (to 33)
14 STORE_FAST 3 (i)
17 LOAD_FAST 2 (_[1])
20 LOAD_FAST 0 (func)
23 LOAD_FAST 3 (i)
26 CALL_FUNCTION 1
29 LIST_APPEND #### stack[-2].append(stack[-1]); pop()
30 JUMP_ABSOLUTE 11
>> 33 DELETE_FAST 2 (_[1])
36 RETURN_VALUE
它只是建立一个空列表，并附加迭代器提供的任何内容。
现在看看这段代码，其中列表推导式中有一个'if'语句：
>>> def bar(func, iterable):
... return [func(i) for i in iterable if i]
...
>>> import dis; dis.dis(bar)
2 0 BUILD_LIST 0
3 DUP_TOP
4 STORE_FAST 2 (_[1])
7 LOAD_FAST 1 (iterable)
10 GET_ITER
>> 11 FOR_ITER 30 (to 44)
14 STORE_FAST 3 (i)
17 LOAD_FAST 3 (i)
20 JUMP_IF_FALSE 17 (to 40)
23 POP_TOP
24 LOAD_FAST 2 (_[1])
27 LOAD_FAST 0 (func)
30 LOAD_FAST 3 (i)
33 CALL_FUNCTION 1
36 LIST_APPEND
37 JUMP_ABSOLUTE 11
>> 40 POP_TOP
41 JUMP_ABSOLUTE 11
>> 44 DELETE_FAST 2 (_[1])
47 RETURN_VALUE
>>>
>>> import dis
>>> def comprehension(f, iterable): return [f(i) for i in iterable]
...
>>> dis.dis(comprehension)
1 0 LOAD_CLOSURE 0 (f)
3 BUILD_TUPLE 1
6 LOAD_CONST 1 (<code object <listcomp> at 0x00C4B8D
8, file "<stdin>", line 1>)
9 MAKE_CLOSURE 0
12 LOAD_FAST 1 (iterable)
15 GET_ITER
16 CALL_FUNCTION 1
19 RETURN_VALUE
>>> dis.dis(comprehension.__code__.co_consts[1])
1 0 BUILD_LIST 0
3 LOAD_FAST 0 (.0)
>> 6 FOR_ITER 18 (to 27)
9 STORE_FAST 1 (i)
12 LOAD_DEREF 0 (f)
15 LOAD_FAST 1 (i)
18 CALL_FUNCTION 1
21 LIST_APPEND 2
24 JUMP_ABSOLUTE 6
>> 27 RETURN_VALUE
>>>
这是老生常谈的技巧：先建立一个空列表，然后迭代可迭代对象，在必要时将元素添加到列表中。我在这里看不到任何预分配。
你想到的优化方法是在单个操作码内使用，例如list.extend(iterable)的实现可以在iterable能够准确报告其长度时进行预分配。list.append(object)只接受单个对象而不是可迭代对象。
timeit模块，您可能会得出相反的结论：列表推导比预分配更快：f=lambda x: x+1
N=1000000
def lc():
return [f(i) for i in range(N)]
def prealloc():
mylist = [None]*N
for i in range(N): mylist[i]=f(i)
return mylist
def xr():
return map(f,xrange(N))
if __name__=='__main__':
lc()
% python -mtimeit -s"import test" "test.prealloc()"
10 loops, best of 3: 370 msec per loop
% python -mtimeit -s"import test" "test.lc()"
10 loops, best of 3: 319 msec per loop
% python -mtimeit -s"import test" "test.xr()"
10 loops, best of 3: 348 msec per loop
mylist = [None]*N包括在timeit要计时的代码中。（它不仅是设置的一部分，因为只有在使用预分配时才需要这段代码。）time模块（以及time（UNIX）命令）可能会给出不可靠的结果。如果您想计时Python代码，我建议使用timeit模块。map(f, xrange(N))的速度要快得多。 - Josh Leexr来测试map(f,xrange(N))。在CPython 2.6中，列表推导比map更快。 - unutbu240/192/148 (python 2.6.4), 244/216/200 (3.1.1)。在两个版本中，map 稍微快一些。 - jfs这里必须要不同意Javier...
以下是代码:
print '%5s | %6s | %6s' % ('N', 'l.comp', 'manual')
print '------+--------+-------'
for N in 10, 100, 1000, 10000:
num_iter = 1000000 / N
# Time for list comprehension.
t1 = timeit.timeit('[func(i) for i in range(N)]', setup='N=%d;func=lambda x:x' % N, number=num_iter)
# Time to build manually.
t2 = timeit.timeit('''mylist = [None]*N
for i in range(N): mylist[i] = func(i)''', setup='N=%d;func=lambda x:x' % N, number=num_iter)
print '%5d | %2.4f | %2.4f' % (N, t1, t2)
N | l.comp | manual
------+--------+-------
10 | 0.3330 | 0.3597
100 | 0.2371 | 0.3138
1000 | 0.2223 | 0.2740
10000 | 0.2185 | 0.2771
有趣的问题。根据以下测试，似乎在当前的CPython实现中（Python 2代码但结果排名相同，除了Python 3中没有xrange），预分配并不能提高性能：
N = 5000000
def func(x):
return x**2
def timeit(fn):
import time
begin = time.time()
fn()
end = time.time()
print "%-18s: %.5f seconds" % (fn.__name__, end - begin)
def normal():
mylist = [func(i) for i in range(N)]
def normalXrange():
mylist = [func(i) for i in xrange(N)]
def pseudoPreallocated():
mylist = [None] * N
for i in range(N): mylist[i] = func(i)
def preallocated():
mylist = [None for i in range(N)]
for i in range(N): mylist[i] = func(i)
def listFromGenerator():
mylist = list(func(i) for i in range(N))
def lazy():
mylist = (func(i) for i in xrange(N))
timeit(normal)
timeit(normalXrange)
timeit(pseudoPreallocated)
timeit(preallocated)
timeit(listFromGenerator)
timeit(lazy)
结果（排名在括号中）：
normal : 7.57800 seconds (2)
normalXrange : 7.28200 seconds (1)
pseudoPreallocated: 7.65600 seconds (3)
preallocated : 8.07800 seconds (5)
listFromGenerator : 7.84400 seconds (4)
lazy : 0.00000 seconds
但是使用 psyco.full()：
normal : 7.25000 seconds (3)
normalXrange : 7.26500 seconds (4)
pseudoPreallocated: 6.76600 seconds (1)
preallocated : 6.96900 seconds (2)
listFromGenerator : 10.50000 seconds (5)
lazy : 0.00000 seconds
正如您所看到的，使用psyco进行伪预分配更快。无论如何，xrange解决方案（我建议使用）和其他解决方案之间没有太大区别。如果您以后不处理列表的所有元素，则还可以使用惰性方法（如上面的代码所示），它将创建一个生成器，按照您迭代它的时间产生元素。
http://svn.python.org/view/python/branches/py3k/Objects/listobject.c?view=markup在页面中按Ctrl-F搜索_PyObject_LengthHint。 - John Machin