Wann unterscheidet sich "i + = x" von "i = i + x" in Python?

Mir wurde gesagt, dass +=dies andere Auswirkungen haben kann als die Standardnotation von i = i +. Gibt es einen Fall, in dem i += 1es anders wäre als i = i + 1?

Dies hängt ganz vom Objekt ab i.

+=ruft die __iadd__Methode auf (falls vorhanden) - __add__greift zurück, wenn sie nicht vorhanden ist), während +die __add__Methode ¹ oder __radd__in einigen Fällen die Methode ² aufgerufen wird .

Aus API-Sicht __iadd__soll es verwendet werden, um veränderbare Objekte an Ort und Stelle zu ändern (das mutierte Objekt zurückzugeben), während __add__eine neue Instanz von etwas zurückgegeben werden soll. Bei unveränderlichen Objekten geben beide Methoden eine neue Instanz zurück, __iadd__setzen die neue Instanz jedoch in den aktuellen Namespace mit demselben Namen wie die alte Instanz. Deshalb

i = 1
i += 1

scheint zu erhöhen i. In Wirklichkeit erhalten Sie eine neue Ganzzahl und weisen sie "über" zu i- wobei ein Verweis auf die alte Ganzzahl verloren geht. In diesem Fall i += 1ist genau das gleiche wie i = i + 1. Bei den meisten veränderlichen Objekten ist dies jedoch eine andere Geschichte:

Als konkretes Beispiel:

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]

verglichen mit:

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

Beachten Sie, wie im ersten Beispiel, da bund adas gleiche Objekt verweisen, wenn ich +=auf b, es ändert sich tatsächlich b(und asieht , dass der Wandel zu - Schließlich ist es die gleiche Liste ist Referenzierung). Im zweiten Fall b = b + [1, 2, 3]nimmt dies jedoch die Liste, auf bdie verwiesen wird, und verkettet sie mit einer neuen Liste [1, 2, 3]. Anschließend wird die verkettete Liste im aktuellen Namespace wie folgt gespeichert: b- Ohne Rücksicht auf die vorherige bZeile.

^{1 In dem Ausdruck x + y, wenn x.__add__nicht implementiert ist oder wenn x.__add__(y)Erträge NotImplemented und xund yverschiedene Typen haben , dann x + yversucht Anruf y.__radd__(x). Also, in dem Fall, wo Sie haben}

^{foo_instance += bar_instance}

^{Wenn Foonicht implementiert __add__oder __iadd__dann ist das Ergebnis hier das gleiche wie}

^{foo_instance = bar_instance.__radd__(bar_instance, foo_instance)}

^{2 In dem Ausdruck foo_instance + bar_instance, bar_instance.__radd__wird versucht werden , bevor , foo_instance.__add__ wenn die Art des bar_instanceeine Unterklasse von der Art der ist foo_instance(zB issubclass(Bar, Foo)). Der Grund für dies ist , weil Barin einem gewissen Sinne ist ein „höhere Ebene“ Objekt als Fooso Barsollte die Möglichkeit erhalten , zu überschreiben Foo‚s Verhalten.}

Macht unter der Decke i += 1so etwas:

try:
    i = i.__iadd__(1)
except AttributeError:
    i = i.__add__(1)

Während i = i + 1macht so etwas:

i = i.__add__(1)

Dies ist eine leichte Vereinfachung, aber Sie haben die Idee: Python bietet Typen eine Möglichkeit, +=speziell damit umzugehen, indem sie sowohl eine __iadd__Methode als auch eine erstellen __add__.

Die Absicht ist, dass sich veränderbare Typen wie listmutieren __iadd__(und dann zurückkehren self, es sei denn, Sie tun etwas sehr Kniffliges), während unveränderliche Typen wie intes einfach nicht implementieren.

Beispielsweise:

>>> l1 = []
>>> l2 = l1
>>> l1 += [3]
>>> l2
[3]

Weil l2es dasselbe Objekt ist wie l1und Sie mutiert haben l1, haben Sie auch mutiert l2.

Aber:

>>> l1 = []
>>> l2 = l1
>>> l1 = l1 + [3]
>>> l2
[]

Hier hast du nicht mutiert l1; Stattdessen haben Sie eine neue Liste erstellt l1 + [3]und den Namen neu l1gebunden, um l2darauf zu zeigen, wobei Sie auf die ursprüngliche Liste zeigen.

(In der +=Version haben Sie auch neu gebunden. l1In diesem Fall haben Sie es nur an das listgebunden, an das es bereits gebunden war, sodass Sie diesen Teil normalerweise ignorieren können.)

Hier ist ein Beispiel , das direkt vergleicht i += xmit i = i + x:

def foo(x):
  x = x + [42]

def bar(x):
  x += [42]

c = [27]
foo(c); # c is not changed
bar(c); # c is changed to [27, 42]