Python __slots__: Advantages and Disadvantages

python slots advantages disadvantages requires a clear understanding of the core syntax, runtime behavior, and practical implementation patterns demonstrated in the examples below.

When a Python class defines attributes, each instance normally carries a __dict__ to store them. That dictionary gives flexibility but costs memory and adds indirection. The __slots__ declaration changes this behavior by letting you declare a fixed set of attributes, trading flexibility for efficiency. Understanding the advantages and disadvantages of python **slots** is essential when you need to optimize memory or attribute access in long-running applications.

What slots Does

Declaring __slots__ in a class definition tells Python to allocate a fixed-size array for the listed attribute names instead of a per-instance dictionary. The class no longer creates a __dict__ for each instance, and attribute access uses a descriptor that maps the slot name to an index in that array.

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

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

This class can still store x and y values, but p = Point(1, 2) will not have a __dict__ attribute. Trying to set an undeclared attribute raises AttributeError.

Memory Savings

The primary advantage of __slots__ is reduced memory usage per instance. A Python dictionary has significant overhead: it stores keys, values, hash tables, and capacity padding. For millions of small objects, this overhead dominates. By replacing the dictionary with a compact array, each instance uses only the memory needed for the actual attribute values.

Consider a simple class representing a 3D coordinate:

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

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

Without __slots__, each Vector3 instance stores a __dict__ with three entries. With __slots__, the instance stores three references in a contiguous block. The exact difference depends on the Python version and platform, but the reduction is substantial—often 40–60% less memory for simple data-holder objects. This matters in workloads like game engines, scientific simulations, or large in-memory datasets.

Faster Attribute Access

Attribute lookup with __slots__ is also faster. Accessing obj.attr normally involves a dictionary lookup: hashing the attribute name, probing the hash table, and retrieving the value. With slots, the attribute name is resolved at class creation time to a fixed offset, so access becomes a simple array index operation. The speedup is modest for individual accesses but can accumulate in tight loops.

class Slotted:
    __slots__ = ('value',)
    def __init__(self, value):
        self.value = value

class Normal:
    def __init__(self, value):
        self.value = value

When you repeatedly read or write value in a loop, the slotted version avoids the dictionary lookup overhead. This is rarely the deciding factor for application-level performance, but it is a real benefit in performance-critical code paths.

Limitations and Tradeoffs

The main disadvantage of __slots__ is loss of flexibility. Without a __dict__, you cannot add new attributes to an instance after creation. This breaks patterns that rely on dynamic attribute assignment, such as monkey-patching or storing ad-hoc metadata.

p = Point(1, 2)
p.z = 3  # AttributeError: 'Point' object has no attribute 'z'

Additionally, instances no longer support pickle by default. The pickle module relies on __dict__ to serialize object state unless the class implements __reduce_ex__ or __getstate__/__setstate__. If you need to pickle slotted objects, you must add those methods manually.

Another limitation: __slots__ interacts poorly with multiple inheritance. If two base classes define non-empty __slots__, the derived class must explicitly define __slots__ to avoid a TypeError. Also, a class with __slots__ cannot have a __dict__ unless you include '__dict__' in the slot list, which defeats the memory savings.

Inheritance and slots

When a class inherits from a slotted class, the subclass gets its own __slots__ declaration. The subclass does not automatically inherit the parent's slots; it must define its own for new attributes. If the subclass does not declare __slots__, it will get a __dict__ anyway, negating the parent's memory savings.

class Base:
    __slots__ = ('a',)

class Child(Base):
    __slots__ = ('b',)
    def __init__(self, a, b):
        self.a = a
        self.b = b

Here Child instances have both a and b stored in slots. If Child omitted __slots__, it would have a __dict__ and the memory benefit would be lost. Also, if two parent classes both have slots, the child must list all of them or use a common base class with empty __slots__.

When to Use slots

Use __slots__ when you create a large number of instances of a class that acts primarily as a data container—where attributes are known in advance and dynamic assignment is not needed. Common examples include configuration records, coordinate points, tree nodes, and lightweight value objects.

Avoid __slots__ when you need to add attributes at runtime, rely on pickle without custom serialization, or use multiple inheritance with conflicting slot layouts. For small numbers of objects, the memory savings are negligible, and the added rigidity is not worth it.

A practical middle ground is to include '__dict__' in __slots__ when you want to keep the memory savings for known attributes but still allow dynamic ones. This adds the dictionary back, so the savings are reduced, but it preserves flexibility.

class FlexiblePoint:
    __slots__ = ('x', 'y', '__dict__')

Common Pitfalls and Edge Cases

One subtle issue is that __slots__ is implemented as a class-level descriptor. If you define a class with __slots__ and then create a subclass without __slots__, the subclass instances get a __dict__ and the slots are still present. This can lead to confusing behavior where some attributes are stored in slots and others in the dictionary.

Another pitfall is forgetting that __slots__ only affects instances, not the class itself. Class attributes and methods are unaffected. Also, you cannot have a slot with the same name as a class attribute or method; the descriptor would conflict.

When using __slots__ with @property or @classmethod, the slot name must not clash with the method name. If you need a property backed by a slot, use a different internal name.

class Temperature:
    __slots__ = ('_celsius',)
    @property
    def celsius(self):
        return self._celsius
    @celsius.setter
    def celsius(self, value):
        self._celsius = value

Alternatives to slots

If you need memory efficiency but also dynamic attributes, consider using dataclasses with slots=True (Python 3.10+). The @dataclass(slots=True) decorator generates a class with __slots__ automatically, while still providing generated __init__, __repr__, and comparison methods.

from dataclasses import dataclass

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

This gives you the memory benefits of __slots__ without manually writing the boilerplate. For even more control, you can use namedtuple or typing.NamedTuple, which are immutable and also use slots internally. These are good options when you need a lightweight data structure and can accept immutability.

For cases where you need dynamic attribute storage, there is no direct substitute for __dict__. The __slots__ approach is a deliberate tradeoff: you give up flexibility to gain efficiency. The choice should be based on whether the object's attribute set is fixed at class definition time and whether memory or access speed is a bottleneck in your application.