Эффективные способы дублирования массива/списка в Python

Ответ 1

Используйте timeit модуль в python для тестирования таймингов.

from copy import *

a=range(1000)

def cop():
    b=copy(a)

def func1():
    b=list(a)

def slice():
    b=a[:]

def slice_len():
    b=a[0:len(a)]



if __name__=="__main__":
    import timeit
    print "copy(a)",timeit.timeit("cop()", setup="from __main__ import cop")
    print "list(a)",timeit.timeit("func1()", setup="from __main__ import func1")
    print "a[:]",timeit.timeit("slice()", setup="from __main__ import slice")
    print "a[0:len(a)]",timeit.timeit("slice_len()", setup="from __main__ import slice_len")

Результаты:

copy(a) 3.98940896988
list(a) 2.54542589188
a[:] 1.96630120277                   #winner
a[0:len(a)] 10.5431251526

Конечно, дополнительные шаги, участвующие в a[0:len(a)], являются причиной его медленности.

Здесь сравнение байтового кода двух:

In [19]: dis.dis(func1)
  2           0 LOAD_GLOBAL              0 (range)
              3 LOAD_CONST               1 (100000)
              6 CALL_FUNCTION            1
              9 STORE_FAST               0 (a)

  3          12 LOAD_FAST                0 (a)
             15 SLICE+0             
             16 STORE_FAST               1 (b)
             19 LOAD_CONST               0 (None)
             22 RETURN_VALUE        

In [20]: dis.dis(func2)
  2           0 LOAD_GLOBAL              0 (range)
              3 LOAD_CONST               1 (100000)
              6 CALL_FUNCTION            1
              9 STORE_FAST               0 (a)

  3          12 LOAD_FAST                0 (a)    #same up to here
             15 LOAD_CONST               2 (0)    #loads 0
             18 LOAD_GLOBAL              1 (len) # loads the builtin len(),
                                                 # so it might take some lookup time
             21 LOAD_FAST                0 (a)
             24 CALL_FUNCTION            1         
             27 SLICE+3             
             28 STORE_FAST               1 (b)
             31 LOAD_CONST               0 (None)
             34 RETURN_VALUE        

Ответ 2

Я не могу прокомментировать время рубина по сравнению с таймером python. Но я могу прокомментировать list vs. slice. Здесь быстрый просмотр байт-кода:

>>> import dis
>>> a = range(10)
>>> def func(a):
...     return a[:]
... 
>>> def func2(a):
...     return list(a)
... 
>>> dis.dis(func)
  2           0 LOAD_FAST                0 (a)
              3 SLICE+0             
              4 RETURN_VALUE        
>>> dis.dis(func2)
  2           0 LOAD_GLOBAL              0 (list)
              3 LOAD_FAST                0 (a)
              6 CALL_FUNCTION            1
              9 RETURN_VALUE 

Обратите внимание, что для list требуется LOAD_GLOBAL найти функцию list. Глянг-глобулы (и вызывающие функции) в python относительно медленны. Это объясняет, почему a[0:len(a)] также медленнее. Также помните, что list должен иметь возможность обрабатывать произвольные итераторы, тогда как нарезка - нет. Это означает, что list необходимо выделить новый список, упаковать элементы в этот список, поскольку он выполняет итерацию по списку и при необходимости изменяет размер. Здесь есть несколько вещей, которые являются дорогостоящими - при необходимости изменяя размер и итерируя (эффективно в python, а не в C). С помощью метода нарезки вы можете рассчитать размер необходимой вам памяти, поэтому, возможно, избежать изменения размера, и итерация может быть выполнена полностью на C (возможно, с memcpy или чем-то.

отказ от ответственности: я не разработчик python, поэтому я не знаю, как реализованы внутренние функции list(). Я просто размышляю о том, что знаю о спецификации.

EDIT. Итак, я посмотрел на источник (с небольшим руководством от Martijn). Соответствующий код находится в listobject.c. list вызывает list_init, который затем вызывает listextend в строке 799. Эта функция имеет некоторые проверки, чтобы увидеть, может ли она использовать быструю ветвь, если объект является списком или кортежем (строка 812). Наконец, тяжелый подъем выполняется с линии 834:

 src = PySequence_Fast_ITEMS(b);
 dest = self->ob_item + m;
 for (i = 0; i < n; i++) {
     PyObject *o = src[i];
     Py_INCREF(o);
     dest[i] = o;
 }

Сравните это со срединной версией, которая, как мне кажется, определена в list_subscript (строка 2544). Это вызывает list_slice (строка 2570), где тяжелый подъем выполняется следующим циклом (строка 486):

 src = a->ob_item + ilow;
 dest = np->ob_item;
 for (i = 0; i < len; i++) {
     PyObject *v = src[i];
     Py_INCREF(v);
     dest[i] = v;
 }

Они похожи на один и тот же код, поэтому неудивительно, что производительность почти одинакова для больших списков (где накладные расходы на мелкие вещи, такие как распаковка срезов, поиск глобальных переменных и т.д., становятся менее важными)

Вот как я буду запускать тесты python (и результаты для моей системы Ubuntu):

$ python -m timeit -s 'a=range(30)' 'list(a)'
1000000 loops, best of 3: 0.39 usec per loop
$ python -m timeit -s 'a=range(30)' 'a[:]'
10000000 loops, best of 3: 0.183 usec per loop
$ python -m timeit -s 'a=range(30)' 'a[0:len(a)]'
1000000 loops, best of 3: 0.254 usec per loop