Como copiar um dicionário e editar apenas a cópia

Alguém pode explicar isso para mim? Isso não faz nenhum sentido para mim.

Copio um dicionário para outro e edito o segundo e ambos são alterados. Por que isso está acontecendo?

>>> dict1 = {"key1": "value1", "key2": "value2"}
>>> dict2 = dict1
>>> dict2
{'key2': 'value2', 'key1': 'value1'}
>>> dict2["key2"] = "WHY?!"
>>> dict1
{'key2': 'WHY?!', 'key1': 'value1'}

Python nunca copia implicitamente objetos. Quando você definedict2 = dict1 , está fazendo com que eles se refiram ao mesmo objeto de ditado exato; portanto, quando você o modifica, todas as referências a ele continuam se referindo ao objeto em seu estado atual.

Se você deseja copiar o ditado (o que é raro), é necessário fazê-lo explicitamente com

dict2 = dict(dict1)

ou

dict2 = dict1.copy()

Quando você atribui dict2 = dict1, não está fazendo uma cópia dict1, isso resulta em dict2apenas outro nome para dict1.

Para copiar os tipos mutáveis, como dicionários, use copy/ deepcopydo copymódulo.

import copy

dict2 = copy.deepcopy(dict1)

Enquanto dict.copy()e dict(dict1)gera uma cópia, elas são apenas cópias rasas . Se você deseja uma cópia profunda , copy.deepcopy(dict1)é necessária. Um exemplo:

>>> source = {'a': 1, 'b': {'m': 4, 'n': 5, 'o': 6}, 'c': 3}
>>> copy1 = x.copy()
>>> copy2 = dict(x)
>>> import copy
>>> copy3 = copy.deepcopy(x)
>>> source['a'] = 10  # a change to first-level properties won't affect copies
>>> source
{'a': 10, 'c': 3, 'b': {'m': 4, 'o': 6, 'n': 5}}
>>> copy1
{'a': 1, 'c': 3, 'b': {'m': 4, 'o': 6, 'n': 5}}
>>> copy2
{'a': 1, 'c': 3, 'b': {'m': 4, 'o': 6, 'n': 5}}
>>> copy3
{'a': 1, 'c': 3, 'b': {'m': 4, 'o': 6, 'n': 5}}
>>> source['b']['m'] = 40  # a change to deep properties WILL affect shallow copies 'b.m' property
>>> source
{'a': 10, 'c': 3, 'b': {'m': 40, 'o': 6, 'n': 5}}
>>> copy1
{'a': 1, 'c': 3, 'b': {'m': 40, 'o': 6, 'n': 5}}
>>> copy2
{'a': 1, 'c': 3, 'b': {'m': 40, 'o': 6, 'n': 5}}
>>> copy3  # Deep copy's 'b.m' property is unaffected
{'a': 1, 'c': 3, 'b': {'m': 4, 'o': 6, 'n': 5}}

Em relação às cópias rasas e profundas, do módulo Python copydocs :

A diferença entre cópia superficial e profunda é relevante apenas para objetos compostos (objetos que contêm outros objetos, como listas ou instâncias de classe):

• Uma cópia superficial constrói um novo objeto composto e, em seguida, (na medida do possível) insere referências aos objetos encontrados no original.
• Uma cópia profunda constrói um novo objeto composto e, em seguida, recursivamente, insere cópias dos objetos encontrados no original.

No python 3.5+, há uma maneira mais fácil de obter uma cópia superficial usando o ** operador de descompactação. Definido pelo Pep 448 .

>>>dict1 = {"key1": "value1", "key2": "value2"}
>>>dict2 = {**dict1}
>>>print(dict2)
{'key1': 'value1', 'key2': 'value2'}
>>>dict2["key2"] = "WHY?!"
>>>print(dict1)
{'key1': 'value1', 'key2': 'value2'}
>>>print(dict2)
{'key1': 'value1', 'key2': 'WHY?!'}

** descompacta o dicionário em um novo dicionário que é atribuído ao dict2.

Também podemos confirmar que cada dicionário tem um ID distinto.

>>>id(dict1)
 178192816

>>>id(dict2)
 178192600

Se uma cópia profunda for necessária, então copy.deepcopy () ainda é o caminho a percorrer.

As melhores e as maneiras mais fáceis de criar uma cópia de um dict no Python 2.7 e 3 são ...

Para criar uma cópia do dicionário simples (nível único):

1. Usando o método dict () , em vez de gerar uma referência que aponte para o dict existente.

my_dict1 = dict()
my_dict1["message"] = "Hello Python"
print(my_dict1)  # {'message':'Hello Python'}

my_dict2 = dict(my_dict1)
print(my_dict2)  # {'message':'Hello Python'}

# Made changes in my_dict1 
my_dict1["name"] = "Emrit"
print(my_dict1)  # {'message':'Hello Python', 'name' : 'Emrit'}
print(my_dict2)  # {'message':'Hello Python'}

2. Usando o método update () interno do dicionário python.

my_dict2 = dict()
my_dict2.update(my_dict1)
print(my_dict2)  # {'message':'Hello Python'}

# Made changes in my_dict1 
my_dict1["name"] = "Emrit"
print(my_dict1)  # {'message':'Hello Python', 'name' : 'Emrit'}
print(my_dict2)  # {'message':'Hello Python'}

Para criar uma cópia do dicionário aninhado ou complexo:

Use o módulo de cópia embutido , que fornece operações genéricas de cópia superficial e profunda. Este módulo está presente no Python 2.7 e 3. *

import copy

my_dict2 = copy.deepcopy(my_dict1)

Você também pode criar um novo dicionário com uma compreensão do dicionário. Isso evita a importação de cópia.

dout = dict((k,v) for k,v in mydict.items())

Obviamente, em python> = 2.7, você pode fazer:

dout = {k:v for k,v in mydict.items()}

Mas para compatibilidade com versões anteriores, o método top é melhor.

Além das outras soluções fornecidas, você pode usar **para integrar o dicionário em um dicionário vazio, por exemplo,

shallow_copy_of_other_dict = {**other_dict}.

Agora você terá uma cópia "rasa" de other_dict.

Aplicado ao seu exemplo:

>>> dict1 = {"key1": "value1", "key2": "value2"}
>>> dict2 = {**dict1}
>>> dict2
{'key1': 'value1', 'key2': 'value2'}
>>> dict2["key2"] = "WHY?!"
>>> dict1
{'key1': 'value1', 'key2': 'value2'}
>>>

Ponteiro: Diferença entre cópias rasas e profundas

As instruções de atribuição no Python não copiam objetos, elas criam ligações entre um destino e um objeto.

portanto, dict2 = dict1resulta em outra ligação entre dict2e o objeto quedict1 refere.

Se você deseja copiar um ditado, pode usar o copy module. O módulo de cópia possui duas interfaces:

copy.copy(x)
Return a shallow copy of x.

copy.deepcopy(x)
Return a deep copy of x.

A diferença entre cópia superficial e profunda é relevante apenas para objetos compostos (objetos que contêm outros objetos, como listas ou instâncias de classe):

Uma cópia superficial constrói um novo objeto composto e, em seguida, (na medida do possível) insere referências aos objetos encontrados no original.

Uma cópia profunda constrói um novo objeto composto e, em seguida, recursivamente, insere cópias dos objetos encontrados no original.

Por exemplo, no python 2.7.9:

>>> import copy
>>> a = [1,2,3,4,['a', 'b']]
>>> b = a
>>> c = copy.copy(a)
>>> d = copy.deepcopy(a)
>>> a.append(5)
>>> a[4].append('c')

e o resultado é:

>>> a
[1, 2, 3, 4, ['a', 'b', 'c'], 5]
>>> b
[1, 2, 3, 4, ['a', 'b', 'c'], 5]
>>> c
[1, 2, 3, 4, ['a', 'b', 'c']]
>>> d
[1, 2, 3, 4, ['a', 'b']]

Você pode copiar e editar a cópia recém-construída de uma só vez, chamando o dictconstrutor com argumentos adicionais de palavras-chave:

>>> dict1 = {"key1": "value1", "key2": "value2"}
>>> dict2 = dict(dict1, key2="WHY?!")
>>> dict1
{'key2': 'value2', 'key1': 'value1'}
>>> dict2
{'key2': 'WHY?!', 'key1': 'value1'}

Isso também me confundiu, inicialmente, porque eu era proveniente de um fundo C.

Em C, uma variável é um local na memória com um tipo definido. A atribuição a uma variável copia os dados no local de memória da variável.

Mas no Python, variáveis ​​agem mais como ponteiros para objetos. Portanto, atribuir uma variável a outra não faz uma cópia, apenas faz o nome da variável apontar para o mesmo objeto.

Toda variável em python (coisas como dict1ou strou __builtins__é um ponteiro para algum "objeto" platônico oculto dentro da máquina.

Se você definir dict1 = dict2, basta apontar dict1para o mesmo objeto (ou local da memória ou qualquer analogia que desejar) como dict2. Agora, o objeto referenciado por dict1é o mesmo objeto referenciado por dict2.

Você pode verificar: dict1 is dict2deve ser True. Além disso, id(dict1)deve ser o mesmo queid(dict2) .

Você quer dict1 = copy(dict2)oudict1 = deepcopy(dict2) .

A diferença entre copye deepcopy? deepcopygarantirá que os elementos dedict2 (você apontou para uma lista?) também sejam cópias.

Não uso deepcopymuito - geralmente é uma prática ruim escrever código que seja necessário (na minha opinião).

dict1é um símbolo que faz referência a um objeto de dicionário subjacente. Atribuir dict1a dict2apenas atribui a mesma referência. Alterar o valor de uma chave por meio do dict2símbolo altera o objeto subjacente, o que também afetadict1 . Isso é confuso.

É muito mais fácil argumentar sobre valores imutáveis ​​do que referências, portanto, faça cópias sempre que possível:

person = {'name': 'Mary', 'age': 25}
one_year_later = {**person, 'age': 26}  # does not mutate person dict

É sintaticamente o mesmo que:

one_year_later = dict(person, age=26)

dict2 = dict1não copia o dicionário. Simplesmente fornece ao programador uma segunda maneira ( dict2) de se referir ao mesmo dicionário.

>>> dict2 = dict1
# dict2 is bind to the same Dict object which binds to dict1, so if you modify dict2, you will modify the dict1

Existem muitas maneiras de copiar o objeto Dict, eu simplesmente uso

dict_1 = {
           'a':1,
           'b':2
         }
dict_2 = {}
dict_2.update(dict_1)

Como outros explicaram, o built-in dictnão faz o que você deseja. Porém, no Python2 (e provavelmente também no 3), você pode criar facilmente uma ValueDictclasse que copia =para ter certeza de que o original não será alterado.

class ValueDict(dict):

    def __ilshift__(self, args):
        result = ValueDict(self)
        if isinstance(args, dict):
            dict.update(result, args)
        else:
            dict.__setitem__(result, *args)
        return result # Pythonic LVALUE modification

    def __irshift__(self, args):
        result = ValueDict(self)
        dict.__delitem__(result, args)
        return result # Pythonic LVALUE modification

    def __setitem__(self, k, v):
        raise AttributeError, \
            "Use \"value_dict<<='%s', ...\" instead of \"d[%s] = ...\"" % (k,k)

    def __delitem__(self, k):
        raise AttributeError, \
            "Use \"value_dict>>='%s'\" instead of \"del d[%s]" % (k,k)

    def update(self, d2):
        raise AttributeError, \
            "Use \"value_dict<<=dict2\" instead of \"value_dict.update(dict2)\""


# test
d = ValueDict()

d <<='apples', 5
d <<='pears', 8
print "d =", d

e = d
e <<='bananas', 1
print "e =", e
print "d =", d

d >>='pears'
print "d =", d
d <<={'blueberries': 2, 'watermelons': 315}
print "d =", d
print "e =", e
print "e['bananas'] =", e['bananas']


# result
d = {'apples': 5, 'pears': 8}
e = {'apples': 5, 'pears': 8, 'bananas': 1}
d = {'apples': 5, 'pears': 8}
d = {'apples': 5}
d = {'watermelons': 315, 'blueberries': 2, 'apples': 5}
e = {'apples': 5, 'pears': 8, 'bananas': 1}
e['bananas'] = 1

# e[0]=3
# would give:
# AttributeError: Use "value_dict<<='0', ..." instead of "d[0] = ..."

Por favor, consulte o padrão de modificação lvalue discutido aqui: Python 2.7 - sintaxe limpa para modificação de lvalue . A principal observação é essa stre intse comporta como valores em Python (mesmo que sejam objetos imutáveis ​​sob o capô). Enquanto você observa isso, observe também que nada é magicamente especial sobre strou int. dictpode ser usado da mesma maneira, e posso pensar em muitos casos em que ValueDictfaz sentido.

o código a seguir, que está no dict, que segue a sintaxe json mais de 3 vezes mais rápido que a cópia em profundidade

def CopyDict(dSrc):
    try:
        return json.loads(json.dumps(dSrc))
    except Exception as e:
        Logger.warning("Can't copy dict the preferred way:"+str(dSrc))
        return deepcopy(dSrc)

Corri para um comportamento peculiar ao tentar copiar profundamente a propriedade do dicionário da classe sem atribuí-la à variável

new = copy.deepcopy(my_class.a)não funciona, ou seja, modificar newmodificamy_class.a

mas se você faz old = my_class.ae então new = copy.deepcopy(old)ele funciona perfeitamente, ou seja, modificar newnão afetamy_class.a

Não sei por que isso acontece, mas espero que ajude a economizar algumas horas! :)

porque, dict2 = dict1, dict2 mantém a referência a dict1. O dict1 e o dict2 apontam para o mesmo local na memória. Este é apenas um caso normal ao trabalhar com objetos mutáveis ​​em python. Ao trabalhar com objetos mutáveis ​​em python, você deve ter cuidado, pois é difícil depurar. Como o exemplo a seguir.

 my_users = {
        'ids':[1,2],
        'blocked_ids':[5,6,7]
 }
 ids = my_users.get('ids')
 ids.extend(my_users.get('blocked_ids')) #all_ids
 print ids#output:[1, 2, 5, 6, 7]
 print my_users #output:{'blocked_ids': [5, 6, 7], 'ids': [1, 2, 5, 6, 7]}

Este exemplo de intenção é obter todos os IDs de usuário, incluindo IDs bloqueados. Obtivemos da variável ids, mas também atualizamos o valor de my_users sem intenção. quando você estendeu os ids com blocked_ids my_users foi atualizado porque ids consulte my_users .

Copiando usando um loop for:

orig = {"X2": 674.5, "X3": 245.0}

copy = {}
for key in orig:
    copy[key] = orig[key]

print(orig) # {'X2': 674.5, 'X3': 245.0}
print(copy) # {'X2': 674.5, 'X3': 245.0}
copy["X2"] = 808
print(orig) # {'X2': 674.5, 'X3': 245.0}
print(copy) # {'X2': 808, 'X3': 245.0}

Você pode usar diretamente:

dict2 = eval(repr(dict1))

em que o objeto dict2 é uma cópia independente do dict1, para que você possa modificar o dict2 sem afetar o dict1.

Isso funciona para qualquer tipo de objeto.