Python 3: самый эффективный способ создать [func (i), поскольку я в диапазоне (N)] перечисляю понимание

Если вы используете модуль 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 и вашего оборудования. (См. Комментарии.)

% 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 is to time при использовании метода «предварительного распределения». (Это не просто часть настройки, поскольку это код, который может понадобиться только при использовании предварительного распределения.)

PS. модуль time (и команда time (unix)) может дать недостоверные результаты . Если вы хотите синхронизировать код Python, я бы посоветовал использовать модуль timeit .

Здесь придется не соглашаться с Хавьером ...

Используя следующий код:

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 (которое я бы рекомендовал) и другими решениями. Если позже вы не обработаете все элементы списка, вы также можете использовать ленивый метод (показанный в приведенном выше коде), который создаст генератор, который производит элементы к тому времени, когда вы выполняете итерацию по нему.

Использование понимания списка для выполнения того, что вы пытаетесь сделать, было бы более питоническим способом сделать это. Несмотря на снижение производительности :).

Нет никакой разницы в вычислительной сложности между использованием массива с авторазмером и предварительным распределением массива. В худшем случае, это стоит примерно O(2N). См. здесь:

Постоянное амортизированное время

Стоимость вызовов функций плюс все, что происходит в вашей функции, сделает это дополнительное n несущественным. Это не то, о чем вы должны беспокоиться. Просто используйте понимание списка.