Una vez vi un problema: un elemento de un diccionario es una lista. Asigné ese elemento de lista a una variable, y luego modifiqué el valor de un elemento en esa lista, y descubrí que la lista en el diccionario también se modificaba. El problema era el siguiente:

dict = {'a':[1,2,3,4,5],'b':2}
x = dict['a']
for i in range(5):
    x[i] = 0
print(dict['a'])

El resultado de ejecución del programa es el siguiente: [0, 0, 0, 0, 0]

Aquí se trata de si la asignación en Python es una referencia o una copia, es decir, si al asignar se pasa el valor o la dirección (referencia). En el problema anterior, se asignó el valor de "a" a x y ocurrió la situación mencionada. Si se hubiera asignado el valor de "b" a x, al modificar el valor de x, el valor del diccionario dict no se vería afectado.

>>> dict = {'a':[1,2,3,4,5],'b':2}
>>> x = dict['b']
>>> x
2
>>> x=x+3
>>> x
5
>>> dict
{'a': [1, 2, 3, 4, 5], 'b': 2}
>>>

Entonces surge la pregunta: ¿cuándo la asignación de variables es por valor (copia) y cuándo por dirección (referencia)?

1. Copia directa

Cuando no sabemos si es referencia o copia, podemos copiar explícitamente. Por ejemplo, los objetos de diccionario tienen su propio método de copia:

x=dict.copy()

Los objetos que no tienen método de copia también se pueden copiar. Aquí introducimos el concepto de copia profunda (deep copy): es el método deepcopy que proporciona el módulo copy de Python. La copia profunda copia completamente todos los datos relacionados con la variable original y genera un contenido completamente idéntico en memoria; en este proceso, cualquier modificación que hagamos a una de las dos variables no afectará a las demás. Con el código anterior, si lo cambiamos así:

import copy
dict = {'a':[1,2,3,4,5],'b':2}
x = copy.deepcopy(dict['a'])
for i in range(5):
    x[i] = 0
print(dict['a'])

El resultado de ejecución muestra que el valor de dict no se ve afectado.

Además de la copia profunda, el módulo copy también proporciona un método copy, llamado copia superficial (shallow copy). Para objetos simples, la copia profunda y la superficial son iguales. El método copy del objeto dict anterior es una copia superficial.

>>> dict
{'a': [8, 2, 3, 4, 5], 'b': 4}
>>> dd=copy.copy(dict)
>>> dd
{'a': [8, 2, 3, 4, 5], 'b': 4}
>>> dd['a'][0]=7
>>> dd
{'a': [7, 2, 3, 4, 5], 'b': 4}
>>> dict
{'a': [7, 2, 3, 4, 5], 'b': 4}
>>> ee=dict.copy()
>>> ee
{'a': [7, 2, 3, 4, 5], 'b': 4}
>>> ee['a'][0]=9
>>> ee
{'a': [9, 2, 3, 4, 5], 'b': 4}
>>> dict
{'a': [9, 2, 3, 4, 5], 'b': 4}
>>> ee['b']=5
>>> ee
{'a': [9, 2, 3, 4, 5], 'b': 5}
>>> dict
{'a': [9, 2, 3, 4, 5], 'b': 4}
>>>

En la copia superficial, cambiar el primer nivel no se afecta mutuamente (en el ejemplo anterior, la modificación del valor de b en el diccionario), pero el segundo nivel (en el ejemplo anterior, la modificación del valor de lista de a en el diccionario) sí se afecta mutuamente; si se modifica uno, los demás cambian. Veamos el id:

>>> id(dict)
20109472
>>> id(dd)
20244496
>>> id(ee)
20495072
>>> id(dd['a'])
20272112
>>> id(ee['a'])
20272112
>>> id(dict['a'])
20272112
>>>

Se puede ver que los id de las copias del diccionario son diferentes, pero el id del valor de a en el diccionario es el mismo. Si necesitamos una copia en el sentido real, usemos la copia profunda.

2. Reglas de paso

En el proceso de asignación de Python no se distingue claramente entre copia y referencia; generalmente, el paso de variables estáticas es por copia, y el paso de variables dinámicas es por referencia. (Nota: en el primer paso de una variable estática también es por referencia; cuando se necesita modificar una variable estática, como las variables estáticas no se pueden cambiar, es necesario generar un nuevo espacio para almacenar los datos).

  • Las cadenas, los números y las tuplas son variables estáticas.
  • Las listas y los diccionarios son variables dinámicas.

Las variables a veces son más complejas y existen combinaciones, por ejemplo, un diccionario contiene una lista, una lista contiene un diccionario, pero al asignar, siempre pertenece a algún tipo. Si realmente no está claro, se puede probar con la función id() para ver; si es una referencia, las direcciones a las que apuntan las dos variables son las mismas. Por ejemplo:

>>> a=6
>>> id(a)
10413476
>>> b=a
>>> id(b)
10413476
>>> b=8
>>> id(b)
10413452
>>>

Antes de modificar la variable b, las direcciones a las que apuntan a y b son las mismas; después de modificar b, la dirección cambia.

Enlace original: https://blog.csdn.net/iamlaosong/article/details/77505510