{"id":3112,"date":"2025-09-21T07:37:40","date_gmt":"2025-09-21T05:37:40","guid":{"rendered":"https:\/\/davidka.net\/ru\/?p=3112"},"modified":"2025-09-22T04:04:27","modified_gmt":"2025-09-22T02:04:27","slug":"copying-objects-in-python","status":"publish","type":"post","link":"https:\/\/de.davidka.net\/de\/2025\/09\/21\/copying-objects-in-python\/","title":{"rendered":"Eine vollst\u00e4ndige Anleitung zum Kopieren von Objekten in Python"},"content":{"rendered":"\n

Das Kopieren von Objekten ist ein grundlegendes Konzept in Python, dessen Missverst\u00e4ndnis oft zu schwer auffindbaren Fehlern f\u00fchrt. Wenn Sie ein Objekt \u00e4ndern und sich unerwartet ein anderes ebenfalls \u00e4ndert, liegt das Problem h\u00f6chstwahrscheinlich in der Art und Weise, wie es kopiert wurde. Lassen Sie uns dieses Thema ein f\u00fcr alle Mal kl\u00e4ren.<\/p>\n\n\n\n

\ud83d\udd0e Warum ist das Kopieren von Objekten \u00fcberhaupt wichtig?<\/strong><\/h4>\n\n\n\n

In Python sind Variablen keine „Boxen“, die Daten enthalten, sondern eher „Etiketten“ oder Referenzen (Verweise), die auf Objekte im Speicher zeigen. Wenn Sie eine einfache Zuweisung durchf\u00fchren, wie hier:<\/p>\n\n\n\n

liste_a = [1, 2, 3]\nliste_b = liste_a<\/code><\/pre>\n\n\n\n
Erstellen Sie keine neue Liste. Sie erstellen lediglich eine weitere Referenz (liste_b<\/code>), die auf genau dasselbe Listenobjekt zeigt.<\/p>\n\n\n\n
\ud83d\udc49 Jede \u00c4nderung an liste_a<\/code> spiegelt sich sofort in liste_b<\/code> wider (und umgekehrt), weil es sich um dasselbe Objekt handelt.<\/strong><\/p>\n\n\n\n
Analogie:<\/strong> Stellen Sie sich vor, Sie haben ein Google-Dokument. Wenn Sie einem Freund einen Link dazu senden, wird er Ihr Originaldokument bearbeiten. Das ist eine Zuweisung. Wenn Sie jedoch „Datei“ \u2192 „Kopie erstellen“ w\u00e4hlen, wird ein v\u00f6llig unabh\u00e4ngiges Dokument erstellt. Das copy<\/code>-Modul in Python existiert genau daf\u00fcr, um solche unabh\u00e4ngigen Kopien zu erstellen.<\/p>\n\n\n\n
\u2699\ufe0f Zwei Arten des Kopierens<\/strong><\/h4>\n\n\n\n
Das copy<\/code>-Modul stellt zwei Schl\u00fcsselfunktionen zur Verf\u00fcgung:<\/p>\n\n\n\n
    \n
  • copy.copy()<\/code> \u2014 erstellt eine oberfl\u00e4chliche Kopie<\/strong> (shallow copy).<\/li>\n\n\n\n
  • copy.deepcopy()<\/code> \u2014 erstellt eine tiefe Kopie<\/strong> (deep copy).<\/li>\n<\/ul>\n\n\n\n
    Der Hauptunterschied zwischen ihnen liegt darin, wie sie mit verschachtelten Objekten umgehen (wie Listen in Listen oder Dictionaries in Dictionaries).<\/p>\n\n\n\n
    \n\n\n\n
    \ud83d\udfe6 Oberfl\u00e4chliche Kopie (copy.copy()<\/code>)<\/strong><\/h4>\n\n\n\n
    copy.copy()<\/code> erstellt ein neues Container-Objekt auf der obersten Ebene, aber anstatt die verschachtelten Objekte zu kopieren, f\u00fcgt es nur Referenzen auf die Originalobjekte in den neuen Container ein.<\/p>\n\n\n\n
    import copy\n\noriginal_liste = [1, 2, [3, 4]]\nflache_kopie = copy.copy(original_liste)\n\n# \u00c4ndern der verschachtelten Liste im Original\noriginal_liste[2][0] = 99\n\nprint(f"Original: {original_liste}")    # Ausgabe: Original: [1, 2, [99, 4]]\nprint(f"Flache Kopie: {flache_kopie}") # Ausgabe: Flache Kopie: [1, 2, [99, 4]]<\/code><\/pre>\n\n\n\n
    Wie Sie sehen, hat die \u00c4nderung der verschachtelten Liste sowohl das Original als auch die Kopie beeinflusst, da sie sich diese verschachtelte Liste teilen.<\/p>\n\n\n\n
    ASCII-Diagramm:<\/strong><\/p>\n\n\n\n
    original_liste \u2192 [ 1, 2, \u2500\u2500\u2500\u25ba innere_liste ]\nflache_kopie   \u2192 [ 1, 2, \u2500\u2500\u2500\u25ba innere_liste ]\n                             innere_liste   \u2192 [ 99, 4 ]<\/code><\/pre>\n\n\n\n
    \n\n\n\n
    \ud83d\udfe9 Tiefe Kopie (copy.deepcopy()<\/code>)<\/strong><\/h4>\n\n\n\n
    copy.deepcopy()<\/code> l\u00f6st das Problem der geteilten Referenzen. Diese Funktion durchl\u00e4uft rekursiv das gesamte Objekt und erstellt vollst\u00e4ndige, unabh\u00e4ngige Kopien von allem, was sie findet, einschlie\u00dflich aller verschachtelten Objekte.<\/p>\n\n\n\n
    import copy\n\noriginal_liste = [1, 2, [3, 4]]\ntiefe_kopie = copy.deepcopy(original_liste)\n\n# \u00c4ndern der verschachtelten Liste im Original\noriginal_liste[2][0] = 99\n\nprint(f"Original: {original_liste}") # Ausgabe: Original: [1, 2, [99, 4]]\nprint(f"Tiefe Kopie: {tiefe_kopie}")     # Ausgabe: Tiefe Kopie: [1, 2, [3, 4]]<\/code><\/pre>\n\n\n\n
    Jetzt ist die tiefe_kopie<\/code> vollst\u00e4ndig unabh\u00e4ngig.<\/p>\n\n\n\n
    ASCII-Diagramm:<\/strong><\/p>\n\n\n\n
    original_liste \u2192 [ 1, 2, \u2500\u2500\u2500\u25ba liste_a ]\ntiefe_kopie    \u2192 [ 1, 2, \u2500\u2500\u2500\u25ba liste_b ]\n                            liste_a   \u2192 [ 99, 4 ]\n                            liste_b   \u2192 [ 3, 4 ]<\/code><\/pre>\n\n\n\n
    \n\n\n\n
    \ud83d\udcd1 Spickzettel: copy.copy()<\/code> vs. copy.deepcopy()<\/code><\/strong><\/h4>\n\n\n\n
    Objekttyp<\/th>Beispiel<\/th>copy.copy()<\/code> (oberfl\u00e4chlich)<\/th>copy.deepcopy()<\/code> (tief)<\/th><\/tr><\/thead>
    list<\/strong> (Liste)<\/td>[1, 2, [3, 4]]<\/code><\/td>Neue Liste, aber die verschachtelte Liste [3, 4]<\/code> ist geteilt<\/strong><\/td>Eine vollst\u00e4ndig unabh\u00e4ngige Kopie; die verschachtelte Liste wird ebenfalls kopiert<\/td><\/tr>
    dict<\/strong> (Dictionary)<\/td>{"a": 1, "b": {"c": 2}}<\/code><\/td>Neues Dictionary, aber das verschachtelte {"c": 2}<\/code> ist geteilt<\/strong><\/td>Ein unabh\u00e4ngiges Dictionary und alle verschachtelten Dictionaries<\/td><\/tr>
    set<\/strong> (Menge)<\/td>{1, 2, (3, 4)}<\/code><\/td>Neue Menge; verschachtelte ver\u00e4nderbare Elemente w\u00e4ren geteilt<\/strong><\/td>Neue Menge; alle verschachtelten Elemente werden rekursiv kopiert<\/td><\/tr>
    tuple<\/strong> (Tupel)<\/td>(1, 2, [3, 4])<\/code><\/td>Gibt dasselbe Tupel zur\u00fcck, aber die verschachtelte Liste ist geteilt<\/strong><\/td>Ein neues Tupel mit einer Kopie<\/strong> der verschachtelten Liste<\/td><\/tr>
    str, int, float, bool<\/strong><\/td>"hallo"<\/code>, 42<\/code>, 3.14<\/code>, True<\/code><\/td>Gibt dasselbe Objekt zur\u00fcck (sie sind unver\u00e4nderlich, Kopieren ist unn\u00f6tig)<\/td>Dasselbe wie bei der oberfl\u00e4chlichen Kopie<\/td><\/tr>
    Benutzerdefinierte Klasse<\/strong><\/td>Knoten(1, Knoten(2))<\/code><\/td>Neues Objekt auf oberster Ebene; verschachtelte Objekte sind geteilt<\/strong><\/td>Eine vollst\u00e4ndig unabh\u00e4ngige Kopie des Objekts und aller verschachtelten Objekte<\/td><\/tr>
    Objekt mit __slots__<\/code><\/strong><\/td>Eine Klasse mit __slots__<\/code><\/td>Nur das Objekt der obersten Ebene wird kopiert<\/td>Alle verschachtelten Objekte werden kopiert, wenn sie das Kopieren unterst\u00fctzen<\/td><\/tr>
    Datei \/ Socket \/ Stream<\/strong><\/td>open("datei.txt")<\/code><\/td>Fehler<\/strong> (nicht kopierbares Objekt)<\/td>Fehler<\/strong> (nicht kopierbares Objekt)<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
    \n\n\n\n
    \ud83e\uddea Live-Beispiele zur Tabelle<\/strong><\/h4>\n\n\n\n
    \ud83d\udccc list<\/strong><\/p>\n\n\n\n
    import copy\na = [1, 2, [3, 4]]\nb = copy.copy(a)\nc = copy.deepcopy(a)\na[2][0] = 99\nprint(f"copy: {b}")      # [1, 2, [99, 4]]\nprint(f"deepcopy: {c}")  # [1, 2, [3, 4]]<\/code><\/pre>\n\n\n\n
    \ud83d\udccc dict<\/strong><\/p>\n\n\n\n
    import copy\na = {"a": 1, "b": {"c": 2}}\nb = copy.copy(a)\nc = copy.deepcopy(a)\na["b"]["c"] = 42\nprint(f"copy: {b}")      # {'a': 1, 'b': {'c': 42}}\nprint(f"deepcopy: {c}")  # {'a': 1, 'b': {'c': 2}}<\/code><\/pre>\n\n\n\n
    \ud83d\udccc set<\/strong><\/p>\n\n\n\n
    import copy\na = {1, 2, (3, 4)} # Mengen k\u00f6nnen nur unver\u00e4nderliche Typen enthalten\nb = copy.copy(a)\nc = copy.deepcopy(a)\nprint(b == c) # True (aber es sind zwei unabh\u00e4ngige Objekte im Speicher)<\/code><\/pre>\n\n\n\n
    \ud83d\udccc tuple<\/strong><\/p>\n\n\n\n
    \nimport copy\na = (1, 2, [3, 4]) # Das Tupel ist unver\u00e4nderlich, sein Listenelement jedoch nicht\nb = copy.copy(a)\nc = copy.deepcopy(a)\na[2][0] = 99\nprint(f"copy: {b}") # (1, 2, [99, 4])\nprint(f"deepcopy: {c}") # (1, 2, [3, 4])<\/code><\/pre>\n\n\n\n
    \ud83d\udccc Benutzerdefinierte Klasse<\/strong><\/p>\n\n\n\n
    \nimport copy\nclass Knoten:\ndef <strong>init<\/strong>(self, wert, kind=None):\nself.wert = wert\nself.kind = kind\na = Knoten(1, Knoten(2))\nb = copy.copy(a)\nc = copy.deepcopy(a)\na.kind.wert = 99\nprint(f"copy: {b.kind.wert}") # 99\nprint(f"deepcopy: {c.kind.wert}") # 2<\/code><\/pre>\n\n\n\n
    <\/p>\n\n\n\n

    \ud83d\udccc Anpassen des Verhaltens: `__copy__` und `__deepcopy__`<\/strong>
    Sie k\u00f6nnen steuern, wie Ihre eigenen Objekte kopiert werden, indem Sie spezielle Methoden in ihrer Klasse definieren.<\/p>\n\n\n\n
    \nimport copy\nclass EigeneKlasse:\ndef <strong>init<\/strong>(self, x):\nself.x = x\ndef <strong>copy<\/strong>(self):\nprint("Aufruf von <strong>copy<\/strong>!")\n# Gibt eine neue Instanz zur\u00fcck, aber mit derselben Referenz auf interne Daten\nreturn EigeneKlasse(self.x)\ndef <strong>deepcopy<\/strong>(self, memo):\n# memo ist ein Dictionary, um bereits kopierte Objekte zu verfolgen (verhindert Rekursion)\nprint("Aufruf von <strong>deepcopy<\/strong>!")\n# Erstellt eine komplett neue Kopie, einschlie\u00dflich der verschachtelten Daten\nreturn EigeneKlasse(copy.deepcopy(self.x, memo))\nobj = EigeneKlasse([1, 2])\nc1 = copy.copy(obj) # Ausgabe: Aufruf von <strong>copy<\/strong>!\nc2 = copy.deepcopy(obj) # Ausgabe: Aufruf von <strong>deepcopy<\/strong>!\n```<\/code><\/pre>\n\n\n\n
    \n\n\n\n
    \u26a1 Leistung und Fallstricke<\/strong><\/h4>\n\n\n\n
      \n
    • Geschwindigkeit:<\/strong> copy.copy()<\/code> ist erheblich schneller, da es nicht die gesamte Datenstruktur rekursiv durchl\u00e4uft. copy.deepcopy()<\/code> kann bei gro\u00dfen und tief verschachtelten Objekten sehr langsam sein.<\/li>\n\n\n\n
    • Nicht kopierbare Objekte:<\/strong> Systemressourcen wie ge\u00f6ffnete Dateien, Sockets oder Streams k\u00f6nnen nicht kopiert werden. Der Versuch, dies zu tun, f\u00fchrt zu einem Fehler.<\/li>\n\n\n\n
    • Zyklische Referenzen:<\/strong> deepcopy<\/code> ist intelligent genug, um mit zyklischen Referenzen umzugehen (wenn Objekt A<\/code> auf B<\/code> verweist und B<\/code> zur\u00fcck auf A<\/code>), ohne in eine Endlosschleife zu geraten.<\/li>\n<\/ul>\n\n\n\n
      Wann was verwenden: Die wichtigsten Regeln<\/strong><\/h4>\n\n\n\n
        \n
      1. Verwenden Sie eine oberfl\u00e4chliche Kopie (copy.copy()<\/code>)<\/strong>, wenn Ihr Objekt nur unver\u00e4nderliche Daten enth\u00e4lt oder wenn Sie absichtlich m\u00f6chten, dass die Kopie und das Original verschachtelte Objekte teilen. Dies ist schnell und effizient.<\/li>\n\n\n\n
      2. Verwenden Sie eine tiefe Kopie (copy.deepcopy()<\/code>)<\/strong>, wenn Sie eine vollst\u00e4ndige, 100% unabh\u00e4ngige Kopie des Originals ben\u00f6tigen, insbesondere bei der Arbeit mit komplexen Datenstrukturen (Listen, Dictionaries, Klasseninstanzen).<\/li>\n\n\n\n
      3. F\u00fcr unver\u00e4nderliche Objekte<\/strong> (Zahlen, Zeichenketten, Tupel ohne ver\u00e4nderbare Elemente) ist das Kopieren im Allgemeinen sinnlos \u2013 Python optimiert deren Verwendung ohnehin.<\/li>\n\n\n\n
      4. Denken Sie daran, dass Sie den Prozess<\/strong> mit __copy__<\/code> und __deepcopy__<\/code> anpassen k\u00f6nnen, um die volle Kontrolle zu haben.<\/li>\n<\/ol>\n","protected":false},"excerpt":{"rendered":"
        Das Kopieren von Objekten ist ein grundlegendes Konzept in Python, dessen Missverst\u00e4ndnis oft zu schwer auffindbaren Fehlern f\u00fchrt. Wenn Sie ein Objekt \u00e4ndern und sich unerwartet ein anderes ebenfalls \u00e4ndert, liegt das Problem h\u00f6chstwahrscheinlich in der Art und Weise, wie es kopiert wurde. Lassen Sie uns dieses Thema ein f\u00fcr alle Mal kl\u00e4ren.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"neve_meta_sidebar":"","neve_meta_container":"","neve_meta_enable_content_width":"","neve_meta_content_width":0,"neve_meta_title_alignment":"left","neve_meta_author_avatar":"on","neve_post_elements_order":"[\"content\",\"tags\",\"comments\"]","neve_meta_disable_header":"","neve_meta_disable_footer":"","neve_meta_disable_title":"","_themeisle_gutenberg_block_has_review":false,"footnotes":""},"categories":[],"tags":[],"class_list":["post-3112","post","type-post","status-publish","format-standard","hentry"],"_links":{"self":[{"href":"https:\/\/de.davidka.net\/de\/wp-json\/wp\/v2\/posts\/3112","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/de.davidka.net\/de\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/de.davidka.net\/de\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/de.davidka.net\/de\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/de.davidka.net\/de\/wp-json\/wp\/v2\/comments?post=3112"}],"version-history":[{"count":0,"href":"https:\/\/de.davidka.net\/de\/wp-json\/wp\/v2\/posts\/3112\/revisions"}],"wp:attachment":[{"href":"https:\/\/de.davidka.net\/de\/wp-json\/wp\/v2\/media?parent=3112"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/de.davidka.net\/de\/wp-json\/wp\/v2\/categories?post=3112"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/de.davidka.net\/de\/wp-json\/wp\/v2\/tags?post=3112"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}