Saltearse al contenido

Atributos y __slots__

En 3.13 un objeto normal guarda sus atributos en un array de valores dentro del propio objeto (managed dict): el __dict__ sólo se materializa si lo pides. __slots__ prescinde de ese diccionario y deja los atributos en huecos fijos, sin la flexibilidad de añadir otros nuevos. La decisión es memoria frente a flexibilidad, y no tiene nada que ver con la velocidad.

__slots__ cambia dónde vive el estado: de fuera del objeto a dentro. Ahorra memoria y prohíbe los atributos nuevos.

100 000 instancias con dos atributos
Forma Memoria por instancia
__dict__ por instancia 96 B
__slots__ = ("x", "y") 56 B

python mediciones/04-05-08-descriptores-slots-metaclases.py

Un 42 % menos por objeto, y esa cifra es la que importa: con un millón de instancias son 40 MB. El ahorro no crece con el número de atributos en la misma proporción, pero sigue siendo sustancial.

Leer un atributo un millón de veces
Forma Coste por lectura
Con __dict__ 15.0 ns
Con __slots__ 14.9 ns

python mediciones/04-01-04-poo.py

Ninguna diferencia. Durante años se enseñó que slots acelera el acceso a atributos; en 3.13 es falso. El intérprete especializa LOAD_ATTR para objetos con diccionario, y la búsqueda ya es una lectura de tabla con caché.

La razón de que el mito sobreviva es histórica: en Python 2 y en las primeras versiones de 3, la diferencia existía. Hoy el beneficio es sólo memoria, y por tanto sólo importa con muchas instancias.

__getattr__ y __getattribute__, que se confunden

Sección titulada «__getattr__ y __getattribute__, que se confunden»
Método Cuándo se llama
__getattribute__ En todos los accesos
__getattr__ Sólo cuando el atributo no se encontró
__setattr__ En toda asignación

__getattribute__ es la puerta principal: si lo sobrescribes, interceptas todo y puedes romper el acceso a self.__dict__ con una recursión infinita. __getattr__ es el respaldo: se usa para atributos calculados o delegados, y es lo que hace que un proxy funcione.

  • Con pocas instancias. El ahorro es despreciable y la limitación es real.
  • Si el objeto necesita atributos dinámicos (plugins, configuración, cachés por instancia).
  • Si usas herencia múltiple con mixins, cada mixin necesita su propio slots, y uno sin declararlo arruina el ahorro.
  • Si el código hace vars() o __dict__.

Una simulación crea 2 millones de partículas con posición, velocidad y masa, y muere por memoria. ¿Resuelve __slots__ el problema? Calcula con los números del capítulo y propón la alternativa si no.

Solución

Con tres campos, slots ahorra aproximadamente el 40 % por instancia: de unos 120 bytes a unos 70, más los objetos de los valores. Para 2 millones de partículas, de ~240 MB a ~140 MB. Ayuda, y probablemente no basta si el proceso muere.

La alternativa real es cambiar la representación: 2 millones × 3 float son 48 MB en un array('d') o en numpy, sin objetos por partícula. El capítulo 11 de la Parte II lo midió: 39,9 bytes por valor en una lista de objetos frente a 4,1 con array('i'); con array('d'), que es el que hace falta aquí, son 8 bytes por valor (los 48 MB de arriba).

La regla: slots es una optimización del 40 % sobre un diseño que quizá sea el equivocado. Si el dato es numérico y homogéneo, el diseño correcto no tiene objetos por elemento.

  • Ramalho, L. Fluent Python, 2ª ed. Capítulo 22: atributos dinámicos.
  • CPython 3.13: Objects/typeobject.c (type_new con __slots__).
  • Mediciones: mediciones/04-05-08-descriptores-slots-metaclases.py y mediciones/04-01-04-poo.py.
  • 05 · Descriptores: el otro mecanismo que intercepta el acceso.
  • 11 · Elección por coste (Parte II): cuándo el objeto por fila es el problema.
  • 01 · Objetos pitónicos: el paquete de métodos que un objeto de valor necesita.