Métodos especiales (dunder)

Los métodos especiales (llamados dunder methods porque comienzan y terminan con un doble guion bajo: __name__) son los ganchos (hooks) que permiten a tus objetos integrarse con el lenguaje: representación de texto, comparación con ==, soporte para len(), in, operadores, etc.

Ya has utilizado uno: __init__.

__str__ y __repr__

Controlan lo que aparece al usar print() y en el REPL.

class Punto:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __repr__(self):
        return f"Punto({self.x}, {self.y})"

    def __str__(self):
        return f"({self.x}, {self.y})"

p = Punto(3, 4)
str(p)        # '(3, 4)'        — para humanos
repr(p)       # 'Punto(3, 4)'   — para depurador / dev
print(p)      # '(3, 4)'
p             # Punto(3, 4)     en el REPL → repr
[p, p]        # [Punto(3, 4), Punto(3, 4)]   — siempre repr en los contenedores

Si defines solo __repr__, Python también lo usa como alternativa para __str__.

__eq__: redefinir ==

Por defecto, a == b compara los identificadores de los objetos (is), no su contenido. Para la comparación estructural, define __eq__:

class Punto:
    def __init__(self, x, y):
        self.x, self.y = x, y

    def __eq__(self, other):
        if not isinstance(other, Punto):
            return NotImplemented
        return (self.x, self.y) == (other.x, other.y)

Punto(1, 2) == Punto(1, 2)    # True
Punto(1, 2) == Punto(3, 4)    # False

Devolver NotImplemented (¡una palabra clave especial, no False!) cuando los tipos no son comparables es la práctica correcta: Python intentará entonces con el __eq__ del otro operando.

__len__: soporte para len()

class Cesto:
    def __init__(self):
        self.frutti = []

    def __len__(self):
        return len(self.frutti)

c = Cesto()
c.frutti.append("mela")
len(c)        # 1
bool(c)       # True (len > 0)

Al definir __len__, también obtienes el booleano gratis: un objeto con len() == 0 se vuelve falso (falsy).

Otros dunders útiles (resumen)

• __add__(self, other) → redefine +
• __lt__, __le__, __gt__, __ge__ → operadores de comparación
• __contains__(self, item) → soporta item in self
• __iter__ + __next__ → hace que el objeto sea iterable
• __getitem__(self, key) → soporta self[key]
• __hash__ → necesario para ser clave de diccionario / elemento de conjunto

Pruébalo tú

Ejercicio de repaso

Desafío adicional