¿Cuál es la mejor manera de copiar una lista?

¿Cuál es la mejor manera de copiar una lista? Conozco las siguientes formas, ¿cuál es mejor? ¿O hay otra manera?

lst = ['one', 2, 3] lst1 = list(lst) lst2 = lst[:] import copy lst3 = copy.copy(lst) 

Si desea una copia superficial (los elementos no se copian) utilice:

 lst2=lst1[:] 

Si desea hacer una copia en profundidad, utilice el módulo de copia:

 import copy lst2=copy.deepcopy(lst1) 

A menudo uso:

 lst2 = lst1 * 1 

Si lst1 contiene otros contenedores (como otras listas), debe usar deepcopy de la copia lib como se muestra por Mark.


ACTUALIZACIÓN: Explicando deepcopy

 >>> a = range(5) >>> b = a*1 >>> a,b ([0, 1, 2, 3, 4], [0, 1, 2, 3, 4]) >>> a[2] = 55 >>> a,b ([0, 1, 55, 3, 4], [0, 1, 2, 3, 4]) 

Como puede ver solo un cambio … Intentaré ahora con una lista de listas

 >>> >>> a = [range(i,i+3) for i in range(3)] >>> a [[0, 1, 2], [1, 2, 3], [2, 3, 4]] >>> b = a*1 >>> a,b ([[0, 1, 2], [1, 2, 3], [2, 3, 4]], [[0, 1, 2], [1, 2, 3], [2, 3, 4]]) 

No es tan legible, déjame imprimirlo con un for:

 >>> for i in (a,b): print i [[0, 1, 2], [1, 2, 3], [2, 3, 4]] [[0, 1, 2], [1, 2, 3], [2, 3, 4]] >>> a[1].append('appended') >>> for i in (a,b): print i [[0, 1, 2], [1, 2, 3, 'appended'], [2, 3, 4]] [[0, 1, 2], [1, 2, 3, 'appended'], [2, 3, 4]] 

¿Ves eso? También se adjunta a la b [1], por lo que b [1] y a [1] son ​​el mismo objeto. Ahora pruébalo con copia profunda.

 >>> from copy import deepcopy >>> b = deepcopy(a) >>> a[0].append('again...') >>> for i in (a,b): print i [[0, 1, 2, 'again...'], [1, 2, 3, 'appended'], [2, 3, 4]] [[0, 1, 2], [1, 2, 3, 'appended'], [2, 3, 4]] 

También puedes hacer:

 a = [1, 2, 3] b = list(a) 

Me gusta hacer:

 lst2 = list(lst1) 

La ventaja sobre lst1 [:] es que el mismo idioma funciona para los dictados:

 dct2 = dict(dct1) 

Listas cortas, [:] es la mejor:

 In [1]: l = range(10) In [2]: %timeit list(l) 1000000 loops, best of 3: 477 ns per loop In [3]: %timeit l[:] 1000000 loops, best of 3: 236 ns per loop In [6]: %timeit copy(l) 1000000 loops, best of 3: 1.43 us per loop 

Para listas más grandes, todos son casi iguales:

 In [7]: l = range(50000) In [8]: %timeit list(l) 1000 loops, best of 3: 261 us per loop In [9]: %timeit l[:] 1000 loops, best of 3: 261 us per loop In [10]: %timeit copy(l) 1000 loops, best of 3: 248 us per loop 

Para listas muy grandes (probé 50MM), siguen siendo casi iguales.

También puedes hacer esto:

 import copy list2 = copy.copy(list1) 

Esto debería hacer lo mismo que la copia superficial de Mark Roddy.

En términos de rendimiento, hay una sobrecarga en la list() llamadas list() comparación con la división. Así que para las listas cortas, lst2 = lst1[:] es aproximadamente el doble de rápido que lst2 = list(lst1) .

En la mayoría de los casos, es probable que esto se vea superado por el hecho de que list() es más legible, pero en ciclos cerrados, esta puede ser una optimización valiosa.