Quel est le meilleur moyen de copier une liste?

Question

Quelle est la meilleure façon de copier une liste? Je connais les moyens suivants, lequel est le meilleur? Ou y a-t-il un autre moyen?

lst = ['one', 2, 3] 

lst1 = list(lst) 

lst2 = lst[:] 

import copy 
lst3 = copy.copy(lst) 

Answer 1

Si vous voulez une copie superficielle (éléments ne sont pas copiés) utilisent:

lst2=lst1[:] 

Si vous souhaitez effectuer une copie en profondeur puis utilisez le module de copie:

import copy 
lst2=copy.deepcopy(lst1) 

Answer 2

J'utilise souvent:

lst2 = lst1 * 1 

Si lst1 il contient d'autres conteneurs (comme les autres listes), vous devriez utiliser deepcopy de la bibliothèque de copie comme indiqué par Mark.

---

MISE À JOUR: Expliquer 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]) 

Comme vous pouvez le voir seulement changé ... Je vais essayer maintenant avec une liste de listes

>>> 
>>> 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]]) 

Pas si facile à lire, permettez-moi de l'imprimer avec un pour:

>>> 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]] 

Vous voyez ça? Il est aussi ajouté à b [1], donc b [1] et a [1] sont exactement le même objet. Maintenant, essayez avec deepcopy

>>> 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]] 

Answer 3

Vous pouvez aussi le faire:

import copy 
list2 = copy.copy(list1) 

Cela devrait faire la même chose que copie superficielle de Mark Roddy.

Answer 4

Vous pouvez également faire:

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

Answer 5

J'aime faire:

lst2 = list(lst1) 

L'avantage par rapport lst1 [:] est que le même fonctionne idiome pour dicts:

dct2 = dict(dct1) 

Answer 6

En termes de performances, il y a une surcharge pour appeler list() par rapport à la découpe. Donc, pour les listes courtes, lst2 = lst1[:] est environ deux fois plus rapide que lst2 = list(lst1).

Dans la plupart des cas, cela est probablement compensé par le fait que list() est plus lisible, mais dans les boucles serrées ceci peut être une optimisation valable.

Answer 7

listes courtes, [:] est le meilleur:

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 

Pour les listes plus grandes, ils sont tous sur le même:

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 

Pour les listes très grandes (j'ai essayé 50MM), ils sont toujours à peu près les mêmes.