Como posso criar uma cópia de um objeto em Python?

Eu gostaria de criar uma cópia de um objeto. Eu quero que o novo objeto possua todas as propriedades do objeto antigo (valores dos campos). Mas eu quero ter objetos independentes. Portanto, se eu alterar os valores dos campos do novo objeto, o objeto antigo não deverá ser afetado por isso.

Para obter uma cópia totalmente independente de um objeto, você pode usar a copy.deepcopy()função

Para obter mais detalhes sobre cópia superficial e profunda, consulte as outras respostas a esta pergunta e a boa explicação nesta resposta a uma pergunta relacionada .

Como posso criar uma cópia de um objeto em Python?

Portanto, se eu alterar os valores dos campos do novo objeto, o objeto antigo não deverá ser afetado por isso.

Você quer dizer um objeto mutável então.

No Python 3, as listas obtêm um copymétodo (em 2, você usaria uma fatia para fazer uma cópia):

>>> 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

Cópias rasas

Cópias rasas são apenas cópias do recipiente mais externo.

list.copy é uma cópia superficial:

>>> 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'}}]

Você não recebe uma cópia dos objetos internos. Eles são o mesmo objeto - portanto, quando são mutados, a alteração aparece nos dois contêineres.

Cópias profundas

Cópias profundas são cópias recursivas de cada objeto interior.

>>> 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'}}]

As alterações não são refletidas no original, apenas na cópia.

Objetos imutáveis

Objetos imutáveis ​​geralmente não precisam ser copiados. De fato, se você tentar, o Python fornecerá apenas o objeto original:

>>> 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'

As tuplas nem sequer têm um método de cópia, então vamos tentar com uma fatia:

>>> tuple_copy_attempt = a_tuple[:]

Mas vemos que é o mesmo objeto:

>>> tuple_copy_attempt is a_tuple
True

Da mesma forma para seqüências de caracteres:

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

e para frozensets, mesmo que eles tenham um copymétodo:

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

Quando copiar objetos imutáveis

Objetos imutáveis devem ser copiados se você precisar de um objeto interior mutável copiado.

>>> 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'],)

Como podemos ver, quando o objeto interior da cópia é alterado , o original não muda.

Objetos personalizados

Objetos personalizados geralmente armazenam dados em um __dict__atributo ou em __slots__(uma estrutura de memória semelhante a uma tupla).

Para criar um objeto copiável, defina __copy__(para cópias rasas) e / ou __deepcopy__(para cópias profundas).

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

Observe que deepcopymantém um dicionário de memorização id(original)(ou números de identidade) para cópias. Para ter bom comportamento com estruturas de dados recursivas, verifique se você ainda não fez uma cópia e, se tiver, devolva-a.

Então, vamos criar um objeto:

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

E copyfaz uma cópia superficial:

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

E deepcopyagora faz uma cópia profunda:

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

Cópia rasa com copy.copy()

#!/usr/bin/env python3

import copy

class C():
    def __init__(self):
        self.x = [1]
        self.y = [2]

# It copies.
c = C()
d = copy.copy(c)
d.x = [3]
assert c.x == [1]
assert d.x == [3]

# It's shallow.
c = C()
d = copy.copy(c)
d.x[0] = 3
assert c.x == [3]
assert d.x == [3]

Cópia profunda com copy.deepcopy()

#!/usr/bin/env python3
import copy
class C():
    def __init__(self):
        self.x = [1]
        self.y = [2]
c = C()
d = copy.deepcopy(c)
d.x[0] = 3
assert c.x == [1]
assert d.x == [3]

Documentação: https://docs.python.org/3/library/copy.html

Testado em Python 3.6.5.

Eu acredito que o seguinte deve funcionar com muitos bem-comportados classificados em Python:

def copy(obj):
    return type(obj)(obj)

(É claro que não estou falando aqui de "cópias profundas", que é uma história diferente e que pode não ser um conceito muito claro - quão profunda é a profundidade suficiente?)

De acordo com meus testes com o Python 3, para objetos imutáveis, como tuplas ou cordas, ele retorna o mesmo objeto (porque não há necessidade de fazer uma cópia superficial de um objeto imutável), mas para listas ou dicionários ele cria uma cópia superficial independente .

Obviamente, esse método funciona apenas para classes cujos construtores se comportam de acordo. Possíveis casos de uso: fazendo uma cópia superficial de uma classe de contêiner Python padrão.