Neste artigo, você aprenderá sobre cópia superficial e cópia profunda em Python com a ajuda de exemplos.
Copiar um objeto em Python
Em Python, usamos o =operador para criar uma cópia de um objeto. Você pode pensar que isso cria um novo objeto; isso não acontece. Ele apenas cria uma nova variável que compartilha a referência do objeto original.
Vamos dar um exemplo onde criamos uma lista chamada old_list e passamos uma referência de objeto para new_list usando o =operador.
Exemplo 1: Copiar usando o operador =
old_list = ((1, 2, 3), (4, 5, 6), (7, 8, 'a')) new_list = old_list new_list(2)(2) = 9 print('Old List:', old_list) print('ID of Old List:', id(old_list)) print('New List:', new_list) print('ID of New List:', id(new_list))
Quando executamos o programa acima, a saída será:
Lista Antiga: ((1, 2, 3), (4, 5, 6), (7, 8, 9)) ID da Lista Antiga: 140673303268168 Nova Lista: ((1, 2, 3), (4, 5 , 6), (7, 8, 9)) ID da Nova Lista: 140673303268168
Como você pode ver na saída, as variáveis old_list e new_list compartilham o mesmo id, ou seja 140673303268168.
Portanto, se você deseja modificar quaisquer valores em new_list ou old_list, a mudança é visível em ambos.
Essencialmente, às vezes você pode querer manter os valores originais inalterados e apenas modificar os novos valores ou vice-versa. Em Python, existem duas maneiras de criar cópias:
- Cópia Rasa
- Deep Copy
Para fazer essas cópias funcionarem, usamos o copymódulo.
Módulo de cópia
Usamos o copymódulo do Python para operações de cópia superficiais e profundas. Suponha que você precise copiar a lista de compostos, digamos x. Por exemplo:
importar cópia copy.copy (x) copy.deepcopy (x)
Aqui, copy()retorne uma cópia superficial de x. Da mesma forma, deepcopy()retorne uma cópia profunda de x.
Cópia Rasa
Uma cópia superficial cria um novo objeto que armazena a referência dos elementos originais.
Portanto, uma cópia superficial não cria uma cópia de objetos aninhados, em vez disso, apenas copia a referência de objetos aninhados. Isso significa que um processo de cópia não repassa ou cria cópias de objetos aninhados em si.
Exemplo 2: Criar uma cópia usando cópia superficial
import copy old_list = ((1, 2, 3), (4, 5, 6), (7, 8, 9)) new_list = copy.copy(old_list) print("Old list:", old_list) print("New list:", new_list)
Quando executamos o programa, a saída será:
Lista antiga: ((1, 2, 3), (4, 5, 6), (7, 8, 9)) Nova lista: ((1, 2, 3), (4, 5, 6), (7 , 8, 9))
No programa acima, criamos uma lista aninhada e a copiamos superficialmente usando o copy()método.
Isso significa que ele criará um objeto novo e independente com o mesmo conteúdo. Para verificar isso, imprimimos a old_list e a new_list.
Para confirmar que new_list é diferente de old_list, tentamos adicionar um novo objeto aninhado ao original e verificá-lo.
Exemplo 3: Adicionando (4, 4, 4) à lista_antiga, usando uma cópia superficial
import copy old_list = ((1, 1, 1), (2, 2, 2), (3, 3, 3)) new_list = copy.copy(old_list) old_list.append((4, 4, 4)) print("Old list:", old_list) print("New list:", new_list)
Quando executamos o programa, ele gerará:
Lista antiga: ((1, 1, 1), (2, 2, 2), (3, 3, 3), (4, 4, 4)) Nova lista: ((1, 1, 1), (2 , 2, 2), (3, 3, 3))
No programa acima, criamos uma cópia superficial de old_list. A new_list contém referências aos objetos aninhados originais armazenados na old_list. Em seguida, adicionamos a nova lista, ou seja, (4, 4, 4)em old_list. Esta nova sublista não foi copiada em new_list.
No entanto, quando você altera qualquer objeto aninhado em old_list, as alterações aparecem em new_list.
Exemplo 4: Adicionando um novo objeto aninhado usando cópia superficial
import copy old_list = ((1, 1, 1), (2, 2, 2), (3, 3, 3)) new_list = copy.copy(old_list) old_list(1)(1) = 'AA' print("Old list:", old_list) print("New list:", new_list)
Quando executamos o programa, ele gerará:
Lista antiga: ((1, 1, 1), (2, 'AA', 2), (3, 3, 3)) Nova lista: ((1, 1, 1), (2, 'AA', 2 ), (3, 3, 3))
No programa acima, fizemos alterações em old_list ie old_list(1)(1) = 'AA'. Ambas as sublistas de old_list e new_list no índice (1)(1)foram modificadas. Isso ocorre porque ambas as listas compartilham a referência dos mesmos objetos aninhados.
Deep Copy
Uma cópia profunda cria um novo objeto e adiciona recursivamente as cópias de objetos aninhados presentes nos elementos originais.
Vamos continuar com o exemplo 2. No entanto, vamos criar uma cópia profunda usando a deepcopy()função presente no copymódulo. A cópia profunda cria uma cópia independente do objeto original e todos os seus objetos aninhados.
Exemplo 5: Copiando uma lista usando deepcopy ()
import copy old_list = ((1, 1, 1), (2, 2, 2), (3, 3, 3)) new_list = copy.deepcopy(old_list) print("Old list:", old_list) print("New list:", new_list)
Quando executamos o programa, ele gerará:
Lista antiga: ((1, 1, 1), (2, 2, 2), (3, 3, 3)) Nova lista: ((1, 1, 1), (2, 2, 2), (3 , 3, 3))
No programa acima, usamos a deepcopy()função para criar uma cópia semelhante.
No entanto, se você fizer alterações em qualquer objeto aninhado no objeto old_list original, não verá alterações na cópia new_list.
Exemplo 6: Adicionando um novo objeto aninhado na lista usando cópia profunda
import copy old_list = ((1, 1, 1), (2, 2, 2), (3, 3, 3)) new_list = copy.deepcopy(old_list) old_list(1)(0) = 'BB' print("Old list:", old_list) print("New list:", new_list)
Quando executamos o programa, ele gerará:
Lista antiga: ((1, 1, 1), ('BB', 2, 2), (3, 3, 3)) Nova lista: ((1, 1, 1), (2, 2, 2), (3, 3, 3))
No programa acima, quando atribuímos um novo valor a old_list, podemos ver que apenas a old_list é modificada. Isso significa que tanto a old_list quanto a new_list são independentes. Isso ocorre porque a old_list foi copiada recursivamente, o que é verdadeiro para todos os seus objetos aninhados.
