Saltearse al contenido

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.

Sólo sobrecarga si la operación se lee igual que con los tipos nativos; si hay que explicarla, es un método.

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
Un millón de sumas
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__.

  1. Devuelve un objeto nuevo. a + b no debe mutar a. Si quieres mutar, es += y se llama __iadd__.
  2. Devuelve NotImplemented, no lances. Es la señal para que Python pruebe el operando reflejado o lance TypeError con un mensaje coherente.
  3. 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.
  4. Mantén la coherencia con __eq__ y __hash__. Un tipo con __eq__ y sin __hash__ no puede ser clave (Parte I, capítulo 09).
class Dinero:
def __add__(self, otro):
if not isinstance(otro, Dinero):
return NotImplemented # correcto
# raise TypeError(...) # incorrecto

Devolver 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.

  • Si el método con nombre se lee igual de bien. tabla.insertar(fila) es más claro que tabla + fila si 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é.

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.

  • 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.
  • 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.