Quand `i = x` et `i = i x` produisent-ils des résultats différents en Python ?

Quand l'affectation et l'augmentation diffèrent : explorer "i = x" par rapport à "i = i x"

L'utilisation de l'opérateur = dans Python peut entraîner un comportement inattendu dans certains scénarios. Examinons les différences entre i = x et i = i x pour comprendre quand ils divergent.

Comprendre la surcharge de l'opérateur

L'opérateur = appelle le iadd si elle existe, ou la méthode add si iadd n'est pas disponible. En revanche, l'opérateur appelle principalement la méthode add.

Objets mutables ou immuables

Le comportement de = dépend du fait que l'objet soit attribué est mutable (peut être modifié) ou immuable (ne peut pas être modifié). Pour les objets immuables, les deux = et créent une nouvelle instance. Cependant, iadd modifie l'objet d'origine et le réaffecte au nom de la variable, écrasant la référence précédente.

Exemple : Listes

Pour illustrer la différence, considérez le code suivant :

a = [1, 2, 3]
b = a
b += [1, 2, 3]
print(a)  # [1, 2, 3, 1, 2, 3]
print(b)  # [1, 2, 3, 1, 2, 3]

Puisque les listes sont mutables, = modifie b en place, ce qui affecte a car les deux variables font référence à la même liste.

Maintenant, considérons :

a = [1, 2, 3]
b = a
b = b + [1, 2, 3]
print(a)  # [1, 2, 3]
print(b)  # [1, 2, 3, 1, 2, 3]

Dans ce cas, b = b [1, 2, 3] crée une nouvelle liste, laissant un inchangé . En effet, appelle la méthode add, qui renvoie une nouvelle instance.

Gestion des exceptions pour ' ='

Dans le cas où x. __add__ n'est pas implémenté ou renvoie NotImplemented, et x et y ont des types différents, l'opérateur se rabat sur y.__radd__ s'il existe. Par conséquent, ce qui suit est équivalent :

foo_instance += bar_instance

foo_instance = bar_instance.__radd__(bar_instance, foo_instance)

Remplacement de sous-classe

Lorsque foo_instance et bar_instance sont de types différents et que bar_instance est une sous-classe de foo_instance, bar_instance.__radd__ sera tenté avant foo_instance.__add__. Cela permet aux sous-classes de remplacer le comportement de leurs superclasses.

Conclusion

Comprendre les différences entre i = x et i = i x est crucial pour éviter des résultats inattendus dans la programmation Python . En sachant quand et comment ces opérateurs se comportent différemment, vous pouvez manipuler efficacement des objets immuables et mutables.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!