Quando "i + = x" è diverso da "i = i + x" in Python?

Mi è stato detto che +=possono avere effetti diversi rispetto alla notazione standard di i = i +. C'è un caso in cui i += 1sarebbe diverso i = i + 1?

Questo dipende interamente dall'oggetto i.

+=chiama il __iadd__metodo (se esiste - riconnettendosi __add__se non esiste) mentre +chiama il __add__metodo ¹ o il __radd__metodo in alcuni casi ² .

Dal punto di vista dell'API, __iadd__dovrebbe essere usato per modificare gli oggetti mutabili sul posto (restituendo l'oggetto che è stato mutato) mentre __add__dovrebbe restituire una nuova istanza di qualcosa. Per oggetti immutabili , entrambi i metodi restituiscono una nuova istanza, ma __iadd__inseriranno la nuova istanza nello spazio dei nomi corrente con lo stesso nome della vecchia istanza. Ecco perché

i = 1
i += 1

sembra aumentare i. In realtà, ottieni un nuovo numero intero e lo assegni "sopra" i- perdendo un riferimento al vecchio numero intero. In questo caso, i += 1è esattamente lo stesso di i = i + 1. Ma, con la maggior parte degli oggetti mutabili, è una storia diversa:

A titolo di esempio concreto:

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]

rispetto a:

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

nota come nel primo esempio, dato che be ariferimento allo stesso oggetto, quando lo uso +=su b, in realtà cambia b(e avede anche quel cambiamento - Dopotutto, fa riferimento allo stesso elenco). Nel secondo caso, tuttavia, quando lo faccio b = b + [1, 2, 3], prende l'elenco che bfa riferimento e lo concatena con un nuovo elenco [1, 2, 3]. Quindi memorizza l'elenco concatenato nello spazio dei nomi corrente come b- Senza riguardo a quella che bera la linea prima.

^{1 Nell'espressione x + y, se x.__add__non è attuato o se x.__add__(y)i rendimenti NotImplemented e xed yhanno tipi diversi , quindi x + ytenta di chiamare y.__radd__(x). Quindi, nel caso in cui tu abbia}

^{foo_instance += bar_instance}

^{se Foonon implementa __add__o __iadd__quindi il risultato qui è lo stesso di}

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

^{2 Nell'espressione foo_instance + bar_instance, bar_instance.__radd__verrà provato prima foo_instance.__add__ se il tipo di bar_instanceè una sottoclasse del tipo di foo_instance(ad es issubclass(Bar, Foo).). Il razionale di questo è perché Barè in un certo senso un oggetto "di livello superiore" rispetto Foocosì Bardovrebbe ottenere la possibilità di sovrascrivere Foo's comportamento.}

Sotto le coperte, i += 1fa qualcosa del genere:

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

Mentre i = i + 1fa qualcosa del genere:

i = i.__add__(1)

Questa è una leggera semplificazione eccessiva, ma hai l'idea: Python offre ai tipi un modo di gestire in modo +=speciale, creando un __iadd__metodo oltre che un __add__.

L'intenzione è che i tipi mutabili, come list, si trasformino __iadd__(e poi ritornino self, a meno che tu non stia facendo qualcosa di molto complicato), mentre i tipi immutabili, come int, non lo implementeranno.

Per esempio:

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

Perché l2è lo stesso oggetto di l1, e tu sei mutato l1, anche tu sei mutato l2.

Ma:

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

Qui, non hai mutato l1; invece, hai creato un nuovo elenco l1 + [3]e rimbalzato il nome l1per puntarlo, lasciando il l2puntamento sull'elenco originale.

(Nella +=versione, stavi anche eseguendo il rebinding l1, è solo che in quel caso lo stavi legando allo stesso a listcui era già legato, quindi di solito puoi ignorare quella parte.)

Ecco un esempio che si confronta direttamente i += xcon 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]