Dictionaries are the favorite workhouse of the Pythonic style. Specifically in the cases of classes, instance attributes are stored in a __dict__ dunder, which is flexible, but uses a lot of overhead as each instance has its own dictionary. Creating millions of class instances for small objects can thus result in memory/performance issues.

Imagine, if you wanted to have a class that stored a datapoint as such:

class Point3D:
    def __init__(self, x: float, y: float, z: float) -> None:
        self.x = x
        self.y = y
        self.z = z

point1 = Point3D(1, 2, 3)
point1.__dict__     # This would be {\"x\": 1, \"y\": 2, \"z\": 3}

You may think it would be better to accomplish this with the @dataclass decorator, but the underlying implementation of a @dataclass is still a __dict__.

__slots__ is a memory-efficient alternative to __dict__. When you define __slots__, you declare what attributes an instance has, resulting in a much more efficient storage mechanism. The underlying implementation is a compact C array indexed by slot position.

class SlottedPoint3D:
    __slots__ = ("x", "y", "z") 
    
    def __init__(self, x: float, y: float, z: float) -> None:
        self.x = x
        self.y = y
        self.z = z

Python now allocates a fixed amount of memory with slot descriptor objects with pre-defined methods like __get__ and __set__ which index into the array. This direct memory lookup is faster than a dictionary lookup. You can even use dataclasses with direct slots support (Python 3.10+).

from dataclasses import dataclass

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

Here is a quick comparison after generating it. Check out the link here.

Memory per object (bytes)

Total creation time (seconds)

Per-object creation time (nanoseconds)

However, there is a tradeoff, here are some differences:

• You cannot add more attributes after predefining slots during instantiation.
• You cannot dynamically add attributes.
• You need to redeclare __slots__ in subclasses.
• You cannot set class attributes for defaults in __slots__ (but you can add class-level constants).