Ich bin einmal auf eine Frage wie diese gestoßen: Ein Element in einem Dictionary ist eine Liste. Weisen Sie dieses Listenelement einer Variablen zu und ändern Sie dann den Wert eines Elements in der Liste. Infolgedessen wurde auch die Liste im Dictionary geändert. Die Frage lautete wie folgt:
dict = {'a':[1,2,3,4,5],'b':2}
x = dict['a']
for i in range(5):
x[i] = 0
print(dict['a'])
Die Programmausgabe sieht wie folgt aus: [0, 0, 0, 0, 0]
Dies betrifft die Frage, ob die Zuweisung in Python per Referenz oder per Kopie erfolgt, d. h. ob die Zuweisung per Wert oder per Adresse erfolgt. Im obigen Problem verursachte die Zuweisung des Wertes von "a" an x die obige Situation. Wenn der Wert von "b" x zugewiesen würde, dann würde sich das Ändern des Wertes von x nicht auf den Wert des dict-Dictionary auswirken.
>>> 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}
>>>
Da stellt sich die Frage: Unter welchen Umständen erfolgt eine Variablenzuweisung per Wert (Kopie) und unter welchen Umständen per Adresse (Referenz)?
1. Direkte Kopie
Wenn wir uns nicht sicher sind, ob es sich um eine Referenz oder eine Kopie handelt, können wir explizit kopieren. Zum Beispiel haben Dictionary-Objekte selbst eine copy-Methode:
x=dict.copy()
Objekte ohne copy-Methode können ebenfalls kopiert werden. Hier führen wir das Konzept der Deep Copy ein. Deep Copy ist eine deepcopy-Methode, die vom copy-Modul von Python bereitgestellt wird. Deep Copy kopiert alle mit der ursprünglichen Variable verbundenen Daten vollständig und erzeugt einen identischen Satz von Inhalten im Speicher. In diesem Prozess wirkt sich jede Änderung, die wir an einer der beiden Variablen vornehmen, nicht auf die andere Variable aus. Mit demselben Code wie oben, wenn wir ihn wie folgt ändern:
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'])
Die Ausgabe zeigt, dass der dict-Wert nicht beeinflusst wird.
Neben Deep Copy bietet das copy-Modul auch eine copy-Methode, die als Shallow Copy bekannt ist. Für einfache Objekte sind Deep Copy und Shallow Copy gleich. Die copy-Methode des obigen Dictionary-Objekts ist eine Shallow Copy.
>>> 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}
>>>
Bei Shallow Copy beeinflussen sich Änderungen auf der ersten Ebene nicht gegenseitig (z. B. das Ändern des Werts von dict b im obigen Beispiel), während sich Änderungen auf der zweiten Ebene (z. B. das Ändern des list-Werts von dict a im obigen Beispiel) gegenseitig beeinflussen – ändere eines, und die anderen ändern sich mit. Sehen wir uns die id an:
>>> id(dict) 20109472 >>> id(dd) 20244496 >>> id(ee) 20495072 >>> id(dd['a']) 20272112 >>> id(ee['a']) 20272112 >>> id(dict['a']) 20272112 >>>
Es ist zu sehen, dass die IDs der verschiedenen Dictionary-Kopien unterschiedlich sind, aber die IDs der Werte in dict a sind gleich. Wenn wir eine echte Kopie benötigen, verwenden wir Deep Copy.
2. Übergaberegeln
Die Zuweisung in Python unterscheidet nicht explizit zwischen Kopie und Referenz. Im Allgemeinen erfolgt die Übergabe statischer Variablen per Kopie und die Übergabe dynamischer Variablen per Referenz. (Hinweis: Die erste Übergabe einer statischen Variable erfolgt ebenfalls per Referenz. Wenn die statische Variable geändert werden muss, da sie nicht geändert werden kann, muss ein neuer Speicherplatz erstellt werden, um Daten zu speichern.)
- Strings, Zahlen und Tupel sind alle statische Variablen.
- Listen und Dictionaries sind dynamische Variablen.
Variablen sind manchmal komplex, und es können Kombinationen auftreten, wie ein Dictionary, das eine Liste enthält, oder eine Liste, die ein Dictionary enthält. Bei der Zuweisung gehört eine Variable jedoch immer einem bestimmten Typ an. Wenn Sie sich bei der Situation wirklich unsicher sind, können Sie sie mit der Funktion id() testen. Wenn es sich um eine Referenz handelt, sind die Adressen, auf die die beiden Variablen zeigen, dieselben. Zum Beispiel:
>>> a=6 >>> id(a) 10413476 >>> b=a >>> id(b) 10413476 >>> b=8 >>> id(b) 10413452 >>>
Bevor die Variable b geändert wird, zeigen a und b auf dieselbe Adresse. Nach dem Ändern von b ändert sich die Adresse.
Originallink: https://blog.csdn.net/iamlaosong/article/details/77505510