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.
En una línea
Sección titulada «En una línea»Los dunders no se llaman: se implementan. El intérprete los llama por ti.
La regla de oro
Sección titulada «La regla de oro»# Mallongitud = mi_objeto.__len__()
# Bienlongitud = 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.
Por qué len() no es un método
Sección titulada «Por qué len() no es un método»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:
| 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.
El experimento que lo demuestra
Sección titulada «El experimento que lo demuestra»Esta clase no hereda de nada y no implementa __iter__:
from collections import namedtupleimport 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.
El coste del atajo
Sección titulada «El coste del atajo»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.
| 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
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)La tabla de enganches
Sección titulada «La tabla de enganches»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__ |
— |
Representación: repr y str
Sección titulada «Representación: repr y str»__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.
Verdad y falsedad
Sección titulada «Verdad y falsedad»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(...).
La trampa
Sección titulada «La trampa»Cuándo NO implementar dunders
Sección titulada «Cuándo NO implementar dunders»- 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__aNoney 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@propertyo undataclassresuelven el caso. La metaprogramación se paga en depuración.
Ejercicio
Sección titulada «Ejercicio»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 * 3Vector2d(9, 12)>>> bool(Vector2d(0, 0))FalseSolució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).
Referencias
Sección titulada «Referencias»- Ramalho, L. Fluent Python, 2ª ed. Capítulo 1: el modelo de datos,
FrenchDecky 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.
Capítulos relacionados
Sección titulada «Capítulos relacionados»- 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.