Si has trabajado en proyectos Python de mediana o gran escala, seguramente te has enfrentado a problemas de consumo excesivo de memoria. Cada objeto en Python lleva consigo un diccionario (__dict__) que almacena sus atributos de forma dinámica — una flexibilidad que tiene un costo elevado. Aquí es donde __slots__ entra como una solución elegante y poderosa para la optimización.

En esta guía completa aprenderás qué son __slots__, cómo funcionan internamente, cuándo usarlos y qué precauciones tomar. Todo acompañado de ejemplos prácticos y benchmarks reales para que puedas aplicar estos conocimientos de inmediato en tus proyectos.

El Problema: Consumo de Memoria en Clases Python

Para entender el valor de __slots__, primero debemos comprender cómo Python gestiona los atributos de instancia. Por defecto, toda clase en Python almacena sus atributos en un diccionario llamado __dict__. Este diccionario permite añadir, eliminar y modificar atributos dinámicamente — una característica que hace a Python increíblemente flexible.

El problema es que los diccionarios son estructuras de datos pesadas. Cada entrada en un diccionario incluye la clave, el valor, el hash de la clave y metadatos internos. Cuando tienes miles o millones de objetos, el __dict__ de cada uno consume una cantidad significativa de memoria. Como explica la documentación oficial de Python, la declaración de __slots__ permite reemplazar el __dict__ por una estructura de almacenamiento más eficiente.

class SinSlots:
    def __init__(self, x, y):
        self.x = x
        self.y = y

obj = SinSlots(10, 20)
print(obj.dict)  # {'x': 10, 'y': 20}
print(sys.getsizeof(obj))  # 56 bytes (sin contar el dict)

El diccionario __dict__ añade aproximadamente 120 bytes adicionales para un objeto simple con dos atributos, y este overhead crece a medida que agregas más atributos. En aplicaciones que crean muchos objetos — como juegos, simulaciones científicas, procesamiento de datos a gran escala o servidores de alto rendimiento — este overhead se convierte en un cuello de botella significativo.

¿Qué Son __slots__?

__slots__ es un atributo especial de clase que define explícitamente qué atributos de instancia puede tener una clase. Cuando declaras __slots__, Python deja de crear el diccionario __dict__ para cada instancia y asigna solo el espacio necesario para los atributos listados. La Wiki de Python describe esta técnica como una forma de reducir el consumo de memoria hasta en un 50% o más.

class ConSlots:
    __slots__ = ('x', 'y')

def __init__(self, x, y):
    self.x = x
    self.y = y


obj2 = ConSlots(10, 20)


print(obj2.dict)  # AttributeError: 'ConSlots' object has no attribute 'dict'


print(sys.getsizeof(obj2))  # 48 bytes (total, sin dict extra)

La sintaxis es sencilla: define una tupla (o lista) con los nombres de los atributos permitidos. Cada instancia almacena estos valores en un array compacto de tamaño fijo, en lugar de un diccionario completo.

Cómo Funcionan __slots__ Internamente

Para dominar realmente __slots__, es importante entender el mecanismo interno. Cuando Python compila una clase que define __slots__, crea descriptores para cada nombre listado. Estos descriptores gestionan el acceso a los valores almacenados en un slot numerado dentro de un array interno de la instancia.

Esto significa que el acceso a atributos en clases con __slots__ no solo es más eficiente en memoria, sino también más rápido. El tutorial oficial de clases de Python ofrece una visión excelente de este comportamiento.

class Punto:
    __slots__ = ('x', 'y', 'z')

def __init__(self, x, y, z):
    self.x = x
    self.y = y
    self.z = z


p = Punto(1, 2, 3)
print(p.x)  # 1


p.w = 4  # AttributeError: 'Punto' object has no attribute 'w'

Además de ahorrar memoria, la restricción de crear nuevos atributos fuera de __slots__ funciona como una protección contra errores tipográficos. Si accidentalmente escribes self.x = 1 en lugar de self.x = 1, Python lanza un AttributeError de inmediato, en lugar de crear silenciosamente un atributo nuevo e incorrecto.

Ejemplos Prácticos

Exploremos escenarios reales donde __slots__ marca una diferencia significativa.

Sistema de Partículas para Videojuegos

En un juego 2D, puedes tener miles de partículas en pantalla simultáneamente. Cada partícula necesita almacenar posición, velocidad, color, tiempo de vida y otros atributos. Sin __slots__, la memoria consumida por estas partículas puede descontrolarse rápidamente.

class Particula:
    __slots__ = ('x', 'y', 'vx', 'vy', 'color', 'vida', 'tamano')

def __init__(self, x, y, vx, vy, color, vida, tamano):
    self.x = x
    self.y = y
    self.vx = vx
    self.vy = vy
    self.color = color
    self.vida = vida
    self.tamano = tamano


particulas = [Particula(i, i*2, 1, -1, 'azul', 100, 3) for i in range(100000)]

Con __slots__, cada partícula ocupa aproximadamente 80 bytes. Sin __slots__, cada una consumiría unos 200 bytes o más. Para 100 mil partículas, el ahorro es de aproximadamente 12 MB. El memory-profiler es una herramienta útil para medir esta diferencia en tus proyectos.

Registros de Datos

Imagina que estás procesando un archivo CSV con millones de filas y representas cada fila como un objeto Python. Usar __slots__ reduce drásticamente el consumo de memoria.

class RegistroVenta:
    __slots__ = ('producto', 'cantidad', 'precio', 'fecha', 'vendedor')

def __init__(self, producto, cantidad, precio, fecha, vendedor):
    self.producto = producto
    self.cantidad = cantidad
    self.precio = precio
    self.fecha = fecha
    self.vendedor = vendedor</code></pre>


Este enfoque es especialmente útil cuando se combina con la lectura bajo demanda de archivos grandes, donde cada línea se procesa y mantiene en memoria por un período corto. El ahorro de memoria se acumula y puede significar la diferencia entre que el programa funcione o se quede sin RAM disponible.


Benchmarks de Memoria y Rendimiento


Comparemos objetivamente clases con y sin __slots__ usando la función sys.getsizeof y una prueba simple de velocidad de acceso.


import sys
import time

class ClaseSinSlots:
def init(self, a, b, c):
self.a = a
self.b = b
self.c = c


class ClaseConSlots:
slots = ('a', 'b', 'c')
def init(self, a, b, c):
self.a = a
self.b = b
self.c = c


Comparación de memoria


obj1 = ClaseSinSlots(1, 2, 3)
obj2 = ClaseConSlots(1, 2, 3)


print(f"Sin slots: {sys.getsizeof(obj1)} bytes")
print(f"Con slots: {sys.getsizeof(obj2)} bytes")


dict añade más memoria


dict_size = sys.getsizeof(obj1.dict)
print(f"dict extra: {dict_size} bytes")


Los resultados típicos muestran que los objetos con __slots__ consumen entre 40 y 60% menos memoria. En pruebas de velocidad de acceso a atributos, la diferencia también es notable: los objetos con __slots__ son generalmente 10 a 15% más rápidos en lectura y escritura de atributos.


Cuándo Usar __slots__


__slots__ no es una solución universal. Existen escenarios específicos donde brilla y otros donde su uso es innecesario o incluso contraproducente. La comunidad de Stack Overflow tiene discusiones excelentes sobre los pros y contras de usar __slots__.


Usa __slots__ cuando:


    
  
  • Creas miles o millones de objetos de la misma clase
    • 
  
  • Cada objeto tiene un conjunto fijo y bien definido de atributos
    • 
  
  • La memoria es un recurso crítico (juegos, sistemas embebidos, servidores de alto rendimiento)
    • 
  
  • El rendimiento de acceso a atributos es importante
    • 
  
  • Quieres prevenir la creación accidental de nuevos atributos
    • 



Evita __slots__ cuando:


    
  
  • Necesitas añadir atributos dinámicamente
    • 
  
  • Tus clases hacen uso intensivo de herencia múltiple
    • 
  
  • Dependes de weak references sin incluir __weakref__ en los slots
    • 
  
  • El número de instancias de la clase es pequeño (cientos o pocos miles)
    • 



Limitaciones y Precauciones


A pesar de los beneficios, __slots__ impone limitaciones importantes que debes conocer antes de adoptarlo en tus proyectos.


1. Sin diccionario de instancia: Como se mencionó, los objetos con __slots__ no tienen __dict__. Esto significa que no puedes añadir nuevos atributos dinámicamente después de crear el objeto. Si lo intentas, recibirás un AttributeError.


2. Sin weak references por defecto: Los objetos con __slots__ no soportan weakref a menos que incluyas explícitamente '__weakref__' en la tupla de slots.


class ConWeakRef:
    __slots__ = ('x', '__weakref__')
    def __init__(self, x):
        self.x = x


3. Herencia: Las subclases de clases con __slots__ también necesitan definir sus propios __slots__ para optimizar el uso de memoria. Si una subclase no define __slots__, tendrá un __dict__ aunque la clase padre use __slots__. La documentación del modelo de datos de Python explica este comportamiento en detalle.


class Base:
    __slots__ = ('a',)

class Derivada(Base):
slots = ('b',)


d = Derivada()
d.a = 1  # OK
d.b = 2  # OK


d.c = 3  # AttributeError


__slots__ y Herencia: Buenas Prácticas


La herencia con __slots__ requiere atención adicional. Cuando heredas de una clase que usa __slots__, la subclase debe declarar sus propios __slots__ incluyendo solo los atributos que añade — no los de la clase padre. Python gestiona automáticamente el espacio para los atributos de todos los niveles de la jerarquía.


class Vehiculo:
    __slots__ = ('marca', 'modelo', 'anio')

def __init__(self, marca, modelo, anio):
    self.marca = marca
    self.modelo = modelo
    self.anio = anio


class Coche(Vehiculo):
slots = ('puertas',)


def __init__(self, marca, modelo, anio, puertas):
    super().__init__(marca, modelo, anio)
    self.puertas = puertas</code></pre>


Un error común es olvidar definir __slots__ en la subclase. En ese caso, la subclase tendrá un __dict__ y no aprovechará la optimización de memoria, aunque la clase padre use __slots__.


# MAL: Sin __slots__ en la subclase
class Coche2(Vehiculo):
    def __init__(self, marca, modelo, anio, puertas):
        super().__init__(marca, modelo, anio)
        self.puertas = puertas

c2 = Coche2('VW', 'Gol', 2024, 4)
print(hasattr(c2, 'dict'))  # True ¡Tiene dict aunque el padre use slots!


__slots__ y el Protocolo de Descriptores


Internamente, cada nombre en __slots__ crea un descriptor en la clase. Los descriptores son objetos que gestionan el acceso a atributos a través de los métodos __get__, __set__ y __delete__. Esto significa que puedes combinar __slots__ con @property para tener control fino sobre la entrada y salida de datos.


class Usuario:
    __slots__ = ('_nombre', '_email')

def __init__(self, nombre, email):
    self._nombre = nombre
    self._email = email

@property
def nombre(self):
    return self._nombre

@nombre.setter
def nombre(self, valor):
    if not valor.strip():
        raise ValueError("El nombre no puede estar vacío")
    self._nombre = valor</code></pre>


Esta combinación te permite tener la eficiencia de __slots__ sin renunciar a las buenas prácticas de encapsulamiento. Para más detalles sobre @property, consulta nuestra guía completa sobre este tema. [link_interno_2]


Alternativas a __slots__


Dependiendo de tu caso de uso, otras estructuras pueden ser más adecuadas que __slots__:


namedtuple: Crea clases inmutables con acceso a atributos por nombre. Eficiente en memoria, pero no permite métodos personalizados fácilmente.


dataclass: Desde Python 3.7, el módulo dataclasses permite crear clases con sintaxis concisa. Puedes combinar dataclass con __slots__ usando slots=True a partir de Python 3.10.


from dataclasses import dataclass

@dataclass(slots=True)
class Configuracion:
host: str
puerto: int
timeout: float


Diccionario simple o types.SimpleNamespace: Para objetos que son meros contenedores de datos, un diccionario o SimpleNamespace puede ser suficiente. El tutorial de Real Python sobre __slots__ compara estas alternativas en detalle.


Arrays de NumPy: Para datos numéricos homogéneos, los arrays de NumPy son extremadamente eficientes en memoria y mucho más rápidos que las listas de objetos Python.


Errores Comunes con __slots__


Estos son los errores más frecuentes que cometen los desarrolladores al usar __slots__:


1. Olvidar incluir '__weakref__' y '__dict__': Si necesitas weak references o un diccionario de instancia, inclúyelos explícitamente en los slots.


class Flexible:
    __slots__ = ('x', '__weakref__', '__dict__')

f = Flexible()
f.x = 1
f.y = 2  # OK, porque dict está en los slots


2. Usar __slots__ con herencia múltiple: La herencia múltiple con __slots__ funciona solo cuando todas las clases base definen exactamente el mismo conjunto de slots. De lo contrario, Python lanza un error.


3. Intentar serializar con pickle: Los objetos con __slots__ se pueden serializar con pickle, pero debes asegurarte de que la clase esté disponible al momento de la deserialización. Las clases que usan __slots__ generalmente funcionan bien con pickle, siempre que implementes __getstate__ y __setstate__ si es necesario.


La documentación del glosario de Python ofrece definiciones precisas y enlaces a recursos adicionales sobre __slots__ y otros mecanismos internos del lenguaje.


Consejos Avanzados


Para desarrolladores que quieren ir más allá, aquí tienes algunas técnicas avanzadas con __slots__:


Introspección con dir()


Incluso sin __dict__, todavía puedes inspeccionar objetos con dir(). La función muestra todos los atributos disponibles, incluyendo los definidos en __slots__.


Slots Dinámicos


¿Puedes modificar __slots__ después de definir la clase? Técnicamente no — es un atributo de clase definido en tiempo de compilación. Sin embargo, puedes usar __dict__ como un slot adicional para permitir asignación dinámica controlada.


Comparación con Lenguajes Compilados


El mecanismo de __slots__ es similar a cómo lenguajes como C++ o Java almacenan atributos de objeto: un bloque contiguo de memoria con offsets fijos. Esto acerca Python al rendimiento de lenguajes de más bajo nivel en escenarios específicos, sin perder la sintaxis expresiva del lenguaje.


Conclusión


__slots__ es una herramienta poderosa en el arsenal de cualquier desarrollador Python que se preocupe por el rendimiento y la eficiencia de memoria. Cuando se usa correctamente, puede reducir el consumo de memoria en más del 50% y acelerar el acceso a atributos de forma significativa. No es una solución para todos los casos, pero en los escenarios adecuados — objetos a gran escala, videojuegos, procesamiento de datos — marca una diferencia transformadora.


Comienza analizando tus proyectos actuales: identifica clases que generan muchas instancias con atributos fijos y prueba añadir __slots__. Mide el consumo de memoria antes y después, y comprueba los beneficios por ti mismo. Invertir en entender este mecanismo interno de Python te convertirá en un desarrollador más completo y preparado para desafíos de rendimiento.


Para continuar tus estudios, te recomendamos nuestra guía completa sobre programación orientada a objetos en Python. [link_interno_1]




Referencias y Recursos