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.
En una línea
Sección titulada «En una línea»__slots__ cambia dónde vive el estado: de fuera del objeto a dentro. Ahorra memoria y prohíbe los atributos nuevos.
Lo que se ahorra
Sección titulada «Lo que se ahorra»| 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.
Lo que no se gana
Sección titulada «Lo que no se gana»| 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.
La trampa
Sección titulada «La trampa»Cuándo NO usar __slots__
Sección titulada «Cuándo NO usar __slots__»- 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__.
Ejercicio
Sección titulada «Ejercicio»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.
Referencias
Sección titulada «Referencias»- Ramalho, L. Fluent Python, 2ª ed. Capítulo 22: atributos dinámicos.
- CPython 3.13:
Objects/typeobject.c(type_newcon__slots__). - Mediciones:
mediciones/04-05-08-descriptores-slots-metaclases.pyymediciones/04-01-04-poo.py.
Capítulos relacionados
Sección titulada «Capítulos relacionados»- 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.