In diesem Artikel erfahren Sie anhand von Beispielen, wie Sie in Python flache und tiefe Kopien erstellen.
Kopieren Sie ein Objekt in Python
In Python verwenden wir den =Operator, um eine Kopie eines Objekts zu erstellen. Sie können denken, dass dies ein neues Objekt erstellt; es tut nicht. Es wird nur eine neue Variable erstellt, die die Referenz des ursprünglichen Objekts gemeinsam nutzt.
Nehmen wir ein Beispiel, in dem wir eine Liste mit dem Namen old_list erstellen und mit dem =Operator einen Objektverweis an new_list übergeben .
Beispiel 1: Kopieren mit dem Operator =
old_list = ((1, 2, 3), (4, 5, 6), (7, 8, 'a')) new_list = old_list new_list(2)(2) = 9 print('Old List:', old_list) print('ID of Old List:', id(old_list)) print('New List:', new_list) print('ID of New List:', id(new_list))
Wenn wir das obige Programm ausführen, lautet die Ausgabe:
Alte Liste: ((1, 2, 3), (4, 5, 6), (7, 8, 9)) ID der alten Liste: 140673303268168 Neue Liste: ((1, 2, 3), (4, 5) , 6), (7, 8, 9)) ID der neuen Liste: 140673303268168
Wie Sie aus der Ausgabe sehen können, haben beide Variablen old_list und new_list dieselbe ID, d 140673303268168. H.
Wenn Sie also Werte in new_list oder old_list ändern möchten, ist die Änderung in beiden sichtbar.
Im Wesentlichen möchten Sie manchmal die ursprünglichen Werte unverändert lassen und nur die neuen Werte ändern oder umgekehrt. In Python gibt es zwei Möglichkeiten, Kopien zu erstellen:
- Flache Kopie
- Tiefe Kopie
Damit diese Kopie funktioniert, verwenden wir das copyModul.
Modul kopieren
Wir verwenden das copyPython-Modul für flache und tiefe Kopiervorgänge. Angenommen, Sie müssen die zusammengesetzte Liste kopieren, z. B. x. Beispielsweise:
import copy copy.copy (x) copy.deepcopy (x)
Hier wird copy()eine flache Kopie von x zurückgegeben. Geben Sie in ähnlicher Weise deepcopy()eine tiefe Kopie von x zurück.
Flache Kopie
Eine flache Kopie erstellt ein neues Objekt, in dem die Referenz der ursprünglichen Elemente gespeichert wird.
Eine flache Kopie erstellt also keine Kopie verschachtelter Objekte, sondern nur die Referenz verschachtelter Objekte. Dies bedeutet, dass ein Kopiervorgang keine Kopien verschachtelter Objekte selbst wiederholt oder erstellt.
Beispiel 2: Erstellen Sie eine Kopie mit einer flachen Kopie
import copy old_list = ((1, 2, 3), (4, 5, 6), (7, 8, 9)) new_list = copy.copy(old_list) print("Old list:", old_list) print("New list:", new_list)
Wenn wir das Programm ausführen, lautet die Ausgabe:
Alte Liste: ((1, 2, 3), (4, 5, 6), (7, 8, 9)) Neue Liste: ((1, 2, 3), (4, 5, 6), (7 8, 9))
Im obigen Programm haben wir eine verschachtelte Liste erstellt und diese dann mithilfe der copy()Methode flach kopiert .
Dies bedeutet, dass ein neues und unabhängiges Objekt mit demselben Inhalt erstellt wird. Um dies zu überprüfen, drucken wir sowohl die alte als auch die neue Liste.
Um zu bestätigen, dass sich new_list von old_list unterscheidet, versuchen wir, dem Original ein neues verschachteltes Objekt hinzuzufügen und es zu überprüfen.
Beispiel 3: Hinzufügen von (4, 4, 4) zu old_list mithilfe einer flachen Kopie
import copy old_list = ((1, 1, 1), (2, 2, 2), (3, 3, 3)) new_list = copy.copy(old_list) old_list.append((4, 4, 4)) print("Old list:", old_list) print("New list:", new_list)
Wenn wir das Programm ausführen, wird Folgendes ausgegeben:
Alte Liste: ((1, 1, 1), (2, 2, 2), (3, 3, 3), (4, 4, 4)) Neue Liste: ((1, 1, 1), (2 , 2, 2), (3, 3, 3))
Im obigen Programm haben wir eine flache Kopie von old_list erstellt. Die new_list enthält Verweise auf ursprünglich verschachtelte Objekte, die in old_list gespeichert sind. Dann fügen wir die neue Liste hinzu, dh (4, 4, 4)in old_list. Diese neue Unterliste wurde nicht in new_list kopiert.
Wenn Sie jedoch verschachtelte Objekte in old_list ändern, werden die Änderungen in new_list angezeigt.
Beispiel 4: Hinzufügen eines neuen verschachtelten Objekts mithilfe einer flachen Kopie
import copy old_list = ((1, 1, 1), (2, 2, 2), (3, 3, 3)) new_list = copy.copy(old_list) old_list(1)(1) = 'AA' print("Old list:", old_list) print("New list:", new_list)
Wenn wir das Programm ausführen, wird Folgendes ausgegeben:
Alte Liste: ((1, 1, 1), (2, 'AA', 2), (3, 3, 3)) Neue Liste: ((1, 1, 1), (2, 'AA', 2 ), (3, 3, 3))
Im obigen Programm haben wir Änderungen an old_list vorgenommen, d old_list(1)(1) = 'AA'. H. Beide Unterlisten von old_list und new_list at index (1)(1)wurden geändert. Dies liegt daran, dass beide Listen die Referenz derselben verschachtelten Objekte gemeinsam haben.
Tiefe Kopie
Eine tiefe Kopie erstellt ein neues Objekt und fügt rekursiv die Kopien verschachtelter Objekte hinzu, die in den ursprünglichen Elementen vorhanden sind.
Fahren wir mit Beispiel 2 fort. Wir werden jedoch eine tiefe Kopie mit der deepcopy()im copyModul vorhandenen Funktion erstellen . Die tiefe Kopie erstellt eine unabhängige Kopie des Originalobjekts und aller seiner verschachtelten Objekte.
Beispiel 5: Kopieren einer Liste mit deepcopy ()
import copy old_list = ((1, 1, 1), (2, 2, 2), (3, 3, 3)) new_list = copy.deepcopy(old_list) print("Old list:", old_list) print("New list:", new_list)
Wenn wir das Programm ausführen, wird Folgendes ausgegeben:
Alte Liste: ((1, 1, 1), (2, 2, 2), (3, 3, 3)) Neue Liste: ((1, 1, 1), (2, 2, 2), (3 , 3, 3))
Im obigen Programm verwenden wir die deepcopy()Funktion, um eine Kopie zu erstellen, die ähnlich aussieht.
Wenn Sie jedoch Änderungen an verschachtelten Objekten im ursprünglichen Objekt old_list vornehmen, werden keine Änderungen an der Kopie new_list angezeigt.
Beispiel 6: Hinzufügen eines neuen verschachtelten Objekts zur Liste mithilfe von Deep Copy
import copy old_list = ((1, 1, 1), (2, 2, 2), (3, 3, 3)) new_list = copy.deepcopy(old_list) old_list(1)(0) = 'BB' print("Old list:", old_list) print("New list:", new_list)
Wenn wir das Programm ausführen, wird Folgendes ausgegeben:
Alte Liste: ((1, 1, 1), ('BB', 2, 2), (3, 3, 3)) Neue Liste: ((1, 1, 1), (2, 2, 2), (3, 3, 3))
Wenn wir im obigen Programm old_list einen neuen Wert zuweisen, sehen wir, dass nur die old_list geändert wird. Dies bedeutet, dass sowohl die alte als auch die neue Liste unabhängig sind. Dies liegt daran, dass die old_list rekursiv kopiert wurde, was für alle verschachtelten Objekte gilt.
