Sobrecarga de operadores
Sobrecargar un operador es darle significado para tu tipo. Vector(1, 2) + Vector(3, 4) es legible; vector.sumar(otro) también, pero peor. La regla que separa el buen uso del abuso es simple: el operador debe significar lo que ya significa.
En una línea
Sección titulada «En una línea»Sólo sobrecarga si la operación se lee igual que con los tipos nativos; si hay que explicarla, es un método.
El protocolo
Sección titulada «El protocolo»class Vector: __slots__ = ("x", "y")
def __init__(self, x, y): self.x, self.y = x, y
def __add__(self, otro): if not isinstance(otro, Vector): return NotImplemented return Vector(self.x + otro.x, self.y + otro.y)
def __mul__(self, escalar): if not isinstance(escalar, (int, float)): return NotImplemented return Vector(self.x * escalar, self.y * escalar)
def __rmul__(self, escalar): return self * escalar
def __repr__(self): return f"Vector({self.x}, {self.y})"Cuatro piezas:
| Método | Cuándo se usa |
|---|---|
__add__ |
a + b con a de tu tipo |
__radd__ |
b + a cuando b no sabe sumar a |
__iadd__ |
a += b; si no existe, cae a __add__ |
NotImplemented |
«no sé hacerlo»: Python prueba el reflejado |
Lo que cuesta
Sección titulada «Lo que cuesta»| Operación | Coste |
|---|---|
1 + 2 |
9 ns |
(1, 2) + (3, 4) |
11 ns |
Vector(1, 2) + Vector(3, 4) |
197 ns |
python mediciones/04-05-08-descriptores-slots-metaclases.py
Unas dieciocho veces más que una tupla, y la mayor parte no es el operador: es crear el objeto resultado, con su __init__ y sus dos atributos. Eso es inherente a un tipo inmutable de Python; si la creación de objetos domina, la solución es cambiar de representación (Parte II, capítulo 04), no optimizar __add__.
Las reglas que evitan el desastre
Sección titulada «Las reglas que evitan el desastre»- Devuelve un objeto nuevo.
a + bno debe mutara. Si quieres mutar, es+=y se llama__iadd__. - Devuelve
NotImplemented, no lances. Es la señal para que Python pruebe el operando reflejado o lanceTypeErrorcon un mensaje coherente. - No inventes semántica.
+para concatenar, sumar o unir;*para repetir o escalar;==para igualdad de valor.+para «añadir a la base de datos» es un bug de legibilidad. - Mantén la coherencia con
__eq__y__hash__. Un tipo con__eq__y sin__hash__no puede ser clave (Parte I, capítulo 09).
NotImplemented no es una excepción
Sección titulada «NotImplemented no es una excepción»class Dinero: def __add__(self, otro): if not isinstance(otro, Dinero): return NotImplemented # correcto # raise TypeError(...) # incorrectoDevolver NotImplemented permite que otro.__radd__ tenga su oportunidad. Lanzar TypeError impide la cooperación y produce mensajes peores.
La excepción que hay que conocer: NotImplementedError es otra cosa, se lanza en métodos abstractos para decir «no implementado». Se confunden por el nombre y no tienen relación.
La trampa
Sección titulada «La trampa»Cuándo no aplica
Sección titulada «Cuándo no aplica»- Si el método con nombre se lee igual de bien.
tabla.insertar(fila)es más claro quetabla + filasi la semántica no es obvia. - Si el operador cambia de significado según el contexto. Un
*que a veces multiplica y a veces repite confunde. - En tipos de servicio. Una conexión o un repositorio no debería tener
+. - Si no puedes garantizar la inmutabilidad del resultado. Un operador que muta obliga a recordar qué expresión modificó qué.
Ejercicio
Sección titulada «Ejercicio»Implementa una clase Matriz2x2 con __add__, __mul__ (producto de matrices) y __matmul__, de forma que m1 @ m2 haga el producto y m1 * 3 escale. Explica por qué el producto va en @ y no en *.
Solución
class Matriz2x2: __slots__ = ("a", "b", "c", "d")
def __init__(self, a, b, c, d): self.a, self.b, self.c, self.d = a, b, c, d
def __add__(self, otra): if not isinstance(otra, Matriz2x2): return NotImplemented return Matriz2x2(self.a + otra.a, self.b + otra.b, self.c + otra.c, self.d + otra.d)
def __matmul__(self, otra): if not isinstance(otra, Matriz2x2): return NotImplemented return Matriz2x2( self.a * otra.a + self.b * otra.c, self.a * otra.b + self.b * otra.d, self.c * otra.a + self.d * otra.c, self.c * otra.b + self.d * otra.d, )
def __mul__(self, escalar): if not isinstance(escalar, (int, float)): return NotImplemented return Matriz2x2(self.a * escalar, self.b * escalar, self.c * escalar, self.d * escalar)El producto va en @ porque * ya significa escalado por un número en el uso matemático habitual, y usarlo para el producto matricial haría que m1 * m2 y m1 * 3 tuvieran semánticas distintas. @ se añadió en Python 3.5 exactamente para esto, y es lo que usa numpy.
Comprobación con datos de ejemplo:
def campos(m): return (m.a, m.b, m.c, m.d)
m1 = Matriz2x2(1, 2, 3, 4)m2 = Matriz2x2(0, 1, 1, 0)print("suma:", campos(m1 + m2))print("producto:", campos(m1 @ m2))print("escala:", campos(m1 * 3))try: m1 * m2except TypeError as error: print("m1 * m2:", error)assert campos(m1 @ m2) == (2, 1, 4, 3), "producto matricial"Referencias
Sección titulada «Referencias»- Ramalho, L. Fluent Python, 2ª ed. Capítulo 16: Operator Overloading.
- CPython 3.13:
Objects/abstract.c(binary_op1,PyNumber_Add). - Mediciones:
mediciones/04-05-08-descriptores-slots-metaclases.py.
Capítulos relacionados
Sección titulada «Capítulos relacionados»- 01 · Objetos pitónicos:
__eq__y__hash__, los operadores que más se olvidan. - 02 · Herencia, MRO: el operando reflejado se busca en el otro tipo.
- 11 · Elección por coste (Parte II): crear objetos es el coste dominante.