在Python中复制数组/列表的有效方法
注意：我是一位Ruby开发人员，试图用Python找到我的方式。
当我想知道为什么有些脚本使用mylist[:]而不是list(mylist)来复制列表时，我对各种方法进行了快速测试，以复制range(10) （请参阅下面的代码）。
编辑：我更新了测试以利用Python的timeit ，如下所示。 这使得直接将它与Ruby进行比较是不可能的，因为在Ruby的Benchmark中timeit没有考虑循环，所以Ruby代码仅供参考。
Python 2.7.2
Array duplicating. Tests run 50000000 times
list(a) 18.7599430084
copy(a) 59.1787488461
a[:] 9.58828091621
a[0:len(a)] 14.9832749367
作为参考，我也在Ruby中编写了相同的脚本：
Ruby 1.9.2p0
Array duplicating. Tests 50000000 times
user system total real
Array.new(a) 14.590000 0.030000 14.620000 ( 14.693033)
Array[*a] 18.840000 0.060000 18.900000 ( 19.156352)
a.take(a.size) 8.780000 0.020000 8.800000 ( 8.805700)
a.clone 16.310000 0.040000 16.350000 ( 16.384711)
a[0,a.size] 8.950000 0.020000 8.970000 ( 8.990514)
问题1：什么是mylist[:]做得不同，它甚至比mylist[0:len(mylist)]快25％。 它直接复制到内存中还是什么？
问题2：编辑：更新的基准测试不再在Python和Ruby中显示出巨大差异。 是：我是否以明显低效的方式实施测试，以便Ruby代码比Python快得多？
现在的代码清单：
蟒蛇：
import timeit
COUNT = 50000000
print "Array duplicating. Tests run", COUNT, "times"
setup = 'a = range(10); import copy'
print "list(a)tt", timeit.timeit(stmt='list(a)', setup=setup, number=COUNT)
print "copy(a)tt", timeit.timeit(stmt='copy.copy(a)', setup=setup, number=COUNT)
print "a[:]tt", timeit.timeit(stmt='a[:]', setup=setup, number=COUNT)
print "a[0:len(a)]t", timeit.timeit(stmt='a[0:len(a)]', setup=setup, number=COUNT)
红宝石：
require 'benchmark'
a = (0...10).to_a
COUNT = 50_000_000
puts "Array duplicating. Tests #{COUNT} times"
Benchmark.bm(16) do |x|
x.report("Array.new(a)") {COUNT.times{ Array.new(a) }}
x.report("Array[*a]") {COUNT.times{ Array[*a] }}
x.report("a.take(a.size)") {COUNT.times{ a.take(a.size) }}
x.report("a.clone") {COUNT.times{ a.clone }}
x.report("a[0,a.size]"){COUNT.times{ a[0,a.size] }}
end
使用python中的timeit模块来测试计时。
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
我不能评论红宝石时间与python时间。 但我可以评论list与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()的内部是如何实现的。 我只是根据我所知道的规范进行猜测。
编辑 - 所以我查看了源代码（来自Martijn的一点指导）。 相关的代码在listobject.c 。 list调用list_init ，然后在799行调用listextend 。如果对象是列表或元组（第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