---
title: "copy em Python: cópia rasa e deepcopy"
url: "https://python.dev.br/blog/python-copy-deepcopy-copia-rasa/"
markdown_url: "https://python.dev.br/blog/python-copy-deepcopy-copia-rasa.MD"
description: "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."
date: "2026-11-11"
author: "Equipe Python Dev BR"
---

# 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](/algoritmos/listas-python/).

## O bug clássico: atribuição não copia

```python
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:

```python
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](/blog/python-pprint-formatar-dicionarios-json/).

## Copiando dataclasses

Uma [dataclass](/blog/dataclasses-python-guia-completo/) é 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:

```python
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:

```python
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:

```python
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](/blog/python-pickle-serializacao-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:

```python
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.
