¿Cuándo es "i + = x" diferente de "i = i + x" en Python?

Me dijeron que +=puede tener diferentes efectos que la notación estándar de i = i +. ¿Hay algún caso en el que i += 1sería diferente i = i + 1?

Esto depende completamente del objeto i.

+=llama al __iadd__método (si existe, recurriendo __add__si no existe) mientras que +llama al __add__método ¹ o al __radd__método en algunos casos ² .

Desde una perspectiva API, __iadd__se supone que se usa para modificar objetos mutables en su lugar (devolviendo el objeto que fue mutado), mientras que __add__debería devolver una nueva instancia de algo. Para los objetos inmutables , ambos métodos devuelven una nueva instancia, pero __iadd__colocarán la nueva instancia en el espacio de nombres actual con el mismo nombre que tenía la instancia anterior. Esta es la razón por

i = 1
i += 1

Parece aumentar i. En realidad, obtienes un nuevo entero y lo asignas "encima" i, perdiendo una referencia al entero anterior. En este caso, i += 1es exactamente lo mismo que i = i + 1. Pero, con la mayoría de los objetos mutables, es una historia diferente:

Como ejemplo 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]

comparado con:

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

Nótese como en el primer ejemplo, puesto by ahacer referencia al mismo objeto, cuando se utiliza +=en b, lo que realmente cambia b(y ave que el cambio también - Después de todo, se hace referencia a la misma lista). Sin embargo, en el segundo caso, cuando lo hago b = b + [1, 2, 3], toma la lista que bhace referencia y la concatena con una nueva lista [1, 2, 3]. Luego almacena la lista concatenada en el espacio de nombres actual como b: sin tener en cuenta cuál bera la línea anterior.

^{1 En la expresión x + y, si x.__add__no se ejecuta o si x.__add__(y)vuelve NotImplemented y xy ytienen diferentes tipos , a continuación, x + yintenta llamar y.__radd__(x). Entonces, en el caso donde tienes}

^{foo_instance += bar_instance}

^{si Foono se implementa __add__o __iadd__el resultado aquí es el mismo que}

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

^{2 En la expresión foo_instance + bar_instance, bar_instance.__radd__se intentará antes foo_instance.__add__ si el tipo de bar_instancees una subclase del tipo de foo_instance(por ejemplo issubclass(Bar, Foo)). El racional para esto es porque Bares en cierto sentido un objeto "nivel más alto" que Fooasí Bardebe recibir la opción de anular Fooel comportamiento 's.}

Debajo de las sábanas, i += 1hace algo como esto:

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

Mientras i = i + 1hace algo como esto:

i = i.__add__(1)

Esta es una ligera simplificación excesiva, pero se entiende la idea: Python le da a los tipos una forma de manejarlos +=especialmente, creando un __iadd__método y un __add__.

La intención es que los tipos mutables, como list, se muten a sí mismos __iadd__(y luego regresen self, a menos que esté haciendo algo muy complicado), mientras que los tipos inmutables, como int, simplemente no lo implementarán.

Por ejemplo:

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

Porque l2es el mismo objeto que l1, y tú mutaste l1, tú también mutaste l2.

Pero:

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

Aquí no mutaste l1; en su lugar, creó una nueva lista l1 + [3]y rebotó el nombre l1para señalarla, dejando de l2apuntar a la lista original.

(En la +=versión, también estaba volviendo a vincular l1, es solo que en ese caso lo estaba volviendo a listvincular a la misma que ya estaba vinculada, por lo que generalmente puede ignorar esa parte).

Aquí hay un ejemplo que se compara directamente 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]