Python __slots__ Optimization

Where does the memory go?

Two classes hold the same coordinates. Why can one use less memory? Follow where Python stores their attributes, then see what changes when you add __slots__.

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

point = RegularPoint(1, 2)

point = SlottedPoint(1, 2)
point.x = 10
print(point.x, point.y)

for Point in (RegularPoint, SlottedPoint):
    points = [Point(x_value, y_value)
              for _ in range(1)]

class PlainChild(SlottedPoint):
    pass

point = PlainChild(1, 2)
print(hasattr(point, "__dict__"))

import weakref

point = SlottedPoint(1, 2)
weakref.ref(point)

What the declaration changes

__slots__ = ("x", "y") declares instance field names when Python creates the class. Python installs a descriptor for each name on the class; that descriptor reads and writes the corresponding reference field in an instance. The values remain ordinary Python objects.

A regular instance offers a flexible __dict__ interface. Its physical storage depends on the CPython version: attribute keys can be shared between instances, and CPython 3.13 can keep values inline. The explorer therefore shows a logical layout, rather than claiming every instance owns a separate full hash table.

For a class whose parents provide neither feature, slots avoid automatically adding an instance dictionary and weak-reference support. You can request either explicitly. The trade-off is a fixed set of field names, with memory savings that depend on the interpreter, inheritance hierarchy and workload.

Measure the objects you actually create

The recorded experiment isolates storage overhead by sharing two pre-existing values. Your application may allocate a different value for every field. Measure that workload too:

import sys
import tracemalloc

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

class SlottedPoint:
    __slots__ = ("x", "y")

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

def build(cls, n=100_000):
    return [cls(i, i + 1) for i in range(n)]

for cls in (RegularPoint, SlottedPoint):
    tracemalloc.start()
    points = build(cls)
    current, peak = tracemalloc.get_traced_memory()
    print(cls.__name__, f"retained: {current / 1024 / 1024:.2f} MiB")
    print(f"peak: {peak / 1024 / 1024:.2f} MiB")
    print("instance size:", sys.getsizeof(points[0]))
    tracemalloc.stop()

Declare the fields that belong to the class

class Point:
    __slots__ = ("x", "y")

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

This class now supports only the declared instance attributes. That is useful when the shape is part of the contract. It is wrong when callers are expected to attach extra fields for caching, instrumentation, or framework state.

Use a dataclass for a simple data container

from dataclasses import dataclass

@dataclass(slots=True)
class Point:
    x: float
    y: float

For simple data containers, slots=True keeps the field declaration in one place and generates slot storage. It is available in Python 3.10 and later. Dataclass field defaults are handled by the decorator, so they do not have the conflict that manually declared slots have with same-named class defaults.

Keep dynamic attributes or weak references deliberately

class HybridPoint:
    __slots__ = ("x", "y", "__dict__")

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

point = HybridPoint(1, 2)
point.label = "origin"  # stored in __dict__

Add __dict__ only when dynamic attributes are intentionally part of the API. Add __weakref__ when instances must work with weakref.ref(), weak caches, or observer registries.

For a dataclass on Python 3.11 or later, use @dataclass(slots=True, weakref_slot=True) when weak references are required. An inherited dictionary or weak-reference capability remains available even if the child declares slots.

Preserve the layout through inheritance

class BasePoint:
    __slots__ = ("x", "y")

class LabeledPoint(BasePoint):
    __slots__ = ("label",)

class Marker(BasePoint):
    __slots__ = ()

Slots declared in a parent are available to child instances. A child that adds fields should declare only the additional slot names. A child that adds no fields can use __slots__ = () to avoid bringing back an instance dictionary.

Know the limits

Slot names are not class defaults

class Wrong:
    __slots__ = ("x",)
    # x = 10  # would conflict with the slot descriptor

class Right:
    __slots__ = ("x",)

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

Multiple inheritance has layout limits

Only one parent class in a multiple-inheritance hierarchy can contribute non-empty slot storage. Other slotted bases need empty layouts such as __slots__ = ().

Slots are not packed numeric arrays

Slots store Python object references. For dense numeric data, arrays, NumPy, struct, or extension types may be a better representation.

The Python data model documents the slot and inheritance rules. The dataclasses reference describes the generated-layout options.

Choose the representation for the workload

Related concepts