Unlock Massive Memory Savings in Python with __slots__: A Complete Guide

1. Starting from a Memory Problem

Consider a scenario where creating millions of objects leads to rapidly increasing memory usage. The default Python class stores attributes in a per‑instance __dict__, which incurs significant overhead.

class RegularUser:
    def __init__(self, name, age, email):
        self.name = name
        self.age = age
        self.email = email

# Create 1,000,000 users
users = [RegularUser(f"user{i}", i % 100, f"user{i}@example.com") for i in range(1000000)]

Running this code shows a large memory footprint, illustrating the cost of the default class mechanism.

2. Revealing Python Class Memory Overhead

In a regular Python class each instance maintains its own dictionary:

user = RegularUser("Alice", 25, "[email protected]")
print(user.__dict__)  # {'name': 'Alice', 'age': 25, 'email': '[email protected]'}
print(hasattr(user, '__dict__'))  # True

The flexibility of a dynamic __dict__ comes with three main costs:

Every instance must maintain a separate dictionary.

The dictionary itself consumes memory.

Dynamic attribute addition requires hash calculations.

3. The Magic of __slots__

By declaring __slots__, Python avoids creating a per‑instance __dict__, storing attributes in a fixed structure instead.

class SlotsUser:
    __slots__ = ['name', 'age', 'email']
    def __init__(self, name, age, email):
        self.name = name
        self.age = age
        self.email = email

slots = SlotsUser("Bob", 30, "[email protected]")
print(hasattr(slots, '__dict__'))  # False

Memory comparison using pympler.asizeof shows a typical reduction from ~328 bytes per object to ~96 bytes, a savings of about 70%.

print("普通对象大小:", asizeof.asizeof(regular), "bytes")
print("Slots对象大小:", asizeof.asizeof(slots), "bytes")
print("内存节省比例:", (asizeof.asizeof(regular)-asizeof.asizeof(slots))/asizeof.asizeof(regular)*100, "%")

Attribute‑access speed also improves. A simple benchmark shows the slots class accesses attributes roughly 1.5‑2× faster than the regular class.

# Access speed test
regular = RegularUser("test", 25, "[email protected]")
slots = SlotsUser("test", 25, "[email protected]")
# ... timing loop omitted for brevity ...

4. Ideal Scenarios for Using __slots__

When you need to create a large number of instances (e.g., game entities, data records).

Memory‑sensitive applications such as data processing pipelines.

Performance‑critical code where attribute lookup speed matters.

5. Caveats and Limitations

Dynamic attribute addition is prohibited.

Inheritance requires careful handling; subclasses must extend __slots__ or risk falling back to __dict__.

Some features (weak references, certain decorators) may need explicit slots like '__weakref__'.

class TestClass:
    __slots__ = ['a', 'b']
    def __init__(self):
        self.a = 1
        self.b = 2
# obj.c = 3  # Raises AttributeError

6. Best‑Practice Guidelines

Use __slots__ only when memory or speed gains are justified.

Declare all expected attributes up front.

When subclassing, extend __slots__ rather than replace it.

Provide clear error messages for disallowed attributes.

class StrictSlots:
    __slots__ = ['allowed_attr']
    def __setattr__(self, name, value):
        if name not in self.__slots__:
            raise AttributeError(f"{self.__class__.__name__} has no attribute {name}. Allowed: {self.__slots__}")
        super().__setattr__(name, value)

7. Real‑World Case: Game Development

In a game, thousands of entities can benefit from slots:

class GameEntity:
    __slots__ = ['x', 'y', 'width', 'height', 'health', 'speed', 'texture']
    def __init__(self, x, y, width, height):
        self.x = x
        self.y = y
        self.width = width
        self.height = height
        self.health = 100
        self.speed = 1.0
        self.texture = None
    def move(self, dx, dy):
        self.x += dx * self.speed
        self.y += dy * self.speed
    def take_damage(self, amount):
        self.health -= amount
        return self.health <= 0

entities = [GameEntity(i % 100, i // 100, 32, 32) for i in range(10000)]
print(f"Created {len(entities)} game entities")

The memory savings are substantial when scaling to tens of thousands of objects.

8. Performance Comparison Summary

Feature

Regular Class

Slots Class

Memory Usage

High (each instance has a dict)

Low (fixed size)

Attribute Access Speed

Slower (dict lookup)

Faster (direct offset)

Flexibility

High (dynamic attributes)

Low (fixed attributes)

Inheritance Support

Simple

Requires explicit slot management

Typical Use Cases

General purpose

Memory‑sensitive, high‑performance scenarios

9. When Not to Use __slots__

When you need to add attributes dynamically.

When using frameworks that rely on __dict__ (e.g., certain ORMs).

When the number of objects is small and optimization offers little benefit.

During early development when requirements may change.

Interactive question: Have you used __slots__ in a project? Share the performance gains you observed!