J'ai déjà rencontré une question comme celle-ci : un élément d'un dictionnaire est une liste. Affectez cet élément de liste à une variable, puis modifiez la valeur d'un élément de la liste. En conséquence, la liste dans le dictionnaire a également été modifiée. La question était la suivante :

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

La sortie du programme est la suivante : [0, 0, 0, 0, 0]

Cela implique la question de savoir si l'affectation en Python se fait par référence ou par copie, c'est-à-dire si l'affectation se fait par valeur ou par adresse. Dans le problème ci-dessus, affecter la valeur de "a" à x a provoqué la situation ci-dessus. Si la valeur de "b" était affectée à x, alors lorsque nous modifions la valeur de x, la valeur du dictionnaire dict ne serait pas affectée.

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

La question se pose donc : dans quelles circonstances l'affectation de variable se fait-elle par valeur (copie), et dans quelles circonstances se fait-elle par adresse (référence) ?

1. Copie directe

Lorsque nous ne sommes pas sûrs qu'il s'agisse d'une référence ou d'une copie, nous pouvons copier explicitement. Par exemple, les objets dictionnaire eux-mêmes ont une méthode copy :

x=dict.copy()

Les objets sans méthode copy peuvent aussi être copiés. Nous introduisons ici le concept de copie profonde. La copie profonde est une méthode deepcopy fournie par le module copy de Python. La copie profonde copie complètement toutes les données associées à la variable d'origine et génère un ensemble identique de contenu en mémoire. Dans ce processus, toute modification que nous apportons à l'une des deux variables n'affectera pas l'autre variable. En utilisant le même code que ci-dessus, si nous le modifions comme suit :

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

La sortie montre que la valeur de dict n'est pas affectée.

En plus de la copie profonde, le module copy fournit également une méthode copy, appelée copie superficielle. Pour les objets simples, la copie profonde et la copie superficielle sont identiques. La méthode copy de l'objet dictionnaire ci-dessus est une copie superficielle.

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

Avec une copie superficielle, les modifications du premier niveau ne s'affectent pas mutuellement (comme modifier la valeur de dict b dans l'exemple ci-dessus), tandis que les modifications du second niveau (comme modifier la valeur de liste de dict a dans l'exemple ci-dessus) s'affectent mutuellement — modifiez l'une, et les autres changent avec elle. Regardons l'id :

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

On peut voir que les id des différentes copies du dictionnaire sont différents, mais que les id des valeurs dans dict a sont les mêmes. Si nous avons besoin d'une véritable copie, utilisez la copie profonde.

2. Règles de passage

L'affectation en Python ne distingue pas explicitement entre copie et référence. Généralement, le passage des variables statiques se fait par copie, et le passage des variables dynamiques se fait par référence. (Remarque : le premier passage d'une variable statique se fait aussi par référence. Lorsqu'il faut modifier la variable statique, comme elle ne peut pas être changée, un nouvel espace doit être créé pour stocker les données.)

  • Les chaînes de caractères, les nombres et les tuples sont tous des variables statiques.
  • Les listes et les dictionnaires sont des variables dynamiques.

Les variables sont parfois complexes, et des combinaisons peuvent se produire, comme un dictionnaire contenant une liste, ou une liste contenant un dictionnaire. Mais lors de l'affectation, elles appartiennent toujours à un certain type. Si vous n'êtes vraiment pas sûr de la situation, vous pouvez la tester à l'aide de la fonction id(). S'il s'agit d'une référence, les adresses pointées par les deux variables sont identiques. Par exemple :

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

Avant de modifier la variable b, a et b pointent vers la même adresse. Après avoir modifié b, l'adresse change.

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