Comment faire pour dupliquer ou copier une liste?

Felix déjà fourni une excellente réponse, mais je pensais faire une comparaison de la vitesse des différentes méthodes:

1. De 10,59 sec (105.9 us/itn) - copier.propriétédeepcopy(old_list)
2. 10.16 sec (101.6 us/itn) - pur python Copy() méthode de copie des classes avec propriétédeepcopy
3. 1.488 sec (14.88 us/itn) - pur python Copy() méthode ne copie pas les classes (seulement dicts/lists/n-uplets)
4. 0.325 sec (3.25 us/itn) - for item in old_list: new_list.append(item)
5. 0.217 sec (2.17 us/itn) - [i for i in old_list] (un compréhension de liste)
6. 0.186 sec (1.86 us/itn) - copier.copier(old_list)
7. 0.075 sec (0.75 us/itn) - list(old_list)
8. 0.053 sec (0.53 us/itn) - new_list = []; new_list.extend(old_list)
9. 0.039 sec (0.39 us/itn) - old_list[:] (liste de découpage)

Donc la plus rapide est la liste de découpage. Mais sachez que copy.copy(), list[:] et list(list), contrairement à copy.deepcopy() et la version de python n'avez pas de copie de toutes les listes, les dictionnaires et les instances de classe dans la liste, donc si les originaux changement, ils vont changer dans la liste copiée aussi, et vice versa.

(Voici le script si quelqu'un est intéressé ou veut soulever des questions:)

from copy import deepcopy
class old_class:
def __init__(self):
self.blah = 'blah'
class new_class(object):
def __init__(self):
self.blah = 'blah'
dignore = {str: None, unicode: None, int: None, type(None): None}
def Copy(obj, use_deepcopy=True):
t = type(obj)
if t in (list, tuple):
if t == tuple:
# Convert to a list if a tuple to 
# allow assigning to when copying
is_tuple = True
obj = list(obj)
else: 
# Otherwise just do a quick slice copy
obj = obj[:]
is_tuple = False
# Copy each item recursively
for x in xrange(len(obj)):
if type(obj[x]) in dignore:
continue
obj[x] = Copy(obj[x], use_deepcopy)
if is_tuple: 
# Convert back into a tuple again
obj = tuple(obj)
elif t == dict: 
# Use the fast shallow dict copy() method and copy any 
# values which aren't immutable (like lists, dicts etc)
obj = obj.copy()
for k in obj:
if type(obj[k]) in dignore:
continue
obj[k] = Copy(obj[k], use_deepcopy)
elif t in dignore: 
# Numeric or string/unicode? 
# It's immutable, so ignore it!
pass 
elif use_deepcopy: 
obj = deepcopy(obj)
return obj
if __name__ == '__main__':
import copy
from time import time
num_times = 100000
L = [None, 'blah', 1, 543.4532, 
['foo'], ('bar',), {'blah': 'blah'},
old_class(), new_class()]
t = time()
for i in xrange(num_times):
Copy(L)
print 'Custom Copy:', time()-t
t = time()
for i in xrange(num_times):
Copy(L, use_deepcopy=False)
print 'Custom Copy Only Copying Lists/Tuples/Dicts (no classes):', time()-t
t = time()
for i in xrange(num_times):
copy.copy(L)
print 'copy.copy:', time()-t
t = time()
for i in xrange(num_times):
copy.deepcopy(L)
print 'copy.deepcopy:', time()-t
t = time()
for i in xrange(num_times):
L[:]
print 'list slicing [:]:', time()-t
t = time()
for i in xrange(num_times):
list(L)
print 'list(L):', time()-t
t = time()
for i in xrange(num_times):
[i for i in L]
print 'list expression(L):', time()-t
t = time()
for i in xrange(num_times):
a = []
a.extend(L)
print 'list extend:', time()-t
t = time()
for i in xrange(num_times):
a = []
for y in L:
a.append(y)
print 'list append:', time()-t
t = time()
for i in xrange(num_times):
a = []
a.extend(i for i in L)
print 'generator expression extend:', time()-t

MODIFIER: Ajout de nouvelles de style à l'ancienne, des classes de style et dicts les benchmarks, et fait de la version de python beaucoup plus rapide et ajouté un peu plus de méthodes, y compris la liste d'expressions et de extend().

OriginalL'auteur cryo

Quelles sont les options pour dupliquer ou copier une liste en Python?

En Python 3, une copie peut être faite avec:

a_copy = a_list.copy()

En Python 2 et 3, vous pouvez obtenir une copie superficielle avec un tranche de l'original:

a_copy = a_list[:]

Explication

Il y a deux sémantique manières de copier une liste. Une copie crée une nouvelle liste des objets de même, une copie en profondeur crée une nouvelle liste contenant les nouvelles équivalent objets.

Peu profonde de la liste de copie

D'une copie des copies de la liste elle-même, qui est un conteneur de références aux objets dans la liste. Si les objets contenus eux-mêmes sont mutables et est changée, le changement pourra être répercuté dans les deux listes.

Il y a différentes façons de le faire en Python 2 et 3. Le Python 2 façons travaillera également en Python 3.

Python 2

En Python 2, le idiomatiques façon de faire une copie de la liste avec une tranche de l'original:

a_copy = a_list[:]

Vous pouvez également faire la même chose en passant par la liste par le biais de la liste de constructeur,

a_copy = list(a_list)

mais en utilisant le constructeur est de moins en moins efficace:

>>> timeit
>>> l = range(20)
>>> min(timeit.repeat(lambda: l[:]))
0.30504298210144043
>>> min(timeit.repeat(lambda: list(l)))
0.40698814392089844

Python 3

En Python 3, les listes d'obtenir le list.copy méthode:

a_copy = a_list.copy()

En Python 3.5:

>>> import timeit
>>> l = list(range(20))
>>> min(timeit.repeat(lambda: l[:]))
0.38448613602668047
>>> min(timeit.repeat(lambda: list(l)))
0.6309100328944623
>>> min(timeit.repeat(lambda: l.copy()))
0.38122922903858125

De faire un autre pointeur ne pas faire une copie

À l'aide de new_list = my_list modifie new_list chaque fois my_list changements. Pourquoi est-ce?

my_list est juste un nom qui points à la liste actuelle dans la mémoire. Quand vous dites new_list = my_list vous n'êtes pas en faire une copie, vous êtes juste ajouter un autre nom à cette liste d'origine dans la mémoire. Nous pouvons avoir des problèmes similaires lorsque nous faisons des copies de listes.

>>> l = [[], [], []]
>>> l_copy = l[:]
>>> l_copy
[[], [], []]
>>> l_copy[0].append('foo')
>>> l_copy
[['foo'], [], []]
>>> l
[['foo'], [], []]

La liste est juste un tableau de pointeurs vers du contenu, donc d'une copie simple copie seulement les pointeurs, et vous avez donc deux listes différentes, mais elles ont le même contenu. Faire des copies du contenu, vous avez besoin d'une copie en profondeur.

Profonde des copies

De faire un copie d'une liste en Python 2 ou 3, utilisez propriétédeepcopy dans le copier module:

import copy
a_deep_copy = copy.deepcopy(a_list)

Pour montrer comment cela nous permet de faire de nouveaux sous-listes:

>>> import copy
>>> l
[['foo'], [], []]
>>> l_deep_copy = copy.deepcopy(l)
>>> l_deep_copy[0].pop()
'foo'
>>> l_deep_copy
[[], [], []]
>>> l
[['foo'], [], []]

Et nous voyons donc que la profondeur copié liste est une liste différente de l'original. Vous pourriez rouler votre propre fonction, mais n'en ont pas. Vous êtes susceptibles de créer des bugs que vous n'avez pas normalement à l'aide de la bibliothèque standard du propriétédeepcopy fonction.

Ne pas utiliser eval

Vous pouvez voir ce utilisé comme un moyen de propriétédeepcopy, mais ne le faites pas:

problematic_deep_copy = eval(repr(a_list))

1. C'est dangereux, surtout si vous êtes à l'évaluation de quelque chose à partir d'une source vous n'avez pas confiance.
2. Ce n'est pas fiable, si un sous-élément que vous êtes la copie n'a pas une représentation qui peut être eval pour reproduire un élément équivalent.
3. Il est également moins performant.

En 64 bits Python 2.7:

>>> import timeit
>>> import copy
>>> l = range(10)
>>> min(timeit.repeat(lambda: copy.deepcopy(l)))
27.55826997756958
>>> min(timeit.repeat(lambda: eval(repr(l))))
29.04534101486206

sur 64 bits Python 3.5:

>>> import timeit
>>> import copy
>>> l = list(range(10))
>>> min(timeit.repeat(lambda: copy.deepcopy(l)))
16.84255409205798
>>> min(timeit.repeat(lambda: eval(repr(l))))
34.813894678023644

OriginalL'auteur Aaron Hall

new_list = list(old_list)

OriginalL'auteur user285176

Python est un langage pour le faire, c'est newList = oldList[:]

OriginalL'auteur erisco

Tous les autres contributeurs ont donné grande réponses, qui travail lorsque vous avez une seule dimension (stabilisé) liste des méthodes mentionnées jusqu'à présent, seuls copy.deepcopy() œuvres de clone/copie d'une liste et de ne pas pointer vers le imbriquée list objets lorsque vous travaillez avec des dimensions, des listes imbriquées (liste de listes). Alors que Felix Kling y fait référence dans sa réponse, il y a un peu plus de la question et, éventuellement, une solution de contournement avec built-ins qui pourrait s'avérer une alternative plus rapide à deepcopy.

Tout new_list = old_list[:], copy.copy(old_list)' et pour Py3k old_list.copy() de travail pour un seul niveau de listes, ils reviennent à pointer à la list objets imbriqués dans la old_list et la new_list, et des modifications à la list objets sont perpétués dans les autres.

Edit: de Nouvelles informations portées à la lumière de

Comme l'a souligné à la fois Aaron Hall et PM 2Ring à l'aide de eval() n'est pas seulement une mauvaise idée, il est aussi beaucoup plus lent que copy.deepcopy().

Cela signifie que pour multidimensionnelle des listes, la seule option est copy.deepcopy(). Avec cela étant dit, ce n'est vraiment pas une option que la performance va vers le sud quand vous essayez de l'utiliser sur un de taille moyenne tableau multidimensionnel. J'ai essayé de timeit à l'aide d'un 42x42 tableau, pas rare de voire que les grands pour les applications de la bioinformatique, et j'ai renoncé à attendre une réponse et juste commencé à taper mon edit de ce post.

Il semblerait que la seule véritable option est d'initialiser plusieurs listes et de les travailler de manière indépendante. Si quelqu'un a d'autres suggestions, pour savoir comment gérer multidimensionnelle de la liste de copie, il serait apprécié.

Comme d'autres l'ont dit, il n'y sont importants des problèmes de performances à l'aide de la copy module et copy.deepcopy pour multidimensionnelle des listes. en Essayant de travailler avec une façon différente de la copie de la multidimensionnel de la liste sans l'aide de deepcopy, (je travaillais sur un problème pour un cours qui ne permet que 5 secondes pour l'ensemble de l'algorithme à exécuter afin de recevoir un crédit), j'ai trouvé un moyen d'utiliser les fonctions intégrées de faire une copie de la liste imbriquée sans les avoir point à un autre ou à l' list objets imbriqués à l'intérieur d'eux. J'ai utilisé eval() et repr() dans l'attribution à faire de la copie de l'ancienne liste dans la nouvelle liste sans la création d'un lien avec l'ancienne liste. Elle prend la forme de:

new_list = eval(repr(old_list))

old_list = [[0 for j in range(y)] for i in range(x)] # initialize (x,y) nested list
# assign a copy of old_list to new list without them pointing to the same list object
new_list = eval(repr(old_list)) 
# make a change to new_list 
for j in range(y):
for i in range(x):
new_list[i][j] += 1

>>> new_list
[[1, 1, 1], [1, 1, 1], [1, 1, 1], [1, 1, 1]]
>>> old_list
[[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]

Alors que ce n'est probablement pas le canoniques ou syntaxiquement correct de le faire, il semble bien fonctionner. Je n'ai pas testé les performances, mais je vais deviner que eval() et rep() aura moins de frais généraux que les deepcopy volonté.

OriginalL'auteur AMR

Python 3.6.0 Timings

Voici les résultats du réglage à l'aide de Python 3.6.0. Gardez à l'esprit ces temps sont relatifs l'un à l'autre, et non pas absolue.

J'ai collé à ne faire que peu profonde exemplaires, et a également ajouté quelques nouvelles méthodes qui n'étaient pas possibles en Python2, comme list.copy() (Python3 tranche équivalent) et liste déballage (*new_list, = list):

METHOD                  TIME TAKEN
b = a[:]                6.468942025996512   #Python2 winner
b = a.copy()            6.986593422974693   #Python3 "slice equivalent"
b = []; b.extend(a)     7.309216841997113
b = a[0:len(a)]         10.916740721993847
*b, = a                 11.046738261007704
b = list(a)             11.761539687984623
b = [i for i in a]      24.66165203397395
b = copy.copy(a)        30.853400873980718
b = []
for item in a:
b.append(item)        48.19176080400939

On peut voir l'ancien vainqueur sort toujours sur le dessus, mais pas vraiment par une quantité énorme, compte tenu de l'augmentation de la lisibilité de la Python3 list.copy() approche.

Noter que ces méthodes ne pas de sortie des résultats équivalents pour toute entrée autres que les listes. Ils travaillent tous pour peut être tranché objets, un peu de travail pour n'importe quel itérable, mais seulement copy.copy() fonctionne pour n'importe quel objet Python.

Voici le code de test pour les parties intéressées (Modèle à partir d'ici):

import timeit
COUNT = 50000000
print("Array duplicating. Tests run", COUNT, "times")
setup = 'a = [0,1,2,3,4,5,6,7,8,9]; import copy'
print("b = list(a)\t\t", timeit.timeit(stmt='b = list(a)', setup=setup, number=COUNT))
print("b = copy.copy(a)\t\t", timeit.timeit(stmt='b = copy.copy(a)', setup=setup, number=COUNT))
print("b = a.copy()\t\t", timeit.timeit(stmt='b = a.copy()', setup=setup, number=COUNT))
print("b = a[:]\t\t", timeit.timeit(stmt='b = a[:]', setup=setup, number=COUNT))
print("b = a[0:len(a)]\t", timeit.timeit(stmt='b = a[0:len(a)]', setup=setup, number=COUNT))
print("*b, = a\t", timeit.timeit(stmt='*b, = a', setup=setup, number=COUNT))
print("b = []; b.extend(a)\t", timeit.timeit(stmt='b = []; b.extend(a)', setup=setup, number=COUNT))
print("b = []\nfor item in a: b.append(item)\t", timeit.timeit(stmt='b = []\nfor item in a:  b.append(item)', setup=setup, number=COUNT))
print("b = [i for i in a]\t", timeit.timeit(stmt='b = [i for i in a]', setup=setup, number=COUNT))

OriginalL'auteur River

Ne sais pas si c'est toujours d'actualité, mais le même comportement est pour les dictionnaires. Regardez cet exemple.

a = {'par' : [1,21,3], 'sar' : [5,6,8]}
b = a
c = a.copy()
a['har'] = [1,2,3]
a
Out[14]: {'har': [1, 2, 3], 'par': [1, 21, 3], 'sar': [5, 6, 8]}
b
Out[15]: {'har': [1, 2, 3], 'par': [1, 21, 3], 'sar': [5, 6, 8]}
c
Out[16]: {'par': [1, 21, 3], 'sar': [5, 6, 8]}

OriginalL'auteur Bobesh

Une approche très simple indépendant de la version de python manquait déjà donné les réponses que vous pouvez utiliser la plupart du temps (au moins je le fais):

new_list = my_list * 1       #Solution 1 when you are not using nested lists

Toutefois, Si my_list contient d'autres conteneurs (pour exemple. listes imbriquées), vous devez utiliser la propriétédeepcopy que d'autres ont suggéré dans les réponses ci-dessus à partir de la copie de la bibliothèque. Par exemple:

import copy
new_list = copy.deepcopy(my_list)   #Solution 2 when you are using nested lists

.Bonus: Si vous ne voulez pas copier des éléments d'utilisation (aka shallow copy):

new_list = my_list[:]

Nous allons comprendre la différence entre la Solution n ° 1 et la Solution #2

>>> 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 Solution n ° 1 a parfaitement fonctionné, quand nous n'étions pas à l'aide de la listes imbriquées. Nous allons vérifier ce qui se passera quand nous appliquer la solution n ° 1 pour des listes imbriquées.

>>> from copy import deepcopy
>>> a = [range(i,i+4) for i in range(3)]
>>> a
[[0, 1, 2, 3], [1, 2, 3, 4], [2, 3, 4, 5]]
>>> b = a*1
>>> c = deepcopy(a)
>>> for i in (a, b, c): print i   
[[0, 1, 2, 3], [1, 2, 3, 4], [2, 3, 4, 5]]
[[0, 1, 2, 3], [1, 2, 3, 4], [2, 3, 4, 5]]
[[0, 1, 2, 3], [1, 2, 3, 4], [2, 3, 4, 5]]
>>> a[2].append('99')
>>> for i in (a, b, c): print i   
[[0, 1, 2, 3], [1, 2, 3, 4], [2, 3, 4, 5, 99]]
[[0, 1, 2, 3], [1, 2, 3, 4], [2, 3, 4, 5, 99]]   #Solution#1 didn't work in nested list
[[0, 1, 2, 3], [1, 2, 3, 4], [2, 3, 4, 5]]       #Solution #2 - DeepCopy worked in nested list

OriginalL'auteur jainashish

new_list = my_list[:]

new_list = my_list
Essayer de comprendre cela. Disons que my_list est dans le segment de mémoire à l'emplacement X c'est à dire my_list pointe sur le symbole X. Maintenant, en attribuant new_list = my_list vous êtes Laissant new_list pointant vers le X. Ceci est connu comme la Copie superficielle.

Maintenant, si vous affectez new_list = my_list[:] Vous êtes tout simplement la copie de chaque objet de my_list à new_list. Ceci est connu en tant que copie en Profondeur.

L'Autre manière que vous pouvez faire sont les suivantes :

• new_list = list(old_list)
• import copy
new_list = copy.deepcopy(old_list)

OriginalL'auteur Ravi Shankar

Vous pouvez utiliser la builtin list.copy() méthode (python 3.3 et+):
https://docs.python.org/3/library/copy.html
new_list = old_list.copier()

OriginalL'auteur Brandon Bailey