Anulando "+ =" en Python? (Método __iadd __())

Question

¿Es posible anular + = en Python?

Answer 1

Sí, anule el método __iadd__. Ejemplo:

def __iadd__(self, other): 
    self.number += other.number 
    return self  

Answer 2

http://docs.python.org/reference/datamodel.html#emulating-numeric-types

Por ejemplo, para ejecutar la instrucción x + = y, donde x es una instancia de una clase que tiene un método __iadd __(), x .__ iadd__ (y) se llama.

Answer 3

Además de la sobrecarga __iadd__ (recuerde que debe volver auto!), También se puede repliegue en __add__, cuando x = y + funcionará como x = x + y. (Esta es una de las trampas del operador + =.)

>>> class A(object): 
... def __init__(self, x): 
...  self.x = x 
... def __add__(self, other): 
...  return A(self.x + other.x) 
>>> a = A(42) 
>>> b = A(3) 
>>> print a.x, b.x 
42 3 
>>> old_id = id(a) 
>>> a += b 
>>> print a.x 
45 
>>> print old_id == id(a) 
False 

Incluso trips up experts:

class Resource(object): 
    class_counter = 0 
    def __init__(self): 
    self.id = self.class_counter 
    self.class_counter += 1 

x = Resource() 
y = Resource() 

¿Qué valores esperas x.id, y.id y Resource.class_counter que tienen?

Answer 4

Además de lo que se da correctamente en las respuestas anteriores, vale la pena aclarar explícitamente que cuando se anula __iadd__, la operación x += y NO finaliza con el final del método __iadd__.

En su lugar, termina con x = x.__iadd__(y). En otras palabras, Python asigna el valor de retorno de su implementación __iadd__ al objeto que está "agregando", DESPUÉS de que se complete la implementación.

Esto significa que es posible mutar el lado izquierdo de la operación x += y para que falle el último paso implícito. Considere lo que puede ocurrir cuando se agrega a algo que está dentro de una lista:

>>> x[1] += y # x has two items

Ahora, si su __iadd__ aplicación (un método de un objeto en x[1]) erróneamente oa propósito elimina el primer elemento (x[0]) desde el principio de la lista, Python ejecutará su método __iadd__) & intente asignar su valor de retorno a x[1]. Que ya no existirá (estará en x[0]), lo que da como resultado un ÌndexError.

O, si sus __iadd__ insertos algo a principios de x del ejemplo anterior, el objeto será en x[2], no x[1], y lo que era antes en x[0] ahora estará en x[1] y asignar el valor de retorno de la __iadd__ invocación.

A menos que uno entienda lo que está sucediendo, los errores resultantes pueden ser una pesadilla para solucionar.