The __slots__ mechanism was introduced in Python 2.2 to address the substantial memory overhead associated with the default object model, which allocates a per-instance __dict__ hash table for dynamic attribute storage. The problem arises in high-scale applications where millions of objects consume hundreds of megabytes of RAM just for dictionary bookkeeping, creating memory pressure and cache misses that degrade performance. The solution involves declaring __slots__ as a class variable containing an iterable of strings, which instructs the interpreter to reserve fixed C-array offsets for attributes instead of hash lookups, thereby eliminating the __dict__ and __weakref__ slots unless explicitly requested.
This optimization reduces per-instance memory footprint by roughly 40-50% and accelerates attribute access by avoiding hashing overhead. It also prevents the creation of __weakref__ unless explicitly included, further reducing object size. However, it introduces rigidity: instances cannot gain new attributes dynamically, and class hierarchies must maintain slot consistency to avoid silently reverting to dictionary storage.
We faced a critical memory bottleneck while developing a real-time analytics pipeline processing ten million network packets per second, where each packet was represented as a standard Python object. The default __dict__-based storage consumed 12GB of RAM for just the object overhead. This caused garbage collection pauses that violated our strict 10ms latency SLA.
Solution 1: Dictionary-based records. We initially considered storing packet data in plain dict instances. This offered simplicity and JSON serialization without custom codecs, but profiling revealed that dictionary hash tables still required 48 bytes per object overhead plus pointer indirection, reducing memory usage by only 12%. The lack of method encapsulation also scattered business logic across utility modules.
Solution 2: Named tuples. Switching to collections.namedtuple eliminated per-instance dictionaries using the C-structure backing of tuples. While this reduced memory significantly, immutability prevented us from updating packet timestamps during analysis, and the inability to add default values or validation methods forced awkward adapter patterns.
Solution 3: __slots__ classes. We refactored our Packet class to use fixed attribute storage:
class Packet: __slots__ = ('src_ip', 'dst_ip', 'payload', 'timestamp') def __init__(self, src_ip, dst_ip, payload, timestamp): self.src_ip = src_ip self.dst_ip = dst_ip self.payload = payload self.timestamp = timestamp def size(self): return len(self.payload)
This preserved our object-oriented design while removing __dict__ entirely. We selected this approach because it balanced memory efficiency with code maintainability, though we had to explicitly include '__weakref__' to support our object pool's weak reference cache.
The Result. Memory footprint collapsed to 4.5GB, allowing the pipeline to run on commodity hardware. Attribute access became 35% faster due to direct offset calculation rather than hashtable probes, though we had to refactor debugging code that relied on __dict__ for dynamic attribute injection.
How does __slots__ interact with multiple inheritance when parent classes define conflicting slot layouts?
When a child class inherits from multiple parents using __slots__, Python requires that the combined slot layout form a consistent linear sequence without overlapping names. If parents share attribute names in their slots, or if one parent uses __slots__ while another uses the default __dict__, the interpreter creates a __dict__ for the child anyway, silently negating memory savings. This happens because Python constructs a single slot table by concatenating parent slots. Candidates must understand that all parents should ideally use __slots__, and the child must explicitly declare additional slots to avoid dictionary fallback.
Why does the standard pickle module fail to reconstruct slotted objects without custom state methods?
By default, pickle attempts to save and restore an object's state via its __dict__ attribute. Since slotted classes lack this dictionary unless explicitly added, unpickling raises AttributeError when the loader tries to assign to non-existent slots. The solution requires implementing __getstate__ to return a dictionary of slot values and __setstate__ to restore them, or using the __reduce_ex__ protocol. Many candidates overlook that __slots__ changes the object layout contract, assuming pickle uses reflection on slot descriptors automatically.
Does __slots__ prevent instance attributes from being added dynamically at runtime?
Yes, but only if no parent class provides a __dict__ and '__dict__' is not explicitly included in the slots list. Candidates frequently miss that __slots__ merely removes the __dict__ attribute; if any base class retains the default dictionary storage, instances can still accept arbitrary attributes via that inherited dictionary. Furthermore, slotted instances remain mutable regarding existing attributes, and they can still be monkey-patched at the class level. True immutability requires additional steps like overriding __setattr__, not merely using __slots__.