Dataclasses

Overview Python classes are notoriously flexible but that flexibility comes at a cost. By default, Python stores instance attributes in a dictionary (`__dict__`). This allows you to add or modify attributes on the fly, but dictionaries are memory-heavy and require hash lookups. By implementing `__slots__`, you explicitly tell Python to skip the dictionary and use a more compact, static structure. This simple change can yield a performance boost of approximately 20% and significantly reduce the RAM footprint when managing thousands of objects. Prerequisites To follow this tutorial, you should understand: * Basic Python class structure and the `__init__` method. * The concept of dunder (double underscore) methods. * Familiarity with Dataclasses (introduced in Python 3.7+). Key Libraries & Tools * **`timeit`**: A built-in Python module used to measure the execution time of small code snippets. * **`Dataclasses`**: A decorator and module that simplifies class creation by automatically generating boilerplate code. * **SQLAlchemy**: A popular ORM that utilizes slots to maintain high performance when loading large datasets. Code Walkthrough The Standard Dictionary Approach In a standard class, Python uses a dynamic dictionary to store attributes. ```python class Person: def __init__(self, name: str, address: str): self.name = name self.address = address You can add attributes dynamically p = Person("Dev", "123 Code St") p.new_attr = "Dynamic!" ``` Implementing Slots Adding `__slots__` restricts the attributes to a predefined list, removing the `__dict__` overhead. ```python class PersonSlots: __slots__ = ("name", "address") def __init__(self, name: str, address: str): self.name = name self.address = address ``` Slots with Dataclasses In Python 3.10+, you can implement this even more cleanly using the `slots=True` parameter in the dataclass decorator. ```python from dataclasses import dataclass @dataclass(slots=True) class PersonDataClass: name: str address: str ``` Syntax Notes When you define `__slots__`, Python creates descriptors for each attribute. These are implemented in C and provide much faster access than a standard hashmap lookup. Note that once slots are defined, you can no longer add arbitrary attributes to the instance unless you explicitly include `"__dict__"` in the slots list. Practical Examples Slots are most effective in scenarios involving high-volume object creation. If you are building a data processing pipeline that reads millions of records from a SQLAlchemy database into objects, using slots will drastically reduce memory consumption and speed up attribute access during iterations. Tips & Gotchas * **Multiple Inheritance**: You cannot easily combine multiple parent classes if more than one of them defines non-empty slots. This often breaks mixin patterns. * **Predictability**: Use slots to enforce better design. Fixing your data structure at the start prevents the unpredictability of dynamic attributes popping up mid-execution.