__slots__ and slots=True dataclasses: smaller instances with fixed attributes

What it is

By default every instance carries a __dict__ for its attributes and a __weakref__ slot. Declaring __slots__ = ("x", "y") reserves fixed storage for those names; the language reference states that this denies the creation of __dict__ and __weakref__ unless they are listed, that the space saved can be significant and that attribute lookup can be faster. @dataclass(slots=True) (3.10) generates __slots__ from the fields and, per the documentation, returns a new class instead of the original; weakref_slot=True (3.11) adds __weakref__ back so instances can be weakly referenced.

Why it matters

Programs holding millions of small records (parsed log lines, graph nodes, cache entries) pay for one dictionary per instance. Slots also catch typos: assigning a name not in __slots__ raises AttributeError instead of silently creating a new attribute.

How to apply

• Use @dataclass(slots=True, frozen=True) for value-like records created in bulk; measure with tracemalloc on a representative sample before and after, and keep the change only if the saving matters.
• Declare __slots__ in every class of the hierarchy (an empty tuple where no attributes are added). The reference states that when inheriting from a class without __slots__, instances always have __dict__ and __weakref__, so the saving disappears.
• Add "__dict__" to __slots__ when dynamic attributes are genuinely needed, and weakref_slot=True (or "__weakref__") when instances go into a WeakValueDictionary or another weak-referencing structure.
• List a dataclass's fields with dataclasses.fields(), not by reading __slots__; the documentation notes that fields already slotted in a base class are omitted from the generated __slots__.

Pitfalls

Because slots=True returns a new class, methods written in the class body originally kept referring to the old class through the implicit __class__ cell. The 3.13 documentation warns that zero-argument super() in such a method raises TypeError and names two-argument super() as the workaround; the 3.14 changelog records the fix (gh-90562). Code that must run on 3.10 to 3.13 therefore writes super(ClassName, self) or moves the call to a non-slotted base. The documentation also warns that passing parameters to a base class __init_subclass__ with slots=True raises TypeError. The reference states that multiple inheritance from more than one base with non-empty slots raises TypeError, and that class attributes cannot be used to set default values for slotted variables, since they would overwrite the descriptor. cached_property needs a __dict__, so it does not work on slotted classes.