Cómo copiar un diccionario y solo editar la copia

¿Alguien puede explicarme esto? Esto no tiene ningún sentido para mí.

Copio un diccionario en otro y edito el segundo y ambos cambian. ¿Por qué está pasando esto?

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

Python nunca copia implícitamente objetos. Cuando establece dict2 = dict1, hace que se refieran al mismo objeto dict exacto, por lo que cuando lo muta, todas las referencias se refieren al objeto en su estado actual.

Si desea copiar el dict (lo cual es raro), debe hacerlo explícitamente con

dict2 = dict(dict1)

o

dict2 = dict1.copy()

Cuando asigna dict2 = dict1, no está haciendo una copia de dict1, resulta en dict2ser solo otro nombre para dict1.

Para copiar los tipos mutables como diccionarios, use copy/ deepcopydel copymódulo.

import copy

dict2 = copy.deepcopy(dict1)

Mientras dict.copy(), y dict(dict1)genera una copia, sólo son poco profundas copias. Si desea una copia profunda , copy.deepcopy(dict1)se requiere. Un ejemplo:

>>> 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}}

Con respecto a las copias superficiales y profundas, de los documentos del módulo Pythoncopy :

La diferencia entre copia superficial y profunda solo es relevante para objetos compuestos (objetos que contienen otros objetos, como listas o instancias de clase):

• Una copia superficial construye un nuevo objeto compuesto y luego (en la medida de lo posible) inserta referencias en él a los objetos encontrados en el original.
• Una copia profunda construye un nuevo objeto compuesto y luego, recursivamente, inserta copias en él de los objetos encontrados en el original.

En python 3.5+ hay una manera más fácil de lograr una copia superficial utilizando el operador de desempaquetado **. Definido por 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?!'}

** desempaqueta el diccionario en un nuevo diccionario que luego se asigna a dict2.

También podemos confirmar que cada diccionario tiene una identificación distinta.

>>>id(dict1)
 178192816

>>>id(dict2)
 178192600

Si se necesita una copia profunda, copy.deepcopy () sigue siendo el camino a seguir.

Las mejores y más fáciles formas de crear una copia de un dict en Python 2.7 y 3 son ...

Para crear una copia del diccionario simple (de un solo nivel):

1. Usando el método dict () , en lugar de generar una referencia que apunte al 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 el método incorporado update () del diccionario 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 crear una copia de un diccionario anidado o complejo:

Utilice el módulo de copia incorporado , que proporciona operaciones genéricas de copia superficial y profunda. Este módulo está presente en Python 2.7 y 3. *

import copy

my_dict2 = copy.deepcopy(my_dict1)

También puede crear un nuevo diccionario con una comprensión del diccionario. Esto evita importar la copia.

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

Por supuesto, en python> = 2.7 puedes hacer:

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

Pero para la compatibilidad con versiones anteriores, el método superior es mejor.

Además de las otras soluciones proporcionadas, puede utilizar **para integrar el diccionario en un diccionario vacío, por ejemplo,

shallow_copy_of_other_dict = {**other_dict}.

Ahora tendrá una copia "superficial" de other_dict.

Aplicado a tu ejemplo:

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

Puntero: diferencia entre copias superficiales y profundas

Las declaraciones de asignación en Python no copian objetos, crean enlaces entre un objetivo y un objeto.

entonces, dict2 = dict1resulta otro enlace entre dict2y el objeto al que se dict1refieren.

si quieres copiar un dict, puedes usar el copy module. El módulo de copia tiene dos interfaces:

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

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

La diferencia entre copia superficial y profunda solo es relevante para objetos compuestos (objetos que contienen otros objetos, como listas o instancias de clase):

Una copia superficial construye un nuevo objeto compuesto y luego (en la medida de lo posible) inserta referencias en él a los objetos encontrados en el original.

Una copia profunda construye un nuevo objeto compuesto y luego, recursivamente, inserta copias de los objetos encontrados en el original.

Por ejemplo, en 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')

y el resultado es:

>>> 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']]

Puede copiar y editar la copia recién construida de una vez llamando al dictconstructor con argumentos de palabras clave adicionales:

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

Esto también me confundió, inicialmente, porque venía de un fondo C.

En C, una variable es una ubicación en la memoria con un tipo definido. La asignación a una variable copia los datos en la ubicación de memoria de la variable.

Pero en Python, las variables actúan más como punteros a los objetos. Entonces, asignar una variable a otra no hace una copia, solo hace que el nombre de la variable apunte al mismo objeto.

Cada variable en Python (cosas como dict1o stro __builtins__es un puntero a algún "objeto" platónico oculto dentro de la máquina.

Si configura dict1 = dict2, solo apunta dict1al mismo objeto (o ubicación de memoria, o cualquier analogía que desee) como dict2. Ahora, el objeto al que hace referencia dict1es el mismo objeto al que hace referencia dict2.

Puede verificar: dict1 is dict2debería ser True. Además, id(dict1)debe ser lo mismo que id(dict2).

Tu quieres dict1 = copy(dict2), o dict1 = deepcopy(dict2).

La diferencia entre copyy deepcopy? deepcopyse asegurará de que los elementos de dict2(¿lo señaló en una lista?) también sean copias.

No uso deepcopymucho; por lo general, es una mala práctica escribir código que lo necesita (en mi opinión).

dict1es un símbolo que hace referencia a un objeto de diccionario subyacente. Asignar dict1a dict2simplemente asigna la misma referencia. Cambiar el valor de una clave a través del dict2símbolo cambia el objeto subyacente, lo que también afecta dict1. Esto es confuso.

Es mucho más fácil razonar sobre valores inmutables que referencias, así que haga copias siempre que sea posible:

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

Esto es sintácticamente lo mismo que:

one_year_later = dict(person, age=26)

dict2 = dict1No copia el diccionario. Simplemente le da al programador una segunda forma ( dict2) para referirse al mismo diccionario.

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

Hay muchas formas de copiar objetos Dict, simplemente uso

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

Como otros han explicado, el incorporado dictno hace lo que quieres. Pero en Python2 (y probablemente también en el 3) puedes crear fácilmente una ValueDictclase con la que copiar =para que puedas estar seguro de que el original no cambiará.

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] = ..."

Consulte el patrón de modificación de lvalue discutido aquí: Python 2.7 - sintaxis limpia para la modificación de lvalue . La observación clave es eso stry intcomportarse como valores en Python (a pesar de que en realidad son objetos inmutables bajo el capó). Mientras observa eso, tenga en cuenta también que nada es mágicamente especial sobre stro int. dictpuede usarse de la misma manera, y puedo pensar en muchos casos en los que ValueDicttiene sentido.

el siguiente código, que se encuentra en los dictados que sigue la sintaxis json más de 3 veces más rápido que la copia profunda

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)

Me encontré con un comportamiento peculiar al intentar copiar en profundidad la propiedad del diccionario de la clase sin asignarla a la variable

new = copy.deepcopy(my_class.a)no funciona, es decir, modificar newmodificamy_class.a

pero si lo hace old = my_class.ay new = copy.deepcopy(old)funciona perfectamente, es decir, modificar newno afectamy_class.a

No estoy seguro de por qué sucede esto, ¡pero espero que ayude a ahorrar algunas horas! :)

porque, dict2 = dict1, dict2 contiene la referencia a dict1. Tanto dict1 como dict2 apuntan a la misma ubicación en la memoria. Este es solo un caso normal mientras se trabaja con objetos mutables en python. Cuando trabaje con objetos mutables en python, debe tener cuidado ya que es difícil de depurar. Tal como el siguiente ejemplo.

 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]}

La intención de este ejemplo es obtener todos los ID de usuario, incluidos los ID bloqueados. Eso lo obtuvimos de la variable ids pero también actualizamos el valor de my_users sin querer. cuando extendió los identificadores con blocks_ids, my_users se actualizaron porque los identificadores se refieren a my_users .

Copiar usando un bucle 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}

Puedes usar directamente:

dict2 = eval(repr(dict1))

donde objeto dict2 es una copia independiente de dict1, por lo que puede modificar dict2 sin afectar a dict1.

Esto funciona para cualquier tipo de objeto.