copy em Python: cópia rasa e deepcopy
Entenda a diferença entre atribuição, cópia rasa (copy.copy, fatia, dict.copy) e copy.deepcopy em Python, com exemplos executados, tabela, limites e desempenho.
Em Python, atribuir não copia: b = a faz as duas variáveis apontarem para o mesmo objeto. Fatiar uma lista (a[:]), chamar dict.copy() e usar copy.copy() fazem uma cópia rasa: criam um novo contêiner, mas os objetos de dentro continuam compartilhados. Só copy.deepcopy() copia também os objetos aninhados, gerando uma estrutura independente.
A regra prática: se a estrutura só tem valores imutáveis (números, strings, tuplas simples), a cópia rasa basta. Se há listas, dicionários ou objetos dentro de outros e você vai alterá-los, use deepcopy. Os exemplos abaixo foram executados com Python 3.13.
Comparação: atribuição, cópia rasa e deepcopy
| Forma | Novo objeto externo? | Objetos internos | Custo |
|---|---|---|---|
b = a | Não, é o mesmo objeto | Compartilhados | Nenhum |
a[:], a.copy(), list(a) | Sim | Compartilhados | Baixo |
d.copy(), dict(d) | Sim | Compartilhados | Baixo |
copy.copy(x) | Sim | Compartilhados | Baixo |
copy.deepcopy(x) | Sim | Copiados recursivamente | Maior |
Para o básico de listas (fatiamento, métodos, ordenação), veja o guia de listas em Python.
O bug clássico: atribuição não copia
a = [1, 2, 3]
b = a
b.append(4)
print(a) # [1, 2, 3, 4]
print(a is b) # True
c = a.copy()
c.append(5)
print(a, c) # [1, 2, 3, 4] [1, 2, 3, 4, 5]
b não é uma lista nova: é outro nome para a mesma lista. Já a.copy() cria um objeto distinto, então c evolui sozinha.
Cópia rasa ainda compartilha a lista interna
O problema aparece quando há estruturas dentro de estruturas. A cópia rasa duplica só o nível de fora:
import copy
original = [[1, 2], [3, 4]]
rasa = copy.copy(original)
fatia = original[:]
funda = copy.deepcopy(original)
original[0].append(99)
print(rasa) # [[1, 2, 99], [3, 4]]
print(fatia) # [[1, 2, 99], [3, 4]]
print(funda) # [[1, 2], [3, 4]]
print(rasa[0] is original[0], funda[0] is original[0]) # True False
d = {"nome": "Ana", "tags": ["python"]}
d2 = d.copy()
d2["tags"].append("copy")
print(d) # {'nome': 'Ana', 'tags': ['python', 'copy']}
A cópia rasa e a fatia enxergaram o 99 porque rasa[0] e original[0] são o mesmo objeto. O deepcopy criou uma lista interna nova. O mesmo vale para dict.copy(): alterar d2["tags"] mudou d. Para inspecionar estruturas aninhadas com clareza, ajuda o pprint.
Copiando dataclasses
Uma dataclass é um objeto comum, então copy.copy e copy.deepcopy funcionam. A função dataclasses.replace também cria uma cópia rasa, trocando os campos que você informar:
import copy
from dataclasses import dataclass, field, replace
@dataclass
class Pedido:
cliente: str
itens: list = field(default_factory=list)
p1 = Pedido("Ana", ["caneta"])
p2 = copy.copy(p1)
p3 = copy.deepcopy(p1)
p4 = replace(p1, cliente="Bia")
p1.itens.append("caderno")
print(p2.itens) # ['caneta', 'caderno']
print(p3.itens) # ['caneta']
print(p4.itens) # ['caneta', 'caderno']
print(p4) # Pedido(cliente='Bia', itens=['caneta', 'caderno'])
p2 e p4 compartilham a lista itens com p1; só p3 é independente. Se um campo é mutável, a cópia rasa de uma dataclass tem a mesma armadilha de qualquer outro objeto.
Controlando a cópia: __copy__ e __deepcopy__
Classes podem definir como são copiadas. copy.copy chama __copy__(self), e copy.deepcopy chama __deepcopy__(self, memo). Dentro de __deepcopy__, repasse o memo às chamadas de deepcopy para preservar referências compartilhadas e ciclos:
import copy
class Conexao:
def __init__(self, url):
self.url = url
self.cache = []
def __copy__(self):
print("__copy__ chamado")
return Conexao(self.url) # cache começa vazio
def __deepcopy__(self, memo):
print("__deepcopy__ chamado")
nova = Conexao(self.url)
memo[id(self)] = nova
nova.cache = copy.deepcopy(self.cache, memo)
return nova
c = Conexao("db://x")
c.cache.append([1])
r = copy.copy(c)
f = copy.deepcopy(c)
print(r.cache, f.cache, f.cache[0] is c.cache[0])
# __copy__ chamado
# __deepcopy__ chamado
# [] [[1]] False
Aqui a cópia rasa descarta o cache de propósito, e a profunda o duplica. Esse controle é útil quando parte do estado não deve ser copiada, como um recurso externo.
O que deepcopy não consegue copiar
Segundo a documentação do módulo copy, a cópia de módulos, métodos, rastreamentos de pilha, arquivos, sockets, janelas e outros tipos semelhantes não é suportada. Na prática, deepcopy levanta TypeError para objetos que dependem de recursos do sistema:
import copy, threading, socket, sys
try:
copy.deepcopy(threading.Lock())
except TypeError as e:
print("TypeError:", e)
# TypeError: cannot pickle '_thread.lock' object
with open("dados.txt", "w") as f:
try:
copy.deepcopy(f)
except TypeError as e:
print("TypeError:", e)
# TypeError: cannot pickle 'TextIOWrapper' instances
s = socket.socket()
try:
copy.deepcopy(s)
except TypeError as e:
print("TypeError:", e)
s.close()
# TypeError: cannot pickle 'socket' object
try:
copy.deepcopy(sys)
except TypeError as e:
print("TypeError:", e)
# TypeError: cannot pickle 'module' object
A mensagem fala em “pickle” porque, sem __deepcopy__, o módulo usa o mesmo protocolo de redução da serialização. Para entender esse protocolo e seus riscos, leia sobre pickle e serialização segura. Nesses casos, defina __deepcopy__ (ou __getstate__) na sua classe para ignorar ou recriar o recurso.
Memo e referências circulares
O deepcopy mantém um dicionário memo que mapeia o id de cada objeto já copiado para a sua cópia. Isso resolve dois problemas descritos na documentação: ciclos recursivos e objetos compartilhados, que são copiados uma única vez:
import copy
a = [1]
a.append(a) # lista que contém a si mesma
b = copy.deepcopy(a)
print(b[1] is b, b is a) # True False
x = [1, 2]
dados = {"a": x, "b": x}
cp = copy.deepcopy(dados)
print(cp["a"] is cp["b"], cp["a"] is x) # True False
A cópia b também contém a si mesma, sem recursão infinita, e cp preserva o fato de "a" e "b" apontarem para a mesma lista, que agora é diferente da original.
Desempenho: quando preferir cópia rasa
deepcopy percorre todo o grafo de objetos, consulta o memo a cada passo e cria muitos objetos novos, por isso é mais lento que uma cópia rasa e usa mais memória. Prefira a cópia rasa quando:
- a estrutura só contém valores imutáveis;
- os objetos aninhados não são alterados nem compartilhados depois da cópia;
- você pode construir explicitamente só a parte que vai mudar, por exemplo
{**config, "debug": True}.
Use deepcopy quando precisar de uma estrutura realmente independente, como um estado inicial de teste ou uma configuração que será modificada em profundidade. Se for decisivo, meça com timeit nos seus dados reais.
Perguntas frequentes
As respostas às dúvidas mais comuns estão no bloco de FAQ desta página: diferença entre copy.copy e deepcopy, atribuição, dict.copy(), limites do deepcopy e desempenho.