Slots & Hashing
Overview
Learn how slots optimizes class memory usage, and master custom class hashing protocols (hash and eq).
Learning Objectives
- Use slots to prevent default instance dict memory allocation.
- Make custom object instances hashable.
- Avoid hash keys lookups conflicts in sets.
Concept Explanation
Python objects store attributes inside dictionary dict buffers. Declaring __slots__ tells Python to use a fixed array instead, saving up to 70% memory. To use instances inside sets, override __eq__ and __hash__ correctly.
Code Examples
Example 1 — Basics
This example introduces the fundamental syntax and concepts.
class Point:
__slots__ = ('x', 'y')
def __init__(self, x, y):
self.x = x
self.y = y
Example 2 — Everyday Usage
This example demonstrates a realistic scenario handling business parameters.
class Node:
__slots__ = ('val', 'next')
def __init__(self, val):
self.val = val
self.next = None
# Node consumes significantly less memory when instantiated millions of times
Example 3 — Advanced Example
This example shows clean, production-grade code structure following senior development standards.
class UniqueKey:
def __init__(self, uid):
self.uid = uid
def __eq__(self, other):
if not isinstance(other, UniqueKey): return False
return self.uid == other.uid
def __hash__(self):
return hash(self.uid)
key1 = UniqueKey(1)
key2 = UniqueKey(1)
s = {key1}
print(key2 in s) # True! Hash matches and eq evaluates True
Visual Flow
The following execution flow represents the step-by-step evaluation inside the interpreter:
Instantiate slotted class → Pre-allocate array slots → Map attribute accesses directly by array indices
Common Mistakes
Review these common pitfalls when working with this topic:
- Trying to add dynamic attributes to slotted instances.
- Overriding eq without defining hash, which makes instances unhashable.
- Mutating attributes that are used inside hash collections calculations.
- Inheriting slotted classes from unslotted parents.
Best Practices
Enforce these Pythonic best practices in your codebase:
class Node:
def __init__(self, val):
self.val = val # Allocates dynamic __dict__ dictionary
class Node:
__slots__ = ('val', 'next')
def __init__(self, val):
self.val = val # Memory optimized slots
Performance Notes
Keep these optimization guidelines in mind for performance-sensitive hotpaths:
- slots reduces class instantiation memory usage by up to 60-70% by avoiding dict allocations.
- Attribute lookups are faster with slots because they bypass dictionary hash table searches.
Quick Revision
Use these key summaries for last-minute revision:
- slots avoids dictionary allocation in objects.
- Saves memory and speeds up lookups.
- Slotted objects cannot have dynamic attributes.
- Custom hash keys require eq and hash.
- Hash keys must remain constant.
- Overriding eq alone makes objects unhashable.
DataPlayArena Technical Editorial Board
Curated & maintained by enterprise data platform engineers with 10+ years in distributed systems.
Runtime Verification Standards: Every code example, query, and architecture diagram in this tutorial is compiled and verified against real runtimes (Apache Spark 3.5, Python 3.11, PostgreSQL, and DuckDB). If you spot any errata or want to suggest improvements, please submit feedback.