Listen kopieren

Python-Listen sind veränderbar (mutable), was bedeutet, dass das Zuweisen einer Liste an eine neue Variable keine Kopie erstellt – beide Namen verweisen auf dasselbe Objekt. Diese Seite erklärt alle zuverlässigen Methoden zum Kopieren einer Liste, den Unterschied zwischen einer flachen Kopie und einer tiefen Kopie sowie wann welcher Ansatz die richtige Wahl ist.

Die Zuweisungsfalle

Ein häufiger Fehler ist die Verwendung des Operators = in der Erwartung, eine unabhängige Kopie zu erstellen:

Warum der =-Operator keine Liste kopiert

Sowohl original als auch alias verweisen auf genau dasselbe Listenobjekt im Speicher. Jede Änderung, die über einen Namen vorgenommen wird, ist sofort über den anderen Namen sichtbar.

Um eine wirklich unabhängige Kopie zu erhalten, verwenden Sie eine der folgenden Methoden.

Methoden für flache Kopien

Eine flache Kopie erstellt ein neues Listenobjekt, aber die Elemente in der neuen Liste sind noch immer Referenzen auf dieselben Objekte wie in der Originalliste. Bei einer flachen Liste (eine Liste, die nur unveränderliche Werte wie Zahlen und Strings enthält) verhält sich eine flache Kopie wie eine vollständig unabhängige Kopie.

Verwendung der Methode copy()

Die Methode copy() ist der expliziteste und lesbarste Ansatz:

Eine Liste mit der copy()-Methode kopieren

original = ["apple", "banana", "cherry"]
copy_of = original.copy()

copy_of.append("date")
print(original)   # Output: ['apple', 'banana', 'cherry']
print(copy_of)    # Output: ['apple', 'banana', 'cherry', 'date']

Die beiden Listen sind nun unabhängig: Das Anhängen an copy_of beeinflusst original nicht.

Verwendung der Slice-Notation [:]

Die Slice-Notation ist eine pythonische Kurzschreibweise zum Kopieren der gesamten Liste:

Eine Liste mit der Slice-Notation kopieren

original = [10, 20, 30, 40]
copy_of = original[:]

copy_of[0] = 99
print(original)   # Output: [10, 20, 30, 40]
print(copy_of)    # Output: [99, 20, 30, 40]

[:] bedeutet „nimm jedes Element vom Anfang bis zum Ende", was eine neue Liste mit diesen Elementen erzeugt.

Verwendung des list()-Konstruktors

Das Übergeben einer bestehenden Liste an list() erstellt ebenfalls eine flache Kopie:

Eine Liste mit dem list()-Konstruktor kopieren

original = [1, 2, 3]
copy_of = list(original)

copy_of.append(4)
print(original)   # Output: [1, 2, 3]
print(copy_of)    # Output: [1, 2, 3, 4]

Dies ist besonders nützlich, wenn gleichzeitig ein anderes iterierbares Objekt (z. B. ein Tupel) in eine Liste umgewandelt werden soll.

Wenn flache Kopien nicht ausreichen

Eine flache Kopie kopiert nur die oberste Ebene der Struktur. Wenn die Liste veränderliche Objekte wie andere Listen oder Dictionaries enthält, werden diese verschachtelten Objekte weiterhin zwischen dem Original und der Kopie geteilt.

Flache Kopie mit einer verschachtelten Liste

Beide Listen teilen dieselben inneren Listenobjekte [1, 2] und [3, 4]. Das Ändern von original[0][0] modifiziert diese gemeinsame innere Liste, sodass die Änderung auch in shallow sichtbar ist.

Tiefe Kopie

Eine tiefe Kopie kopiert rekursiv jedes Objekt innerhalb der Liste und erzeugt eine Struktur, die vollständig unabhängig vom Original ist. Verwenden Sie copy.deepcopy() aus dem Standardbibliotheksmodul copy:

Eine verschachtelte Liste mit copy.deepcopy() tief kopieren

import copy

original = [[1, 2], [3, 4]]
deep = copy.deepcopy(original)

original[0][0] = 99       # Mutate the nested list

print(original)   # Output: [[99, 2], [3, 4]]
print(deep)       # Output: [[1, 2], [3, 4]]  <- unchanged

deep enthält eigene Kopien der inneren Listen, sodass Änderungen an original keine Auswirkungen darauf haben.

Flache Kopie vs. tiefe Kopie im Überblick

Praktische Beispiele

Alle flachen Kopiermethoden kombiniert

original = [1, 2, 3]

a = original.copy()    # method
b = original[:]        # slice
c = list(original)     # constructor

original.append(4)

print(a)  # Output: [1, 2, 3]
print(b)  # Output: [1, 2, 3]
print(c)  # Output: [1, 2, 3]

Alle drei erzeugen unabhängige Kopien – keine von ihnen spiegelt das spätere append(4) wider.

Eine Liste von Dictionaries kopieren

Dictionaries sind veränderliche Objekte. Eine flache Kopie einer Liste von Dictionaries teilt diese dict-Objekte:

import copy

records = [{"name": "Alice", "score": 90}, {"name": "Bob", "score": 85}]
shallow = records.copy()
deep    = copy.deepcopy(records)

records[0]["score"] = 0

print(shallow[0])   # Output: {'name': 'Alice', 'score': 0}   <- shared dict
print(deep[0])      # Output: {'name': 'Alice', 'score': 90}  <- independent copy

Wenn die Elemente veränderliche Objekte sind und Sie vollständige Unabhängigkeit benötigen, verwenden Sie stets deepcopy().

Fazit

Python-Listen sind veränderbar, daher erstellt der Operator = einen Alias, keine Kopie. Für flache Listen funktionieren alle flachen Kopiermethoden – copy(), [:] oder list() – gleich gut. Wenn Listen verschachtelte veränderliche Objekte enthalten, verwenden Sie copy.deepcopy(), um vollständige Unabhängigkeit zu gewährleisten.

Informationen zu verwandten Listenoperationen finden Sie unter Listenmethoden, Listenelemente hinzufügen und Listenelemente entfernen. Beim Kopieren von Dictionaries gilt dieselbe flache/tiefe Unterscheidung – siehe Dictionaries kopieren.

Übungen