Copy an Object in Python

In Python, we use = operator to create a copy of an object. Você pode pensar que isso cria um novo objeto; ele não cria. ele só cria uma nova variável que compartilha a referência do objeto original.

tomemos um exemplo onde criamos uma lista chamada old_list e passamos uma referência de objeto para new_list usando = operador.,

Exemplo 1: Copiar usando o operador =

Quando vamos executar o programa acima, a saída será:

Old List: , , ]ID of Old List: 140673303268168New List: , , ]ID of New List: 140673303268168

Como você pode ver a saída de ambas as variáveis old_list e new_list tem o mesmo id.e 140673303268168.

assim, se você quiser modificar quaisquer valores em new_list ou old_list, a alteração é visível em ambos.

essencialmente, às vezes você pode querer ter os valores originais inalterados e só modificar os novos valores ou vice-versa., Em Python, existem duas maneiras de criar cópias:

1. cópia Rasa
2. cópia profunda

para fazer estas cópias funcionarem, usamos o módulo copy.

Copy Module

We use the copy module of Python for shallow and deep copy operations. Suponha-se, você precisa copiar o composto lista digamos x. Por exemplo:

import copycopy.copy(x)copy.deepcopy(x)

Aqui copy() retornar uma cópia superficial de x. Da mesma forma, deepcopy() retornar uma cópia de profundidade de x.,

cópia Rasa

uma cópia rasa cria um novo objecto que armazena a referência dos elementos originais.

assim, uma cópia rasa não cria uma cópia de objetos aninhados, em vez disso, apenas copia a referência de objetos aninhados. Isto significa que um processo de cópia não recursiva ou cria cópias de objetos aninhados em si.,

Exemplo 2: Criar uma cópia de cópia superficial

import copyold_list = , , ]new_list = copy.copy(old_list)print("Old list:", old_list)print("New list:", new_list)

Quando executamos o programa , o resultado será:

Old list: , , ]New list: , , ]

No programa acima, nós criamos uma lista aninhada e, em seguida, a cópia superficial-lo usando copy() método.

isto significa que irá criar um objecto novo e independente com o mesmo conteúdo. Para verificar isso, imprimimos tanto o old_list como o new_list.,

Para confirmar que new_list é diferente de old_list, tentamos adicionar um novo objeto aninhado original e verificá-lo.

Exemplo 3: Adicionando a old_list, usando a cópia superficial

Ao executar o programa, ele irá saída:

Old list: , , , ]New list: , , ]

No programa acima, nós criamos uma cópia superficial de old_list. A lista new_ list contém referências aos objectos aninhados originais armazenados na lista old_ list. Em seguida, adicionamos a nova lista i. e no old_list., Esta nova sub-lista não foi copiada na new_ list.

no entanto, quando você alterar quaisquer objetos aninhados no old_list, as alterações aparecem no new_list.

Exemplo 4: Adicionar o novo objeto aninhado usando a cópia Superficial

import copyold_list = , , ]new_list = copy.copy(old_list)old_list = 'AA'print("Old list:", old_list)print("New list:", new_list)

Ao executar o programa, ele irá saída:

Old list: , , ]New list: , , ]

Cópia de Profundidade

Uma cópia profunda cria um novo objeto e adiciona recursivamente as cópias de objetos aninhados presente nos elementos originais.vamos continuar com o exemplo 2., No entanto, vamos criar cópia profunda usando deepcopy() função presente emcopy módulo. A cópia profunda cria uma cópia independente do objeto original e de todos os seus objetos aninhados.

Exemplo 5: a Cópia de uma lista usando deepcopy()

import copyold_list = , , ]new_list = copy.deepcopy(old_list)print("Old list:", old_list)print("New list:", new_list)

Ao executar o programa, ele irá saída:

Old list: , , ]New list: , , ]

No programa acima, nós usamos deepcopy() função para criar a cópia, que é semelhante.,

no entanto, se fizer alterações a quaisquer objectos aninhados na lista original de objectos old_ List, não irá ver alterações à lista de cópias new_ list.

Exemplo 6: Adicionando um novo objeto aninhado na lista usando Profunda copiar

Ao executar o programa, ele irá saída:

Old list: , , ]New list: , , ]

No programa anterior, quando podemos atribuir um novo valor para old_list, podemos ver apenas o old_list é modificado. Isto significa que tanto o old_list como o new_list são independentes. Isto é porque o old_ LIst foi copiado recursivamente, o que é verdadeiro para todos os seus objetos aninhados.