Saltearse al contenido

El modelo de datos

Si vienes de Java, len(coleccion) en lugar de coleccion.len() parece un capricho. Es lo contrario: es la punta del diseño más importante del lenguaje. Python no define las operaciones en cada clase, las define en el intérprete, y deja que las clases se enganchen a ellas implementando métodos con nombre fijo. Ese contrato se llama modelo de datos, y es lo que hace que una clase de veinte líneas se comporte como una lista.

Los dunders no se llaman: se implementan. El intérprete los llama por ti.

# Mal
longitud = mi_objeto.__len__()
# Bien
longitud = len(mi_objeto)

El intérprete llama a __len__ cuando ve len(). Nunca lo llames tú, por tres razones: el built-in puede hacer trabajo extra, en los tipos nativos es más rápido porque ni siquiera hay llamada, y llamar al dunder directamente salta los enganches que el lenguaje ofrece.

La única excepción habitual es super().__init__(), que sí se escribe a mano porque no existe un built-in equivalente.

En los tipos escritos en C, len() no llama a nada: lee un campo de la estructura.

typedef struct {
PyObject ob_base; // 16 bytes: refcount + type
Py_ssize_t ob_size; // número de elementos
} PyVarObject;

Una list es un PyVarObject, así que len(lista) devuelve ob_size en tiempo constante, sin recorrer nada. En una clase tuya, len(obj) sí llama a obj.__len__(), y ese método es Python. Por eso conviene que __len__ no recorra la colección: si tu clase envuelve una lista, delega en len(self._datos), no cuentes a mano.

La justificación de Raymond Hettinger, citada por Ramalho: practicality beats purity. Contar elementos es tan común que merece un atajo del lenguaje. Y el mismo Zen cierra el círculo: special cases aren’t special enough to break the rules, de modo que el atajo vale para todos los tipos, no sólo para los nativos.

La diferencia se mide:

Coste de una llamada a len()
Objeto Coste por llamada
list nativa 28 ns
Clase propia con __len__ 85 ns

timeit, 1 000 000 de llamadas, CPython 3.13

Tres veces más caro, y aun así son ochenta y cinco nanosegundos: en cualquier programa real, irrelevante. La lección no es «evita len en tus clases», es que el atajo de los nativos existe y explica por qué len es una función y no un método.

Esta clase no hereda de nada y no implementa __iter__:

from collections import namedtuple
import random
Carta = namedtuple("Carta", "rank suit")
class Mazo:
ranks = [str(n) for n in range(2, 11)] + list("JQKA")
suits = "spades diamonds clubs hearts".split()
def __init__(self):
self._cartas = [Carta(r, s) for s in self.suits for r in self.ranks]
def __len__(self):
return len(self._cartas)
def __getitem__(self, posicion):
return self._cartas[posicion]

Con esos dos métodos, la clase ya soporta:

Operación Por qué funciona
len(mazo) __len__
mazo[0], mazo[-1] __getitem__
mazo[:3], mazo[12::13] __getitem__ recibe un slice
for c in mazo el intérprete cae a __getitem__ si no hay __iter__
reversed(mazo) __len__ + __getitem__
Carta("Q", "hearts") in mazo recorrido secuencial, al no haber __contains__
sorted(mazo, key=...) es iterable
random.choice(mazo) es una secuencia con __len__ y __getitem__

Ninguna de esas ocho líneas está escrita en la clase. Son consecuencia del contrato.

Funcionar no es lo mismo que funcionar bien. Cuando no hay __iter__, el intérprete itera llamando a __getitem__(0), __getitem__(1)… y construyendo un objeto índice nuevo en cada paso.

Recorrer un millón de elementos
Forma de iterar Tiempo Frente a la lista
list nativa 21.6 ms 1.0×
Clase con __iter__ que delega 21.8 ms 1.0×
Clase sólo con __getitem__ 79.4 ms 3.6×

verificado en CPython 3.13

Recorrer un millón de elementos
list nativa 21.6 ms clase con __iter__ 21.8 ms clase solo __getitem__ 79.4 ms

Con __iter__ que delega, la clase cuesta lo mismo que una lista. Sin él, el intérprete fabrica un índice nuevo en cada paso y paga 3,6 veces más.

La conclusión práctica: __getitem__ basta para que la clase sea una secuencia, pero si vas a recorrerla mucho, escribe __iter__ y delega. Es una línea:

def __iter__(self):
return iter(self._cartas)

Esta es la tabla que conviene tener a mano. La columna del medio es lo que implementas; la de la derecha es lo que el usuario de tu clase escribe.

Sintaxis Método especial Alternativa explícita
len(x) __len__ —
x[i] __getitem__ —
x[i] = v __setitem__ —
del x[i] __delitem__ —
for i in x __iter__ iter(x)
x in y __contains__ recorrido
a + b __add__ operator.add
a * n __mul__ operator.mul
abs(x) __abs__ —
repr(x) __repr__ —
str(x) __str__ cae a __repr__
f"{x}" __format__ —
bool(x) __bool__ cae a __len__
with x: __enter__ / __exit__ —
x() __call__ —

__repr__ es para quien lee el programa: la consola, el debugger, los logs. Debe ser inequívoca y, si se puede, parecerse al código que reconstruiría el objeto. __str__ es para el usuario final, y print la usa.

La regla que resuelve el 95 % de los casos: si sólo vas a implementar uno, implementa __repr__, porque str cae a repr cuando no existe y no al revés.

class Vector:
def __init__(self, x, y):
self.x, self.y = x, y
def __repr__(self):
return f"Vector({self.x!r}, {self.y!r})"

El !r dentro del f-string no es cosmético: sin él, Vector("1", "2") se imprimiría igual que Vector(1, 2), y la representación dejaría de ser inequívoca.

bool(x) llama a __bool__. Si no existe, prueba __len__ y devuelve False sólo cuando la longitud es cero. Si no hay ninguno de los dos, el objeto es verdadero — por eso una instancia vacía de tu clase es True por defecto, aunque no tenga nada dentro.

Cuidado con el atajo x or y: devuelve uno de los operandos, no un booleano. Si __bool__ tiene que devolver un bool de verdad, envuelve el resultado con bool(...).

  • No los implementes por completitud. Una clase de dominio que no se va a imprimir, comparar ni recorrer no necesita __repr__ ni __eq__. La mitad de los dunders de la tabla son ruido en una clase de negocio.
  • No implementes __eq__ sin __hash__ pensado. Definir __eq__ pone __hash__ a None y el objeto deja de ser usable como clave. Es el tema del capítulo 09.
  • No uses __getattr__ para simular atributos dinámicos si un @property o un dataclass resuelven el caso. La metaprogramación se paga en depuración.

Implementa Vector2d con __init__, __repr__, __abs__, __add__, __mul__ y __bool__, de modo que se cumpla esta sesión de consola:

>>> v = Vector2d(3, 4)
>>> repr(v)
'Vector2d(3, 4)'
>>> abs(v)
5.0
>>> v + Vector2d(1, 1)
Vector2d(4, 5)
>>> v * 3
Vector2d(9, 12)
>>> bool(Vector2d(0, 0))
False
Solución
import math
class Vector2d:
def __init__(self, x, y):
self.x, self.y = x, y
def __repr__(self):
return f"Vector2d({self.x!r}, {self.y!r})"
def __abs__(self):
return math.hypot(self.x, self.y)
def __bool__(self):
return bool(abs(self))
def __add__(self, other):
return Vector2d(self.x + other.x, self.y + other.y)
def __mul__(self, escalar):
return Vector2d(self.x * escalar, self.y * escalar)

Tres detalles que separan la solución correcta de la que pasa el test: __repr__ usa !r; __add__ devuelve un objeto nuevo y no muta self; y __mul__ acepta v * 3 pero no 3 * v, porque para eso hace falta __rmul__ (Parte IV, capítulo 08).

  • Ramalho, L. Fluent Python, 2ª ed. Capítulo 1: el modelo de datos, FrenchDeck y la API de colecciones.
  • CPython 3.13: Include/cpython/object.h (PyVarObject), Objects/listobject.c (list_length).
  • Medición de iteración: comparativa ejecutada en CPython 3.13 sobre un millón de enteros.
  • 01 · Todo es un objeto: por qué el intérprete puede engancharse a métodos con nombre fijo.
  • 03 · Nombres, no variables: el enganche que más se malinterpreta.
  • 01 · Objetos pitónicos (Parte IV): __eq__, __hash__ y __format__ en profundidad.