When should I use __slots__ in a Python class, and what are the tradeoffs?

[JacobZimmerman2029]

Body

I recently came across a Python class that uses __slots__, which I hadn’t seen much before. From what I understand, it’s supposed to save memory and maybe speed things up by preventing dynamic attribute creation.

But how much of a difference does it actually make in practice? Are there any downsides to using __slots__ in modern Python code? Just curious how often people reach for this in real-world projects.

Guidelines

• I have read and understood this category's guidelines before making this post.

[JBurrell999]

Good question, slots can definitely help in some situations, but it’s not always worth using. By default, Python gives every object a dynamic dict, which allows you to add attributes at runtime, but that also uses more memory. When you define slots, you tell Python exactly which attributes an object can have, and it skips creating the dict, which can lead to significant memory savings, especially if you’re creating thousands or millions of instances. That said, there are tradeoffs. You lose the ability to add new attributes unless you explicitly include dict in the slots, and using slots can make inheritance a bit trickier, especially when combining it with other classes that also define slots. Also worth noting: if you’re using dataclasses, you’ll need to explicitly enable slots via @DataClass(slots=True) (available in Python 3.10+). In general, slots makes sense in performance-critical systems, like compilers, interpreters, or memory-heavy data processing pipelines, but for most everyday Python code, the benefits are usually too small to matter.

[OutSquareCapital]

To add another perspective, I will disagree with the other answers and says that they should always be used as the default, unless dynamic attribute setting is a desired behavior (which is, in fact, very rarely the case).

Not only do they improve memory consumption and performance by avoiding the dict, but they also make your code safer!
See the example below:

from dataclasses import dataclass
from typing import Self

@dataclass
class Foo:
    name: str

    def set_name(self, new_name: str) -> Self:
        self.nam = new_name
        return self

This look more like a typo than intended behavior, right?
However, since this is perfectly valid python, this will run fine, and I will get no warning from my type checker (Pylance in strict mode) nor my linter (Ruff with almost all rules enabled).

However if I specify slots=True in the dataclass decorator, now my type checker give me a nice warning:

"nam" is not specified in __slots__

And when running the code it crashes rather than silently NOT updating my instance name:

Traceback (most recent call last):
  File "C:\Users\tibo\python_codes\pyochain\t.py", line 14, in <module>
    Foo("test").set_name("new_name")
    ~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^
  File "C:\Users\tibo\python_codes\pyochain\t.py", line 10, in set_name
    self.nam = new_name
    ^^^^^^^^
AttributeError: 'Foo' object has no attribute 'nam' and no __dict__ for setting new attributes. Did you mean: 'name'?

The only downsides they can bring, as already pointed out, is that they can make inerhitance trickier.

[jashwinsingh11]

slots is a Python class feature that tells the interpreter to store instance attributes in a fixed, static structure instead of each instance having its own dict. In practice, this can significantly reduce memory usage when you create many instances of a class (for example, thousands or millions), and it can provide a small speed improvement for attribute access due to the more compact layout. However, for most everyday applications, the performance difference is negligible, and the memory savings only matter at scale. There are also downsides: classes using slots cannot have arbitrary new attributes added at runtime, they interact less smoothly with multiple inheritance, and features like pickling, weak references, and some debugging or introspection tools may require extra work. Because of these trade-offs, slots is not commonly used in typical application code and is mostly seen in performance-sensitive libraries, data-heavy systems, or low-level frameworks where memory efficiency is critical.

[KausHalJHa-04]

slots is mainly a memory optimization feature in Python. By default, instances store attributes in a per-object dictionary (dict), which provides flexibility but adds memory overhead for every instance.
When a class defines slots, Python avoids creating dict and stores attributes in a more compact internal layout. In practice, this results in:
✅ What you gain
Significant memory savings when you create a very large number of objects (hundreds of thousands or millions).
A small potential speed improvement in attribute access, though this is usually modest in modern Python and mostly noticeable in performance-critical code.
🧩 Real-world usage
In many general-purpose applications, slots isn’t used frequently because memory isn’t typically a bottleneck. However, it’s common in performance-sensitive systems that create many small objects—such as parsers/AST nodes, simulations, graph/tree structures, or game entities.
✅ Modern approach
In modern Python, a clean alternative is using:

@DataClass(slots=True)

(Python 3.10+), which provides the benefits of slots while keeping code readable and maintainable.
Summary: slots can make a meaningful difference when working with many instances, especially for memory-heavy workloads, and is best applied where profiling shows it matters.