À propos de la référence Python

Trébucher en Python

Comme indiqué dans les commentaires, il n'y a pas de passage par référence en Python en premier lieu. Reportez-vous à l'article suivant. https://qiita.com/raccy/items/d4c5e7995a8fc90109ee#_reference-de4299be58ab9d936fcb

Il y a des inexactitudes dans cet article, en partie parce que je l'ai écrit alors que je manquais clairement de compréhension, mais je voudrais le laisser comme un mémo sur la façon dont j'ai fait face aux questions que j'avais à ce moment-là (laisser un mémo). Peut-être pas bon).

Le mystère du passage par référence

Quand j'ai commencé python pour la première fois, la première chose sur laquelle je suis tombé par hasard était la mystérieuse explication que l'on voit souvent partout: «Tous les arguments de python sont passés par référence». J'ai en quelque sorte compris le passage par référence. Cependant, si vous exécutez le code suivant avec python, ...

>>> a=1
>>> b=a
>>> b=2
>>> print(a,b)
1,2

Sera. Eh bien, je pense que c'est naturel, mais je ne suis pas convaincu si c'est passé par référence (il semble naturel que je n'étais pas convaincu car il n'a pas été adopté par référence en premier lieu). Parce que si tu passes par référence

>>> a=1
>>> b=a
>>> b=2
>>> print(a,b)
2,2　 

Parce qu'il devrait l'être (cette compréhension à ce moment-là semble avoir été correcte). Je pensais: "Si b = a par référence, alors si b et a partagent la même mémoire et que b est réécrit, alors a sera également réécrit." En fait, si vous faites quelque chose de similaire dans la liste, c'est ce qui se passe.

>>> a=[1,2,3]
>>> b=a
>>> b[0]=5
>>> print(a,b)
#[5,1,2],[5,1,2] 

S'il est passé par référence, ce sera le comportement. Autrement dit, ceux qui peuvent contenir plusieurs éléments sont passés par référence, et je me suis demandé si seul le type numérique était différent, et quand je vérifie les emplacements mémoire de a et b avec le code suivant, ...

>>> a=1
>>> b=a
>>> print(id(a)==id(b))
True
>>> b=2 
>>> print(id(a)==id(b))
False

Par conséquent, lorsque b = a, b et a se réfèrent au même endroit. Cependant, si b = 2, b fera référence à l'emplacement de l'objet int nouvellement créé avec la valeur 2. D'autre part, a continue de faire référence à l'emplacement d'origine. Je comprends. Mais cette fois, l'exemple de liste est plus déroutant. Alors, quand je regarde ça

>>> a=[1,2,3]
>>> b=a
>>> a_0=a[0]　
>>> b[0]=5
>>> print(a[0])
5
>>> print(id(a)==id(b))
True
>>> print(id(a[0])==id(a_0))
False 
>>> b=[4,5,6]
>>> print(id(a)==id(b))
False

J'en suis enfin convaincu. En d'autres termes.

1. Au moment de b = a, b se réfère également au même endroit que a
2. Si b [0] = 5, un nouvel objet int avec une valeur de 5 sera créé et b [0] se référera à nouveau à cet emplacement.
3. A ce moment, comme a et b se réfèrent au même emplacement, a [0] fait également référence à l'emplacement nouvellement référencé par b [0].
4. Si b = [4,5,6], un nouvel objet de liste sera créé et b fera référence à cet emplacement. À ce stade, a continue de faire référence à l'emplacement d'origine. Il semble qu'il se comporte ainsi.

Je l'ai écrit pendant longtemps, c'est-à-dire Lorsqu'un nouvel objet lui-même est affecté à la variable __, il fera référence à l'endroit où le nouvel objet a été créé au lieu de la destination de référence précédente. __ Il ne devrait y avoir aucun problème dans la pratique.