__slots__ - Dramatic memory reduction

What is __slots__?

By default, every Python instance stores its attributes in a __dict__, a regular Python dictionary that lives on the heap alongside the object. This dictionary is flexible and allows you to add any attribute at any time, but it comes with a significant hidden memory cost, a dictionary has substantial overhead even when it only holds a few keys.

__slots__ is a class-level declaration that tells Python exactly which attributes an instance will ever have. Instead of creating a __dict__ for each instance, Python allocates a fixed, compact block of memory with one slot per attribute, like a C struct rather than a dictionary.

Python stores attributes in a regular dict

When you write this:

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

rp = RegularPoint(1.0, 2.0, 3.0)

Python needs somewhere to store the values of x, y, and z for that specific instance. It does this by automatically creating a regular Python dictionary, called __dict__, attached to every instance. You can see it directly:

print(rp.__dict__)       # {'x': 1.0, 'y': 2.0, 'z': 3.0}
print(type(rp.__dict__)) # <class 'dict'>

It is literally just a dictionary where the keys are the attribute names and the values are the attribute values:

  rp = RegularPoint(1.0, 2.0, 3.0)

  Heap
  ────
  [ RegularPoint instance ]
       │
       └──► [ __dict__ ]  ← a plain Python dict, created automatically
                │
                ├── key: "x"  value: 1.0
                ├── key: "y"  value: 2.0
                └── key: "z"  value: 3.0

This is why you can do things like:

# access via attribute syntax
print(rp.x)             # 1.0

# access via __dict__ directly — same thing
print(rp.__dict__["x"]) # 1.0

# add a new attribute at any time
rp.color = "red"
print(rp.__dict__)      # {'x': 1.0, 'y': 2.0, 'z': 3.0, 'color': 'red'}

The flexibility is great, you can add any attribute at any time because it is just a dictionary entry. But the cost is that every single instance carries a full dictionary, even if it only has 3 attributes.

A Python dictionary has significant overhead: it needs to handle hashing, collision resolution, and dynamic resizing which is why rp.__dict__ alone takes ~232 bytes just to store three numbers.

This is exactly the problem __slots__ solves, it replaces the dictionary with a fixed, compact block of memory.

The Hidden Cost of __dict__

When Python creates an instance, it actually allocates two separate objects on the heap, not one:

• Object 1 — the instance itself This is the actual object, it holds the type information, the reference count, and a pointer to the __dict__. It does not hold the attribute values directly.

• Object 2 — the __dict__ This is a separate, standalone Python dictionary that lives next to the instance on the heap. This is where the actual attribute values are stored.

  rp = RegularPoint(1.0, 2.0, 3.0)

  Heap
  ────

  Object 1                    Object 2
  ────────                    ────────
  [ RegularPoint instance ]   [ __dict__                    ]
    type: RegularPoint    ─────────────────────────────────►  "x" → 1.0
    refcount: 1               ▲                               "y" → 2.0
    pointer to __dict__ ──────┘                               "z" → 3.0

  ~48 bytes                   ~232 bytes
  (the instance)              (the dictionary)

You can verify both objects exist independently:

rp = RegularPoint(1.0, 2.0, 3.0)

# Object 1 — the instance
print(sys.getsizeof(rp))            # ~48 bytes
print(type(rp))                     # <class 'RegularPoint'>
print(id(rp))                       # memory address of Object 1

# Object 2 — the __dict__
print(sys.getsizeof(rp.__dict__))   # ~232 bytes
print(type(rp.__dict__))            # <class 'dict'>
print(id(rp.__dict__))              # different memory address — Object 2

So when you access rp.x, Python has to do two steps:

  rp.x

  Step 1 — find the instance on the heap
  ──────
  rp ──────────────────────────► [ RegularPoint instance ]
                                    pointer to __dict__ ──┐
                                                          │
  Step 2 — follow the pointer to __dict__, look up "x"    │
  ──────                                                  │
                                  ◄───────────────────────┘
                                  [ __dict__ ]
                                    "x" → 1.0  ← found it
                                    "y" → 2.0
                                    "z" → 3.0

With __slots__ there is only one object, the instance itself holds the attribute values directly, no dictionary, no second object, no two-step lookup:

  sp = SlottedPoint(1.0, 2.0, 3.0)

  Heap
  ────

  Object 1 only
  ─────────────
  [ SlottedPoint instance ]
    type: SlottedPoint
    refcount: 1
    slot x → 1.0   ← stored directly in the instance
    slot y → 2.0   ← no pointer, no second object
    slot z → 3.0

  ~72 bytes total — one object, one allocation

So the “two memory costs” means literally two heap allocations: one for the instance object and one for its __dict__ dictionary, where __slots__ reduces this to a single allocation.

Closer comparison

dict implies 2 objects

  rp = RegularPoint(1.0, 2.0, 3.0)

  Heap
  ────
  [ RegularPoint instance ]  ~48 bytes
       │
       └──► [ __dict__ ]  ~232 bytes  ← the hidden cost
                │
                ├── "x" ──► [ float: 1.0 ]
                ├── "y" ──► [ float: 2.0 ]
                └── "z" ──► [ float: 3.0 ]

  total per instance: ~280 bytes

With __slots__, the dictionary disappears entirely:

__slots__ implies 1 object

  sp = SlottedPoint(1.0, 2.0, 3.0)

  Heap
  ────
  [ SlottedPoint instance ]  ~72 bytes
       │
       ├── slot x ──► [ float: 1.0 ]
       ├── slot y ──► [ float: 2.0 ]
       └── slot z ──► [ float: 3.0 ]

  total per instance: ~72 bytes
  no __dict__ — slots are part of the object itself

How to use __slots__

class RegularPoint:
    def __init__(self, x, y, z):
        self.x = x
        self.y = y
        self.z = z
        # Python automatically creates __dict__ for each instance


class SlottedPoint:
    __slots__ = ["x", "y", "z"]    # pre-declare all attributes

    def __init__(self, x, y, z):
        self.x = x
        self.y = y
        self.z = z
        # no __dict__ created — attributes stored in fixed slots

Measuring the difference

import sys

rp = RegularPoint(1.0, 2.0, 3.0)
sp = SlottedPoint(1.0, 2.0, 3.0)

# the object itself
print(sys.getsizeof(rp))            # ~48 bytes  — object only
print(sys.getsizeof(rp.__dict__))   # ~232 bytes — the hidden dict cost
print(sys.getsizeof(rp) + \
      sys.getsizeof(rp.__dict__))   # ~280 bytes — true total

# slotted — no __dict__
print(sys.getsizeof(sp))            # ~72 bytes  — complete total
# sp.__dict__                       # ❌ AttributeError — no __dict__!

  Memory per instance

  RegularPoint                SlottedPoint
  ────────────                ────────────

  object:   ~48  bytes        object:  ~72 bytes
  __dict__: ~232 bytes        __dict__:  0 bytes  ← does not exist
  ─────────────────           ──────────────────
  total:    ~280 bytes        total:  ~72 bytes

                              ~74% less memory per instance

Real World Impact at Scale

The difference per instance is modest, but across hundreds of thousands of instances it becomes significant:

import tracemalloc

tracemalloc.start()

# 100,000 regular instances
regular = [RegularPoint(i, i, i) for i in range(100_000)]
snapshot1 = tracemalloc.take_snapshot()
regular_stats = snapshot1.statistics("lineno")
regular_mem = sum(stat.size for stat in regular_stats)

# 100,000 slotted instances
slotted = [SlottedPoint(i, i, i) for i in range(100_000)]
snapshot2 = tracemalloc.take_snapshot()
slotted_stats = snapshot2.statistics("lineno")
slotted_mem = sum(stat.size for stat in slotted_stats)

print(f"regular: {regular_mem / 1024 / 1024:.1f} MB")
print(f"slotted: {slotted_mem / 1024 / 1024:.1f} MB")

  100,000 instances

  RegularPoint                SlottedPoint
  ────────────                ────────────

  100,000 × ~280 bytes        100,000 × ~72 bytes
  = ~28 MB                    = ~7 MB

                              ~75% less memory at scale

The Trade-offs

__slots__ is not a free lunch, it trades flexibility for memory efficiency:

rp = RegularPoint(1.0, 2.0, 3.0)
sp = SlottedPoint(1.0, 2.0, 3.0)

# ✅ regular — can add attributes dynamically
rp.color = "red"                # works fine
rp.label = "origin"             # works fine

# ❌ slotted — only declared slots allowed
sp.color = "red"                # AttributeError: 'SlottedPoint' has no attribute 'color'
sp.label = "origin"             # AttributeError: 'SlottedPoint' has no attribute 'label'

class Slotted:
    __slots__ = ["x", "y"]

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


s = Slotted(1, 2)

# ✅ Benefits
# - Less memory (no __dict__ overhead)
# - Faster attribute access
# - Prevents accidental new attributes

# ❌ Limitations
s.z = 3                 # AttributeError — can't add new attributes
print(s.__dict__)       # AttributeError — no __dict__!

# Inheritance with __slots__ requires care
class Base:
    __slots__ = ["x"]

class Child(Base):
    __slots__ = ["y"]   # Only declare NEW attributes here

c = Child()
c.x = 1     # ✅  from Base
c.y = 2     # ✅  from Child

When to Use __slots__

	Regular class	__slots__ class
Memory per instance	~280 bytes	~72 bytes
Dynamic attributes	✅ Yes	❌ No
__dict__ present	✅ Yes	❌ No
Best for	General purpose objects	Large collections of simple objects
Typical use case	Business logic, models	Points, vectors, records, data classes

Rule of thumb

Use __slots__ when you know exactly what attributes an instance will have and you expect to create many instances of the class, data-heavy applications, simulations, parsers, and anywhere objects are created in bulk.