So Klonen Sie oder kopieren Sie eine Liste?

Felix schon eine ausgezeichnete Antwort, aber ich dachte, ich mache einen speed-Vergleich der verschiedenen Methoden:

1. 10,59 am Trockner am Trockner sec (105.9 uns/itn) - kopieren.deepcopy(old_list)
2. 10.16 Sek (101.6 uns/itn) - reines python Copy() Methode kopieren von Klassen mit deepcopy
3. 1.488 sec (14.88 kompatibler uns/itn) - reines python Copy() Methode nicht kopieren-Klassen (nur dicts/Listen/Tupel)
4. 0.325 sec (3.25 uns/itn) - for item in old_list: new_list.append(item)
5. 0.217 Sek (2.17 uns/itn) - [i for i in old_list] (a list comprehension)
6. 0.186 Sek (1.86 us/itn) - kopieren.kopieren(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 Sek (0.39 uns/itn) - old_list[:] (Liste slicing)

Also die Schnellste ist die Liste aufschneiden. Aber bewusst sein, dass copy.copy(), list[:] und list(list) im Gegensatz zu copy.deepcopy() und die python-version nicht kopieren, Listen, dictionaries und Klassen-Instanzen in der Liste, so dass, wenn sich die Originale ändern wird, ändern Sie in der kopierten Liste zu und Umgekehrt.

(Hier ist das script, wenn jemand interessiert ist oder will, Ihre möglichen Fragen:)

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

BEARBEITEN: neuen Stil, old-style-Klassen und dicts, um die benchmarks, und die python-version viel schneller und fügte einige weitere Methoden, einschließlich der Liste der Ausdrücke und extend().

InformationsquelleAutor cryo

Was sind die Optionen zum duplizieren oder kopieren Sie eine Liste, in Python?

In Python 3, eine flache Kopie gemacht werden kann, mit:

a_copy = a_list.copy()

In Python 2 und 3, können Sie eine flache Kopie mit einer vollen Scheibe des Originals:

a_copy = a_list[:]

Erklärung

Gibt es zwei semantische Möglichkeiten zum kopieren einer Liste. Eine flache Kopie erzeugt eine neue Liste mit der gleichen Objekte, die eine Tiefe Kopie erstellt eine neue Liste mit entsprechenden neuen Objekte.

Flachen Liste kopieren

Wird eine flache Kopie kopiert nur die Liste selbst, die ein container von Referenzen auf die Objekte in der Liste. Wenn die enthaltenen Objekte selbst sind veränderlich und eine geändert wird, die änderung spiegelt sich in beiden Listen.

Gibt es verschiedene Möglichkeiten, dies zu tun in Python 2 und 3. Die Python 2 Möglichkeiten, das funktioniert auch in Python 3.

Python 2

In Python 2 die idiomatische Weise, eine flache Kopie der Liste ist mit einer kompletten Scheibe das original:

a_copy = a_list[:]

Können Sie auch das gleiche erreichen, indem die Liste über die list-Konstruktor,

a_copy = list(a_list)

aber mit dem Konstruktor ist weniger effizient:

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

Python 3

In Python 3, Listen erhalten die list.copy Methode:

a_copy = a_list.copy()

In 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

Ein weiterer Zeiger ist nicht eine Kopie

Mit new_list = my_list ein, dann ändert new_list jedes mal my_list ein änderungen. Warum ist das so?

my_list ist nur ein name, die Punkte, um die aktuelle Liste im Speicher. Wenn Sie sagen new_list = my_list du bist keine Kopie, du bist einfach nur das hinzufügen eines weiteren Namen die Punkte an, die original-Liste im Speicher. Wir haben ähnliche Probleme, wenn wir Kopien von Listen.

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

Die Liste ist ein array von Zeigern auf die Inhalte, also eine flache Kopie kopiert den Zeiger, und so haben Sie zwei verschiedene Listen, aber Sie haben den gleichen Inhalt. Kopien der Inhalte, die Sie benötigen, eine Tiefe Kopie.

Tiefe Kopien

Machen Tiefe Kopie einer Liste, in Python 2 oder 3, verwenden Sie deepcopy in copy - Modul:

import copy
a_deep_copy = copy.deepcopy(a_list)

Um zu demonstrieren, wie dies ermöglicht es uns, um eine neue sub-Listen:

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

Und so sehen wir, dass die Tiefe kopiert, die Liste ist eine ganz andere Liste aus dem original. Könnten Sie Rollen Sie Ihre eigene Funktion, aber nicht. Du bist wahrscheinlich zu erstellen, die bugs, die Sie sonst nicht haben durch die Verwendung der standard-Bibliothek deepcopy-Funktion.

Nicht verwenden eval

Können Sie sehen dies als einen Weg, um deepcopy, aber tun Sie es nicht:

problematic_deep_copy = eval(repr(a_list))

1. Es ist gefährlich, vor allem, wenn Sie die Bewertung etwas aus einer Quelle, die Sie nicht Vertrauen.
2. Es ist nicht zuverlässig, wenn ein Unterelement Sie kopieren nicht eine Darstellung haben, können eval ' D zu reproduzieren, ein gleichwertiges element.
3. Es ist auch weniger performant.

In 64-bit-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

auf 64-bit-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

InformationsquelleAutor Aaron Hall

new_list = list(old_list)

InformationsquelleAutor user285176

Python-idiom dafür ist newList = oldList[:]

InformationsquelleAutor erisco

Alle anderen Mitwirkenden Gaben große Antworten, die arbeiten, wenn Sie eine einzelne dimension (nivelliert) Liste, aber von den genannten Methoden bisher nur copy.deepcopy() Werke zu Klonen/kopieren Sie eine Liste, und Sie müssen nicht zeigen, bis die geschachtelte list Objekte beim arbeiten mit mehrdimensionalen, verschachtelte Listen (Listen von Listen). Während Felix Kling bezieht sich auf Sie in seiner Antwort, es ist ein wenig mehr zu dem Problem und evtl. einen workaround mit built-ins, die beweisen könnte eine schnellere alternative zu deepcopy.

Während new_list = old_list[:], copy.copy(old_list)' und für Py3k old_list.copy() Arbeit für die einzelnen-nivelliert Listen, die Sie wiederherstellen Hinweis auf die list Objekte innerhalb der old_list und die new_list, und änderungen an einer der list Objekte sind verewigt in den anderen.

Edit: Neue Informationen ans Licht gebracht

Als wurde darauf hingewiesen, von beiden Aaron Hall und PM 2Ring mit eval() ist nicht nur eine schlechte Idee, es ist auch viel langsamer als copy.deepcopy().

Dies bedeutet, dass für die mehrdimensionale Listen, die einzige option ist copy.deepcopy(). Mit diesem wird gesagt, es ist nicht wirklich eine option, die Leistung geht Weg in den Süden, wenn Sie versuchen, es auf einen mittleren mehrdimensionales array. Ich habe versucht, zu timeit mit einem 42x42 array, nicht unerhört oder sogar, dass große für Bioinformatik-Anwendungen, und ich gab das warten auf eine Antwort und begann einfach eingeben mein edit an diesem post.

Es scheint, dass die einzige wirkliche option ist dann zu initialisieren, mehrere Listen und arbeiten diese unabhängig voneinander. Wenn jemand noch andere Vorschläge für den Umgang mit mehrdimensionale Liste kopieren, würde es geschätzt werden.

Wie andere gesagt haben, es sind erhebliche performance-Probleme mit der copy Modul und copy.deepcopy für mehrdimensionale Listen. Versucht, herauszufinden, einen anderen Weg zu kopieren, die mehrdimensionale Liste ohne Verwendung deepcopy (ich war arbeiten an einem problem, für einen Kurs, der es nur erlaubt 5 Sekunden für den gesamten Algorithmus zu laufen, um den Kredit erhalten), ich kam mit ein Weg, mit built-in-Funktionen, um eine Kopie der verschachtelten Liste die zimmerreserviereung, ohne das Sie an einem Punkt oder anderen in der list Objekte verschachtelt. Ich verwendet eval() und repr() in der Zuordnung zu machen, die Kopie der alten Liste in die neue Liste, ohne eine link zu der alten Liste. Es hat die form:

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

Während diesem wahrscheinlich nicht die kanonische oder syntaktisch korrekte Weg, es zu tun, es scheint gut zu funktionieren. Habe ich noch nicht getestet Leistung, aber ich werde zu erraten, dass eval() und rep() haben weniger overhead als deepcopy wird.

InformationsquelleAutor AMR

Python 3.6.0 Timings

Hier sind die zeitlichen Ergebnisse mit Python-3.6.0. Halten Sie im Verstand, den diese Zeiten sind relativ zu anderen, nicht absolut.

Blieb mir tun nur flache Kopien, und fügte auch einige neue Methoden, die nicht möglich ist in Python2, wie list.copy() (die Python ist3 slice entspricht) und Liste Auspacken (*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

Sehen wir die alten Gewinner kommt immer noch auf top, aber nicht wirklich eine riesige Menge, wenn man bedenkt das erhöht die Lesbarkeit der Python ist3 list.copy() Ansatz.

Beachten Sie, dass diese Methoden nicht nicht Ausgang gleichwertige Ergebnisse für jede Eingabe andere als Listen. Sie alle arbeiten für schneidbar Objekte, ein paar für jeden durchsuchbar, aber nur copy.copy() funktioniert für jedes Python-Objekt.

Hier ist der Test-code für Interessierte (Vorlage von hier):

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

InformationsquelleAutor River

Nicht sicher, ob das noch aktuelle ist, aber das gleiche Verhalten gilt auch für die Wörterbücher. Blick auf dieses Beispiel.

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

InformationsquelleAutor Bobesh

Beachten Sie, dass es einige Fälle gibt, wenn Sie Ihre eigenen benutzerdefinierten Klasse, und Sie möchten, dass die Attribute dann sollten Sie copy.copy() oder copy.deepcopy() eher als die alternativen, zum Beispiel in Python 3:

import copy

class MyList(list):
    pass

lst = MyList([1,2,3])

lst.name = 'custom list'

d = {
'original': lst,
'slicecopy' : lst[:],
'lstcopy' : lst.copy(),
'copycopy': copy.copy(lst),
'deepcopy': copy.deepcopy(lst)
}


for k,v in d.items():
    print('lst: {}'.format(k), end=', ')
    try:
        name = v.name
    except AttributeError:
        name = 'NA'
    print('name: {}'.format(name))

Ausgänge:

lst: original, name: custom list
lst: slicecopy, name: NA
lst: lstcopy, name: NA
lst: copycopy, name: custom list
lst: deepcopy, name: custom list

InformationsquelleAutor Chris_Rands

new_list = my_list[:]

new_list = my_list
Versuchen Sie zu verstehen. Lassen Sie uns sagen, dass my_list ein in den heap-Speicher an der Stelle X, d.h. my_list ein Verweis auf das X. Nun durch die Zuordnung new_list = my_list Sie Lassen new_list zeigt auf den X. Dies ist bekannt als flache Kopie.

Nun, wenn Sie zuweisen new_list = my_list[:] Du bist einfach nur kopieren jedes Objekt der my_list ein bis new_list. Dies ist bekannt als Tiefe Kopie.

Die Andere Möglichkeit, wie Sie dies tun können, sind :

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

InformationsquelleAutor Ravi Shankar

Können Sie die builtin list.copy() Methode (python 3.3+):
https://docs.python.org/3/library/copy.html
new_list = old_list.copy()

InformationsquelleAutor Brandon Bailey