Saltearse al contenido

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.

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.

Un millón de comparaciones entre objetos iguales
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.

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.

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 iguales

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

  • 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, @dataclass da casi todo con una línea.

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 # True
a == Intervalo(1, 10) # True
{Intervalo(1, 10)} # funciona: es hashable

frozen=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.

Comprobación con datos de ejemplo:

print(a)
print(5 in a, 11 in a)
print(a == Intervalo(1, 10), a == Intervalo(1, 11))
print(len({Intervalo(1, 10), Intervalo(1, 10)}))
try:
a.fin = 20
except Exception as error:
print("mutar:", type(error).__name__)
assert 5 in a and 0 not in a, "los extremos definen la pertenencia"
  • 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.
  • 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.