Objetos pitónicos
La Parte I explicó cómo se engancha un objeto a la sintaxis. Esta parte empieza por lo que hace que un objeto se sienta nativo: que print muestre algo útil, que == compare lo que debe, que pueda estar en un set y que f"{obj:>10}" funcione. Son cuatro métodos, y la mitad de las clases del mundo real no los tienen.
En una línea
Sección titulada «En una línea»Un objeto pitónico se puede imprimir, comparar, hashear y formatear sin que el lector adivine qué pasa.
__repr__: la representación que reconstruye
Sección titulada «__repr__: la representación que reconstruye»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})"La regla de oro: el repr debe parecerse al código que reconstruiría el objeto. Vector(3, 4) se puede copiar a una consola y funciona; <Vector object at 0x7f...> no dice nada.
El !r no es cosmético: sin él, Vector("3", "4") y Vector(3, 4) se imprimen igual y la representación miente.
__str__ es para el usuario final y print la usa. Si sólo vas a implementar uno, implementa __repr__: str cae a repr cuando no existe, y no al revés.
__eq__: igualdad por valor
Sección titulada «__eq__: igualdad por valor»| Tipo | Coste por comparación |
|---|---|
tuple de dos enteros |
25 ns |
Clase con __eq__ manual |
102 ns |
dataclass(frozen=True) |
108 ns |
python mediciones/04-01-04-poo.py
Comparar dos objetos propios cuesta cuatro veces más que comparar dos tuplas. La razón: la llamada a __eq__ es una llamada a método Python, mientras que la comparación de tuplas está en C. En un set de un millón de elementos eso importa; en una lista de cien, no.
La regla del contrato, ya vista en el capítulo 09 de la Parte I: si defines __eq__, define __hash__ (o marca el objeto como no hashable). Y si los campos que comparas son mutables, el objeto no puede ser clave.
__format__: el que casi nadie escribe
Sección titulada «__format__: el que casi nadie escribe»class Dinero: def __init__(self, cantidad, moneda="EUR"): self.cantidad = cantidad self.moneda = moneda
def __format__(self, spec): if spec == "": return f"{self.cantidad:.2f} {self.moneda}" return format(self.cantidad, spec)Sin __format__, f"{dinero:>12}" lanza TypeError: unsupported format string; sólo el especificador vacío cae a str. Con él, el objeto participa en el sistema de formato como un número o una fecha: alineación, relleno, precisión.
El paquete completo
Sección titulada «El paquete completo»Una clase de valor bien hecha tiene seis métodos y ninguno sobra:
| Método | Para qué |
|---|---|
__init__ |
Construir |
__repr__ |
Depurar y reconstruir |
__eq__ |
Comparar por valor |
__hash__ |
Usar como clave |
__format__ |
Participar en f-strings |
__slots__ |
Ahorrar memoria (opcional) |
Una @dataclass(frozen=True) genera los cuatro primeros. Es la razón por la que se usa tanto: el código que no escribes es el código que no puedes escribir mal.
Cuándo la igualdad por identidad es la correcta
Sección titulada «Cuándo la igualdad por identidad es la correcta»No todo objeto debe compararse por valor. Una entidad —un usuario, un pedido, una conexión— tiene identidad propia: dos pedidos con los mismos datos son dos pedidos distintos.
class Pedido: def __init__(self, id): self.id = id # sin __eq__: dos instancias nunca son igualesLa regla: valor si el objeto representa un dato (un punto, un importe, un rango); identidad si representa algo que existe y evoluciona. Definir __eq__ por todos los campos en una entidad es un bug esperando: dos actualizaciones del mismo pedido dejarían de ser iguales.
Cuando la entidad necesita compararse —por ejemplo, para deduplicar en un set—, se compara por su clave natural (id), y entonces esa clave debe ser inmutable.
La trampa
Sección titulada «La trampa»Cuándo NO implementar todo esto
Sección titulada «Cuándo NO implementar todo esto»- En objetos de servicio (repositorios, clientes HTTP), la igualdad por identidad es la correcta: no los compares por contenido.
- Si el objeto tiene identidad propia (un usuario con ID),
__eq__por ID y no por todos los campos mutables. - En prototipos,
@dataclassda el 90 % con una línea.
Ejercicio
Sección titulada «Ejercicio»Implementa Intervalo(inicio, fin) con __repr__, __eq__, __hash__ y __contains__, de forma que fecha in intervalo funcione y dos intervalos con los mismos extremos sean iguales. Explica qué pasa si el intervalo se puede modificar después de meterlo en un set.
Solución
from dataclasses import dataclass
@dataclass(frozen=True)class Intervalo: inicio: int fin: int
def __contains__(self, valor): return self.inicio <= valor <= self.fin
a = Intervalo(1, 10)5 in a # Truea == Intervalo(1, 10) # True{Intervalo(1, 10)} # funciona: es hashablefrozen=True genera __eq__ y __hash__ coherentes, y hace imposible mutar los extremos. Si el intervalo fuera mutable, hash cambiaría al modificarlo y el objeto quedaría perdido dentro del set: estaría guardado en una cubeta que ya no le corresponde.
__contains__ es lo que hace que in funcione sin recorrer nada: el intérprete lo llama directamente en lugar de iterar.
Referencias
Sección titulada «Referencias»- Ramalho, L. Fluent Python, 2ª ed. Capítulos 11 y 12: A Pythonic Object.
- CPython 3.13:
Objects/object.c(object_repr,object_richcompare). - Mediciones:
mediciones/04-01-04-poo.py.
Capítulos relacionados
Sección titulada «Capítulos relacionados»- 02 · El modelo de datos (Parte I): el protocolo general.
- 09 · Hashabilidad (Parte I): el contrato entre
__eq__y__hash__. - 06 · Atributos y
__slots__: la memoria, que aquí no se mide.