Python-Dictionaries: Copy-Methode erklärt

Dieses Kapitel erklärt alle Standardmethoden zum Kopieren eines Python-Dictionaries, warum eine einfache Zuweisung (=) keine Kopie erstellt und wann eine Deep Copy anstelle einer Shallow Copy benötigt wird.

Warum ein Dictionary nicht mit = kopiert werden kann

Das Zuweisen eines Dictionaries an eine neue Variable erstellt keine Kopie — es erstellt eine zweite Referenz auf dasselbe Objekt. Jede Änderung, die über eine der beiden Variablen vorgenommen wird, betrifft dasselbe zugrunde liegende Dictionary.

original = {'a': 1, 'b': 2}
alias = original          # same object, not a copy

alias['c'] = 3
print(original)           # {'a': 1, 'b': 2, 'c': 3}  — original changed!

Um ein wirklich unabhängiges Dictionary zu erhalten, wird eine der unten gezeigten Kopiermethoden benötigt.

Shallow Copy vs. Deep Copy

Bevor die Methoden betrachtet werden, ist es hilfreich, die zwei Arten von Kopien zu verstehen:

Für flache Dictionaries (Werte sind strings, Zahlen, None, boolean) ist eine Shallow Copy immer ausreichend. Für Dictionaries, die Listen, Sets oder andere Dictionaries als Werte enthalten, sollte eine Deep Copy in Betracht gezogen werden.

Methode 1: dict.copy()

Die eingebaute Methode copy() gibt ein neues Dictionary zurück, das eine Shallow Copy des Originals ist. Sie ist die idiomatischste Wahl für flache Dictionaries.

Syntax

new_dict = original_dict.copy()

Eine Shallow Copy eines Dictionaries in Python erstellen

Das Hinzufügen oder Entfernen eines Schlüssels in new_dict lässt original_dict unberührt, da die Kopie der obersten Ebene unabhängig ist.

Schlüssel der obersten Ebene in einem kopierten Dictionary aktualisieren

Methode 2: dict()-Konstruktor

Das Übergeben eines vorhandenen Dictionaries an den dict()-Konstruktor erstellt eine Shallow Copy auf dieselbe Weise wie copy().

original_dict = {'name': 'Alice', 'age': 30}
new_dict = dict(original_dict)

new_dict['age'] = 31
print(original_dict)   # {'name': 'Alice', 'age': 30}
print(new_dict)        # {'name': 'Alice', 'age': 31}

dict() ist nützlich, wenn man explizit ein Dictionary aus einem anderen Mapping erstellen möchte oder wenn man Schlüsselwortargumente mit einem vorhandenen Dictionary kombiniert:

defaults = {'color': 'blue', 'size': 'M'}
custom = dict(defaults, size='L', weight='light')
print(custom)
# {'color': 'blue', 'size': 'L', 'weight': 'light'}

Methode 3: Dictionary-Entpackung {**d}

Der Entpackungsoperator ** fügt ein Dictionary in ein neues Dictionary-Literal ein. Für eine einfache Kopie verhält er sich identisch zu copy(), ermöglicht aber auch das Zusammenführen mehrerer Dictionaries oder das Überschreiben einzelner Schlüssel in einem einzigen Ausdruck.

original_dict = {'a': 1, 'b': 2}
new_dict = {**original_dict}

new_dict['c'] = 3
print(original_dict)   # {'a': 1, 'b': 2}
print(new_dict)        # {'a': 1, 'b': 2, 'c': 3}

Kopieren mit gleichzeitigem Überschreiben eines Schlüssels

config = {'host': 'localhost', 'port': 5432, 'debug': False}
prod_config = {**config, 'host': 'db.example.com', 'debug': False}
print(prod_config)
# {'host': 'db.example.com', 'port': 5432, 'debug': False}

Wie copy() ist dies eine Shallow Copy — verschachtelte Mutables werden weiterhin geteilt.

Shallow-Copy-Fallstrick: Verschachtelte Mutables werden geteilt

Alle drei oben genannten Methoden erzeugen Shallow Copies. Wenn ein Wert selbst ein mutablees Objekt ist (wie etwa eine Liste), halten sowohl das Original als auch die Kopie eine Referenz auf dasselbe innere Objekt.

Mutable Werte innerhalb eines kopierten Dictionaries aktualisieren

Beide Dictionaries spiegeln die Änderung wider, weil new_dict['key1'] und original_dict['key1'] auf dasselbe Listenobjekt zeigen. Dies ist das erwartete Verhalten einer Shallow Copy — es handelt sich nicht um einen Fehler.

Methode 4: copy.deepcopy() für vollständige Unabhängigkeit

Wenn vollständige Isolation benötigt wird — einschließlich verschachtelter Listen, Sets und Dictionaries — wird copy.deepcopy() aus dem Standardbibliotheksmodul copy verwendet. Es kopiert rekursiv jedes Objekt in der Struktur.

Deep Copy in Python

deepcopy() verarbeitet beliebig tief verschachtelte Strukturen und sogar selbstreferenzielle Objekte. Der Kompromiss liegt bei Geschwindigkeit und Arbeitsspeicher: Es ist langsamer als eine Shallow Copy, da der gesamte Objektgraph durchlaufen und dupliziert werden muss.

Die richtige Methode wählen

Zusammenfassung

• Der Operator = erstellt einen Alias, keine Kopie.
• dict.copy(), dict() und {**d} erzeugen alle Shallow Copies — Schlüssel der obersten Ebene sind unabhängig, aber verschachtelte Mutables werden geteilt.
• copy.deepcopy() erzeugt eine Deep Copy — jedes Objekt auf jeder Tiefe wird dupliziert.
• Für flache Dictionaries wird dict.copy() aus Gründen der Klarheit bevorzugt.
• {**d, overrides} wird verwendet, wenn in einem einzigen Ausdruck kopiert und geändert werden soll.

Siehe auch: Dictionary-Methoden · Verschachtelte Dictionaries · Dictionaries durchlaufen

Übungen