Copiar Listas

As listas em Python são mutáveis, o que significa que atribuir uma lista a uma nova variável não cria uma cópia — ambos os nomes apontam para o mesmo objeto. Esta página explica todas as formas confiáveis de copiar uma lista, a diferença entre uma cópia superficial e uma cópia profunda, e quando cada abordagem é a escolha certa.

A Armadilha da Atribuição

Um erro comum é usar o operador = esperando que ele produza uma cópia independente:

Por que o operador = não copia uma lista

Tanto original quanto alias apontam para exatamente o mesmo objeto de lista na memória. Qualquer alteração feita por meio de um nome é imediatamente visível pelo outro.

Para obter uma cópia verdadeiramente independente, use um dos métodos abaixo.

Métodos de Cópia Superficial

Uma cópia superficial cria um novo objeto de lista, mas os elementos dentro da nova lista ainda são referências aos mesmos objetos que a original. Para uma lista plana (uma lista contendo apenas valores imutáveis como números e strings), uma cópia superficial se comporta como uma cópia totalmente independente.

Usando o Método copy()

O método copy() é a abordagem mais explícita e legível:

Copiar uma lista com o método copy()

original = ["apple", "banana", "cherry"]
copy_of = original.copy()

copy_of.append("date")
print(original)   # Output: ['apple', 'banana', 'cherry']
print(copy_of)    # Output: ['apple', 'banana', 'cherry', 'date']

As duas listas agora são independentes: adicionar um elemento a copy_of não afeta original.

Usando a Notação de Fatia [:]

A notação de fatia é um atalho Python para copiar a lista inteira:

Copiar uma lista com notação de fatia

original = [10, 20, 30, 40]
copy_of = original[:]

copy_of[0] = 99
print(original)   # Output: [10, 20, 30, 40]
print(copy_of)    # Output: [99, 20, 30, 40]

[:] significa "pegar todos os elementos do início ao fim", o que produz uma nova lista contendo esses elementos.

Usando o Construtor list()

Passar uma lista existente para list() também cria uma cópia superficial:

Copiar uma lista com o construtor list()

original = [1, 2, 3]
copy_of = list(original)

copy_of.append(4)
print(original)   # Output: [1, 2, 3]
print(copy_of)    # Output: [1, 2, 3, 4]

Isso é especialmente útil ao converter outro iterável (como uma tupla) em uma lista ao mesmo tempo.

Quando Cópias Superficiais Não São Suficientes

Uma cópia superficial copia apenas a estrutura de nível superior. Se a lista contiver objetos mutáveis, como outras listas ou dicionários, esses objetos aninhados ainda serão compartilhados entre o original e a cópia.

Cópia superficial com uma lista aninhada

Ambas as listas compartilham os mesmos objetos de lista internos [1, 2] e [3, 4]. Alterar original[0][0] modifica essa lista interna compartilhada, então a mudança também aparece em shallow.

Cópia Profunda

Uma cópia profunda copia recursivamente todos os objetos dentro da lista, produzindo uma estrutura completamente independente do original. Use copy.deepcopy() do módulo copy da biblioteca padrão:

Cópia profunda de uma lista aninhada com copy.deepcopy()

import copy

original = [[1, 2], [3, 4]]
deep = copy.deepcopy(original)

original[0][0] = 99       # Mutate the nested list

print(original)   # Output: [[99, 2], [3, 4]]
print(deep)       # Output: [[1, 2], [3, 4]]  <- unchanged

deep mantém suas próprias cópias das listas internas, portanto alterações em original não a afetam em nada.

Cópia Superficial vs. Cópia Profunda em Resumo

Exemplos Práticos

Combinando Todos os Métodos de Cópia Superficial

original = [1, 2, 3]

a = original.copy()    # method
b = original[:]        # slice
c = list(original)     # constructor

original.append(4)

print(a)  # Output: [1, 2, 3]
print(b)  # Output: [1, 2, 3]
print(c)  # Output: [1, 2, 3]

Os três produzem cópias independentes — nenhuma delas reflete o append(4) posterior.

Copiando uma Lista de Dicionários

Dicionários são objetos mutáveis. Uma cópia superficial de uma lista de dicionários compartilha esses objetos dict:

import copy

records = [{"name": "Alice", "score": 90}, {"name": "Bob", "score": 85}]
shallow = records.copy()
deep    = copy.deepcopy(records)

records[0]["score"] = 0

print(shallow[0])   # Output: {'name': 'Alice', 'score': 0}   <- shared dict
print(deep[0])      # Output: {'name': 'Alice', 'score': 90}  <- independent copy

Quando os elementos são objetos mutáveis e você precisa de total independência, sempre use deepcopy().

Conclusão

As listas em Python são mutáveis, portanto o operador = cria um alias, não uma cópia. Para listas planas, qualquer um dos métodos de cópia superficial — copy(), [:] ou list() — funciona igualmente bem. Quando as listas contêm objetos mutáveis aninhados, use copy.deepcopy() para garantir total independência.

Para explorar operações relacionadas a listas, veja List Methods, Add List Items e Remove List Items. Para copiar dicionários, a mesma distinção superficial/profunda se aplica — veja Copy Dictionaries.

Prática