Wie kann ich eine Kopie eines Objekts in Python erstellen?

Wie kann ich das erstellen einer Kopie eines Objekts in Python?

So, wenn ich ändern Sie die Werte der Felder des neuen Objektes das alte Objekt nicht berührt werden sollte.

Du meinst ein veränderliches Objekt.

In Python 3, Listen bekommen copy Methode (in 2, die Sie verwenden würden, eine Scheibe zu machen eine Kopie):

>>> a_list = list('abc')
>>> a_copy_of_a_list = a_list.copy()
>>> a_copy_of_a_list is a_list
False
>>> a_copy_of_a_list == a_list
True

Flache Kopien

Flache Kopien sind nur Kopien von den äußersten container.

list.copy ist eine flache Kopie:

>>> list_of_dict_of_set = [{'foo': set('abc')}
... ]
>>> list_of_dict_of_set = [{'foo': set('abc')}]
>>> lodos_copy = list_of_dict_of_set.copy()
>>> lodos_copy[0]['foo'].pop()
'c'
>>> lodos_copy
[{'foo': {'b', 'a'}}]
>>> list_of_dict_of_set
[{'foo': {'b', 'a'}}]

Bekommen Sie nicht, eine Kopie der inneren Objekte. Sie sind die gleiche Objekt - also, wenn Sie mutiert, die änderung zeigt sich in beiden Behältern.

Tiefe Kopien

Tiefen Kopien werden rekursiv Kopien von jeder interior-Objekt.

>>> lodos_deep_copy = copy.deepcopy(list_of_dict_of_set)
>>> lodos_deep_copy[0]['foo'].add('c')
>>> lodos_deep_copy
[{'foo': {'c', 'b', 'a'}}]
>>> list_of_dict_of_set
[{'foo': {'b', 'a'}}]

Änderungen nicht in das original, nur in der Kopie.

Unveränderliche Objekte

Immutable Objekte in der Regel nicht kopiert werden müssen. In der Tat, wenn Sie versuchen, Python wird nur geben Sie das ursprüngliche Objekt:

>>> a_tuple = tuple('abc')
>>> tuple_copy_attempt = a_tuple.copy()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'tuple' object has no attribute 'copy'

Tupel, die nicht einmal einen copy-Methode, also versuchen wir es mit einer Scheibe:

>>> tuple_copy_attempt = a_tuple[:]

Aber sehen wir, es ist das gleiche Objekt:

>>> tuple_copy_attempt is a_tuple
True

Ebenso für Streicher:

>>> s = 'abc'
>>> s0 = s[:]
>>> s == s0
True
>>> s is s0
True

und für frozensets, obwohl Sie ein copy Methode:

>>> a_frozenset = frozenset('abc')
>>> frozenset_copy_attempt = a_frozenset.copy()
>>> frozenset_copy_attempt is a_frozenset
True

Beim kopieren unveränderliche Objekte

Unveränderliche Objekte sollte kopiert werden, wenn Sie brauchen eine veränderliche interior-Objekt kopiert.

>>> tuple_of_list = [],
>>> copy_of_tuple_of_list = tuple_of_list[:]
>>> copy_of_tuple_of_list[0].append('a')
>>> copy_of_tuple_of_list
(['a'],)
>>> tuple_of_list
(['a'],)
>>> deepcopy_of_tuple_of_list = copy.deepcopy(tuple_of_list)
>>> deepcopy_of_tuple_of_list[0].append('b')
>>> deepcopy_of_tuple_of_list
(['a', 'b'],)
>>> tuple_of_list
(['a'],)

Wie wir sehen können, wenn das innere Objekt der Kopie mutiert ist, das original nicht nicht ändern.

Benutzerdefinierter Objekte

Benutzerdefinierten Objekte, die in der Regel speichern von Daten in einem __dict__ Attribut oder in __slots__ (einer Tupel-wie Speicher-Struktur.)

Machen kopierbar Objekts definieren __copy__ (für flache Kopien) und/oder __deepcopy__ (für Tiefe Kopien).

from copy import copy, deepcopy

class Copyable:
    __slots__ = 'a', '__dict__'
    def __init__(self, a, b):
        self.a, self.b = a, b
    def __copy__(self):
        return type(self)(self.a, self.b)
    def __deepcopy__(self, memo): # memo is a dict of id's to copies
        id_self = id(self)        # memoization avoids unnecesary recursion
        _copy = memo.get(id_self)
        if _copy is None:
            _copy = type(self)(
                deepcopy(self.a, memo), 
                deepcopy(self.b, memo))
            memo[id_self] = _copy 
        return _copy

Beachten Sie, dass deepcopy hält eine memoization Wörterbuch id(original) (oder id-Nummern) kopiert. Genießen Sie gutes Verhalten mit rekursiven Datenstrukturen, stellen Sie sicher, dass Sie nicht bereits eine Kopie, und wenn Sie haben, zurückzukehren.

Machen wir also ein Objekt:

>>> c1 = Copyable(1, [2])

Sowie copy macht eine flache Kopie:

>>> c2 = copy(c1)
>>> c1 is c2
False
>>> c2.b.append(3)
>>> c1.b
[2, 3]

Sowie deepcopy macht nun eine Tiefe Kopie:

>>> c3 = deepcopy(c1)
>>> c3.b.append(4)
>>> c1.b
[2, 3]

InformationsquelleAutor der Antwort Aaron Hall