Python Dataclasses — Mutable Default Traps That Break Prod

Every Python developer has written a class that does nothing except hold some data — a User, a Product, a Config — and then spent ten minutes writing __init__, __repr__, and __eq__ methods that all look almost identical. It's the kind of work that feels productive but is really just noise. Python 3.7 introduced dataclasses precisely to kill this ceremony, and they've quietly become one of the most useful tools in a Python developer's daily toolkit.

The problem dataclasses solve is subtle but real: when you write a plain class to hold data, Python gives you almost nothing for free. You have to manually wire up the constructor, teach the class how to print itself sensibly, decide how two instances should be compared, and handle freezing if you want immutability. Doing all of that correctly — especially edge cases like mutable default arguments — is surprisingly easy to get wrong. Dataclasses generate all of that code for you, correctly, based on simple field declarations.

By the end of this article you'll understand exactly what a dataclass generates under the hood, when to reach for one versus a plain class or a NamedTuple, how to add validation and computed fields without fighting the framework, and the three mistakes that reliably catch developers off guard in production code. You'll also be ready to answer the dataclass questions that pop up in Python technical interviews.

What @dataclass Actually Generates — and Why That Matters

The @dataclass decorator is a code generator. It reads the class-level field annotations you write, then silently injects methods into your class at definition time. Understanding which methods it generates — and why each one exists — is the key to using dataclasses confidently instead of cargo-culting them.

By default, @dataclass generates four things: __init__ (so you can construct instances with keyword arguments), __repr__ (so printing an instance gives you something useful instead of a memory address), __eq__ (so two instances with identical field values compare as equal), and nothing else. That last point matters — it does NOT generate __hash__ by default, for a very deliberate reason we'll come back to.

The real payoff is not just saving lines. It's correctness. The generated __eq__, for example, compares all fields in the order they're declared, and it correctly returns NotImplemented when compared to an object of a different type — something a hand-rolled == often gets wrong. You're not just saving keystrokes; you're getting battle-tested behavior for free.

from dataclasses import dataclass, field
from typing import List

# @dataclass reads the annotated class variables below and generates
# __init__, __repr__, and __eq__ automatically at class definition time.
@dataclass
class Product:
    name: str                          # Required field — no default, must be supplied
    price: float                       # Required field
    category: str = "Uncategorized"    # Optional field with a simple default value
    tags: List[str] = field(default_factory=list)  # Mutable default — MUST use field()

# Python calls the generated __init__ under the hood here
laptop = Product(name="ThinkPad X1", price=1299.99, category="Electronics", tags=["work", "portable"])
coffee = Product(name="Arabica Blend", price=14.50)  # category and tags get their defaults

# The generated __repr__ makes this print something actually useful
print(laptop)
print(coffee)

# The generated __eq__ compares field-by-field
identical_laptop = Product(name="ThinkPad X1", price=1299.99, category="Electronics", tags=["work", "portable"])
print(f"Same product? {laptop == identical_laptop}")   # True — field values match
print(f"Different products? {laptop == coffee}")        # False — fields differ

# You can still add your own methods — dataclass doesn't restrict this
def discounted_price(self, percent: float) -> float:
    return self.price * (1 - percent / 100)

Product.discounted_price = discounted_price  # Attaching for demo; normally define inside class
print(f"Laptop at 10% off: ${laptop.discounted_price(10):.2f}")

Frozen Dataclasses, Post-Init Logic, and Computed Fields

Once you're comfortable with the basics, three features unlock genuinely sophisticated patterns: frozen=True for immutability, __post_init__ for validation, and field(init=False) for computed attributes that depend on other fields.

Setting frozen=True tells the decorator to generate __setattr__ and __delattr__ methods that raise FrozenInstanceError on any attempt to mutate the object after construction. It also enables __hash__ generation, which is why frozen dataclasses can safely be used as dictionary keys or added to sets. Mutable objects shouldn't be hashable — Python enforces this opinion deliberately.

__post_init__ is the escape hatch for logic that belongs at construction time but can't be expressed as a plain default. Validation, normalization, and computing fields that depend on other fields all live here. It runs automatically after the generated __init__ finishes, so all fields are guaranteed to be populated when your code runs. Combined with field(init=False, repr=True), you can attach derived attributes that are calculated once and never need to be passed by the caller — keeping your API clean while your object stays self-contained.

from dataclasses import dataclass, field
from typing import List

@dataclass
class LineItem:
    product_name: str
    unit_price: float
    quantity: int

    # init=False means this field is NOT part of the constructor signature —
    # callers never pass it. repr=True means it shows up in print() output.
    subtotal: float = field(init=False, repr=True)

    def __post_init__(self):
        # __post_init__ runs right after __init__ completes.
        # All fields (name, unit_price, quantity) are already set when this runs.
        if self.unit_price < 0:
            raise ValueError(f"unit_price cannot be negative, got {self.unit_price}")
        if self.quantity < 1:
            raise ValueError(f"quantity must be at least 1, got {self.quantity}")
        # Compute and store the subtotal — callers never need to calculate this themselves
        self.subtotal = round(self.unit_price * self.quantity, 2)


# frozen=True makes the whole object immutable after construction.
# It also enables __hash__, so Order instances can be used as dict keys or in sets.
@dataclass(frozen=True)
class Order:
    order_id: str
    customer_email: str
    items: tuple  # Use tuple, not list — lists are mutable and incompatible with frozen

    # This computed field summarises the order total
    total: float = field(init=False, repr=True)

    def __post_init__(self):
        if not self.customer_email or "@" not in self.customer_email:
            raise ValueError(f"Invalid customer email: '{self.customer_email}'")
        # With frozen=True, self.field = value raises FrozenInstanceError.
        # object.__setattr__ is the approved workaround inside __post_init__.
        object.__setattr__(self, "total", round(sum(item.subtotal for item in self.items), 2))


# --- Build a realistic order ---
item1 = LineItem(product_name="Mechanical Keyboard", unit_price=89.99, quantity=1)
item2 = LineItem(product_name="USB-C Hub", unit_price=34.50, quantity=2)
print(item1)
print(item2)

order = Order(order_id="ORD-001", customer_email="alex@example.com", items=(item1, item2))
print(order)
print(f"Order total: ${order.total}")

# Confirm immutability
try:
    order.order_id = "ORD-999"   # This should blow up
except Exception as err:
    print(f"Caught expected error: {err}")

# Confirm frozen dataclasses are hashable
processed_orders = {order}  # Can be added to a set
print(f"Order in set: {order in processed_orders}")

# Confirm validation fires
try:
    bad_item = LineItem(product_name="Ghost Product", unit_price=-5.00, quantity=1)
except ValueError as err:
    print(f"Validation caught: {err}")

Dataclass vs Plain Class vs NamedTuple vs TypedDict — Full Comparison

Choosing the right data container is a decision that compounds. Python offers four main options: plain classes, NamedTuples, dataclasses, and TypedDicts. Each has a distinct design center.

TypedDict (from typing) is unique: it provides type hints for dictionary keys but does not generate any methods — instances are plain dicts. It's perfect for API response payloads where you want static analysis but don't need object behavior. Dataclasses remain the best all-rounder for structured data.

from dataclasses import dataclass
from typing import NamedTuple, TypedDict

# Plain class
class PointClass:
    def __init__(self, x: float, y: float):
        self.x = x
        self.y = y

# NamedTuple
class PointNT(NamedTuple):
    x: float
    y: float

# Dataclass
@dataclass
class PointDC:
    x: float
    y: float

# TypedDict — just type hints, still a plain dict
class PointTD(TypedDict):
    x: float
    y: float

# Usage
p_class = PointClass(1.0, 2.0)
p_nt = PointNT(1.0, 2.0)
p_dc = PointDC(1.0, 2.0)
p_td: PointTD = {'x': 1.0, 'y': 2.0}

print(f"Class repr: {p_class}")
print(f"NamedTuple repr: {p_nt}")
print(f"Dataclass repr: {p_dc}")
print(f"TypedDict repr: {p_td}  (plain dict)")

Using dataclasses.asdict() and dataclasses.astuple() for Serialization

One of the most practical features of dataclasses is built-in conversion to plain dicts and tuples. The functions dataclasses.asdict() and dataclasses.astuple() recursively convert a dataclass instance (and all nested dataclasses) into Python primitives, making JSON serialization trivial.

asdict() returns a dictionary where field names become keys. It handles nested dataclasses, lists of dataclasses, and other common collection types. astuple() similarly converts to a tuple in field order. Both functions create deep copies — they do not return the same objects, so modifying the result won't affect the original instance.

This is especially useful when you need to serialize your domain objects to JSON (via json.dumps) or pass them to a database driver that expects dicts. Because asdict is recursive, a single call can flatten an entire object graph.

from dataclasses import dataclass, asdict, astuple
from datetime import datetime
from typing import List

@dataclass
class Address:
    street: str
    city: str
    zip_code: str

@dataclass
class Customer:
    name: str
    email: str
    address: Address
    tags: List[str]

# Build a nested dataclass
addr = Address(street="123 Main St", city="Springfield", zip_code="12345")
customer = Customer(name="Alice", email="alice@example.com", address=addr, tags=["premium", "vip"])

# Convert to dict — recursive
data_dict = asdict(customer)
print("asdict:")
print(data_dict)

# Convert to tuple — field order
data_tuple = astuple(customer)
print("\nastuple:")
print(data_tuple)

# JSON serialization with asdict
import json
print("\nJSON:")
print(json.dumps(data_dict, indent=2))

# Verify deep copy: modifying the dict does not affect the original
data_dict["name"] = "Bob"
print(f"\nOriginal name unchanged: {customer.name}")

Keyword-Only Fields with KW_ONLY (Python 3.10+)

Python 3.10 introduced the KW_ONLY sentinel from the dataclasses module. When used as a field marker, it forces all fields declared after it to be keyword-only in the generated __init__. This solves a common pain point: preventing positional argument errors when a dataclass has many optional fields.

Without KW_ONLY, callers can accidentally pass a value for the wrong optional field by position. With KW_ONLY, every field after the sentinel must be named explicitly. This is especially useful for dataclasses with many fields where the order is not obvious, or where backward compatibility matters — you can later add new fields without breaking positional callers.

The sentinel itself is not a real field — it's just a marker for the code generator. It does not appear in __init__, __repr__, or equality comparisons. It works alongside frozen, slots, and other decorator options.

from dataclasses import dataclass, field, KW_ONLY

@dataclass
class User:
    username: str          # Required, can be positional or keyword
    email: str             # Required, can be positional or keyword
    _ = KW_ONLY            # All fields after this are keyword-only
    phone: str | None = None
    role: str = "viewer"
    department: str | None = None

# Valid calls:
user1 = User("alice", "alice@example.com", role="admin")
user2 = User("bob", "bob@example.com", phone="555-0100", department="eng")
print(user1)
print(user2)

# This would raise TypeError: User.__init__() takes 3 positional arguments but 4 were given
try:
    user3 = User("charlie", "charlie@example.com", "555-0200")  # phone as positional
except TypeError as e:
    print(f"Caught: {e}")

Dataclass vs Plain Class vs NamedTuple — Choosing the Right Tool

Knowing how to write a dataclass is only half the skill. The other half is knowing when NOT to use one. Python gives you three main options for data-holding objects, and they're not interchangeable.

A plain class is still the right choice when your object has significant behaviour — methods that do real work, internal state that shouldn't be exposed as fields, or a complex inheritance hierarchy. Reaching for @dataclass to add some free __repr__ to a class with ten methods is reasonable; using it as the base for a deep OOP hierarchy gets messy quickly.

NamedTuple (from the typing module) is the right choice when you need true immutability with tuple semantics — unpacking, indexing by position, and guaranteed hashability without any extra configuration. NamedTuples are also marginally faster for read-heavy access patterns because they're backed by actual tuples. Their weakness is that you can't easily add mutable defaults, computed fields, or post-init logic.

Dataclasses sit in the sweet spot: mutable by default (frozen when you want), rich feature set, extensible with regular methods, and compatible with tools like dataclasses.asdict() and dataclasses.astuple() for serialization. They're the default choice for config objects, API response models, domain entities, and anything you'd previously have written as a verbose plain class.

from dataclasses import dataclass, asdict, astuple
from typing import NamedTuple

# --- Option 1: Plain Class ---
# You write everything yourself. Maximum control, maximum boilerplate.
class PlainPoint:
    def __init__(self, x: float, y: float):
        self.x = x
        self.y = y

    def __repr__(self):
        return f"PlainPoint(x={self.x}, y={self.y})"

    def __eq__(self, other):
        if not isinstance(other, PlainPoint):
            return NotImplemented
        return self.x == other.x and self.y == other.y


# --- Option 2: NamedTuple ---
# Immutable, tuple-compatible, fast, but no post-init or mutable defaults.
class NamedPoint(NamedTuple):
    x: float
    y: float


# --- Option 3: Dataclass ---
# Generated boilerplate + full class features + serialization helpers.
@dataclass
class DataPoint:
    x: float
    y: float

    def distance_from_origin(self) -> float:
        return (self.x ** 2 + self.y ** 2) ** 0.5


# -- Demonstrate the differences --

plain = PlainPoint(3.0, 4.0)
named = NamedPoint(3.0, 4.0)
data  = DataPoint(3.0, 4.0)

print("--- Repr ---")
print(plain)  # Our hand-rolled repr
print(named)  # NamedTuple gives this for free
print(data)   # Dataclass gives this for free

print("\n--- Equality ---")
print(PlainPoint(1, 2) == PlainPoint(1, 2))  # True — we wrote __eq__
print(NamedPoint(1, 2) == NamedPoint(1, 2))  # True — tuple equality
print(DataPoint(1, 2) == DataPoint(1, 2))    # True — generated __eq__

print("\n--- Tuple unpacking (NamedTuple only) ---")
x_coord, y_coord = named          # Works because NamedTuple IS a tuple
print(f"Unpacked: x={x_coord}, y={y_coord}")
# x_coord, y_coord = data         # Would raise: cannot unpack dataclass directly

print("\n--- Dataclass serialization helpers ---")
print(asdict(data))    # {'x': 3.0, 'y': 4.0} — perfect for JSON serialization
print(astuple(data))   # (3.0, 4.0)

print("\n--- Custom method on dataclass ---")
print(f"Distance from origin: {data.distance_from_origin():.2f}")

print("\n--- Mutability ---")
data.x = 10.0          # Works fine — dataclasses are mutable by default
print(f"Mutated DataPoint: {data}")
try:
    named = named._replace(x=10.0)  # NamedTuple 'mutation' returns a new instance
    print(f"New NamedPoint: {named}")
except Exception as err:
    print(err)

Dataclass Inheritance — Parent and Child Field Interactions

Dataclasses support inheritance, but there's a critical constraint: if a parent dataclass has any field with a default value, every field in a child dataclass must also have a default. This is a direct consequence of how the generated __init__ constructs the signature — you can't have a non-default argument after a default argument.

Consider a base dataclass for a database entity: an id field with a default of None (auto-generated on save), and a created_at with a default of field(default_factory=datetime.now). Now a child dataclass adds a required name field. The generated __init__ would be __init__(self, id=None, created_at=..., name=...). That's invalid Python: name comes after defaults. The solution is to either give all child fields defaults, or restructure the hierarchy so defaults only appear in leaf classes. A common pattern is to use an abstract base class without defaults, then concrete implementations with all defaults.

Another gotcha: inherited field order matters. Python collects all fields from parent classes and combines them in reverse MRO order (most base first) for __init__ and __repr__. This can surprise you if you rely on positional arguments. Always use keyword arguments with dataclass constructors.

from dataclasses import dataclass, field
from datetime import datetime
from typing import Optional

# Base dataclass with defaults — risky for inheritance
@dataclass
class BaseEntity:
    id: Optional[int] = None
    created_at: datetime = field(default_factory=datetime.now)

# This will raise: TypeError: non-default argument 'name' follows default argument
# class User(BaseEntity):
#     name: str
#     email: str

# Fix: give all child fields defaults, or separate into two hierarchies
@dataclass
class BaseEntityNoDefaults:
    id: int
    created_at: datetime

@dataclass
class User(BaseEntityNoDefaults):
    name: str
    email: str

# Alternatively, if you want defaults in child:
@dataclass
class Config:
    debug: bool = False
    timeout: int = 30

# child class with all fields having defaults
@dataclass
class ExtendedConfig(Config):
    feature_flag: bool = False
    retry_count: int = 3

print(Config(debug=True))
print(ExtendedConfig(debug=True, feature_flag=True))

Slots Dataclasses and Performance Optimisation

Python 3.10 introduced the slots parameter @dataclass(slots=True). This tells the decorator to generate a class with __slots__ set, and to define slots for each field. Slots eliminate the per-instance __dict__, reducing memory usage by roughly 30-50% for large numbers of instances. Attribute access is also faster because slots bypass the dict lookup.

But slots come with trade-offs. You can't add arbitrary new attributes to a slots instance — no more obj.new_field = value without raising AttributeError. Inheritance becomes trickier: if a parent class uses slots, the child must also define slots to avoid conflicts. You also lose the ability to use weak references unless you explicitly include __weakref__ in __slots__.

For domain objects that you instantiate thousands of times — like event payloads, cache entries, or data transfer objects — slots=True is an easy win. For config objects or rarely created dataclasses, the benefit is negligible, and the flexibility loss may not be worth it.

from dataclasses import dataclass
from sys import getsizeof

# Standard dataclass
@dataclass
class Point:
    x: float
    y: float

# Slots dataclass — Python 3.10+
@dataclass(slots=True)
class SlottedPoint:
    x: float
    y: float

# Memory comparison
p = Point(1.0, 2.0)
sp = SlottedPoint(1.0, 2.0)

print(f"Point instance size: {getsizeof(p)} bytes (__dict__ size: {getsizeof(p.__dict__)})")
print(f"SlottedPoint instance size: {getsizeof(sp)} bytes (no __dict__)")

# Speed test (simplified)
import timeit
print(f"Point access: {timeit.timeit(lambda: p.x, number=10_000_000):.3f}s")
print(f"SlottedPoint access: {timeit.timeit(lambda: sp.x, number=10_000_000):.3f}s")

# Slots prevent arbitrary attribute assignment
try:
    sp.z = 3.0
except AttributeError as e:
    print(f"SlottedPoint rejects new attr: {e}")

# p.z = 3.0  # Works fine on regular dataclass

Mutable Defaults: The Silent Data Corruption Bomb

You've seen it. A dataclass with a default empty list. Two instances, same list. One appends, the other sees it. This isn't a Python quirk — it's a reference trap baked into how Python function defaults work.

Dataclasses try to protect you. If you write items: list = [], the decorator catches it and raises a ValueError. It forces you to use field(default_factory=list). That's not bureaucracy — that's a guard rail.

default_factory calls a zero-argument callable every time a new instance is created. Each instance gets its own fresh mutable object. Lists, dicts, sets, custom objects — always use default_factory.

The trap deepens with nested structures. A dict of lists? Write a function or a lambda: field(default_factory=lambda: {'errors': []}). If you use the same list as a default across fields, you're sharing state across a class hierarchy.

Senior rule: If you see a mutable default in production code, flag it immediately. It's not style — it's correctness.

// io.thecodeforge — python tutorial

from dataclasses import dataclass, field
from typing import List, Dict

# WRONG: Will raise ValueError in Python 3.7+
@dataclass
class ShoppingCart:
    items: List[str] = []  # ValueError! mutable default

# RIGHT: Each cart gets its own list
@dataclass
class ShoppingCart:
    items: List[str] = field(default_factory=list)

# NESTED MUTABLE:
@dataclass
class Order:
    line_items: Dict[str, List[str]] = field(
        default_factory=lambda: {"pending": [], "completed": []}
    )

cart1 = ShoppingCart()
cart1.items.append("apple")
cart2 = ShoppingCart()
print(cart2.items)  # [] — not ["apple"]

Class Variables vs Instance Fields: The Annotation Ambush

Type annotations in a dataclass aren't just hints — they're field declarations. Every annotated variable becomes an instance field unless you explicitly mark it otherwise.

Want a class-level constant? Forget field() tricks. Use ClassVar from typing, or slap an underscore prefix. ClassVar tells the decorator: "hands off, this belongs to the class, not instances."

Without ClassVar, your "class variable" becomes an instance field, silently overriding what you intended. The __init__ method swallows it, and suddenly your shared config constant is per-instance.

Init-only variables (InitVar) are the opposite — they feed into __post_init__ but don't persist as fields. Use them for dependency injection or computed state that doesn't need to stick around.

The pattern: ClassVar for global config, InitVar for setup data, normal annotations for persistent state. Mix them and your codebase becomes a minefield of unexpected behavior.

// io.thecodeforge — python tutorial

from dataclasses import dataclass, InitVar
from typing import ClassVar

@dataclass
class DatabaseConfig:
    # Class-level constant — not an instance field
    DEFAULT_TIMEOUT: ClassVar[int] = 30
    
    # Instance fields
    host: str
    port: int
    
    # Init-only: consumed by __post_init__, not stored
    connection_pool: InitVar[int] = 10
    
    def __post_init__(self, connection_pool: int):
        print(f"Creating pool with {connection_pool} connections")

config = DatabaseConfig("localhost", 5432, connection_pool=20)
print(config.DEFAULT_TIMEOUT)  # 30 — class var
# print(config.connection_pool)  # AttributeError! doesn't exist

Descriptor Fields: When Dataclasses Need Runtime Logic

Dataclasses generate __init__ and __setattr__ that bypass descriptor protocols. If you slap a @property or a custom descriptor on a field, the dataclass machinery will flat-out ignore it during construction.

This means validation, computed properties, or lazy loading inside a descriptor won't fire during __init__. You assign a raw value, the descriptor's __set__ never runs.

The fix: Use __post_init__ to trigger manual validation, or define the field with field(init=False) and handle assignment yourself. Better yet, for computed fields, use @property on the class directly — dataclasses won't interfere with properties defined outside the decorator.

Custom descriptors still work for attribute access after construction, but you must ensure the field is excluded from __init__. Otherwise, you get silent failures where validation never runs.

Production reality: Most descriptor patterns are overengineering for dataclasses. Keep it simple — if you need validation, do it in __post_init__. If you need computed state, use @property.

// io.thecodeforge — python tutorial

from dataclasses import dataclass, field

class PositiveInt:
    def __set_name__(self, owner, name):
        self._name = f"_{name}"
    
    def __get__(self, obj, objtype=None):
        return getattr(obj, self._name, 0)
    
    def __set__(self, obj, value):
        if value < 0:
            raise ValueError(f"{self._name} must be non-negative")
        object.__setattr__(obj, self._name, value)

@dataclass
class Warehouse:
    # Descriptor — but __set__ won't fire in __init__
    capacity: int = field(default=0)
    
    # Manually apply descriptor after init
    def __post_init__(self):
        self.capacity = self.capacity  # triggers descriptor __set__

ware = Warehouse(capacity=100)
print(ware.capacity)  # 100

# This raises ValueError
ware.capacity = -50

Python's Dataclass in a Nutshell

Dataclasses are a code generation tool. They automate the boilerplate of data containers: __init__, __repr__, __eq__, and __hash__. That's it. No magic, no metaprogramming overhead — just a decorator that writes methods you'd otherwise write by hand.

Why does this matter? Because every line of boilerplate you delete is a line that can't hold a hidden bug. When you write __init__ manually, you risk typo'd attribute names, wrong default values, or missed validations. Dataclasses eliminate that class of error entirely.

The real power isn't the decorator itself — it's the contract. A dataclass declares: "I am a data carrier with explicit fields, explicit types, and zero implicit behavior." That contract makes your code auditable and your refactors safe. Production teams swear by dataclasses because they turn a runtime mess into a compile-time constraint (well, as close as Python gets).

// io.thecodeforge — python tutorial

from dataclasses import dataclass

@dataclass
class User:
    id: int
    name: str
    active: bool = True

# That's it. __init__, __repr__, __eq__ are generated.
u = User(id=42, name="Alice")
print(u)
print(repr(u))
print(u == User(id=42, name="Alice"))

Conclusion: What You Should Actually Do Next

Stop writing manual __init__ methods. Stop using dicts for structured data. Reach for @dataclass first, NamedTuple second (when ordering matters), and TypedDict only when interfacing with legacy dict-based APIs. That's the hierarchy.

Your takeaway from this guide should be sharpened judgment. Not "use dataclasses because they're new" — use them because they enforce discipline. Frozen dataclasses prevent mutation rot. KW_ONLY fields prevent argument-order spaghetti. __post_init__ catches bad data at construction, not three stack frames later.

For further reading: study the CPython source for dataclasses.py — it's 700 lines of pure Python, eminently readable. Then read Hynek Schlawack's blog posts on attrs (the progenitor). Finally, internalize PEP 557. The difference between a senior and a junior is knowing not just what the tool does, but why the tool exists and when to set it aside.

// io.thecodeforge — python tutorial

from dataclasses import dataclass, field
from typing import ClassVar

@dataclass(frozen=True, kw_only=True)
class Config:
    host: str
    port: int = field(default=8080, metadata={"env": "PORT"})
    log_level: str = "INFO"
    # This is your production new default pattern

# No more guessing argument order
c = Config(host="localhost", port=9090)
print(c)
# c.port = 80  # frozen=True prevents this at runtime

dataclasses.Field(): Precision Control Over Instance Fields

Standard dataclass fields are declared with type hints and optional defaults. But what if you need to enforce metadata, hide a field from __repr__, exclude it from comparison, or mutate it safely? That's where dataclasses.Field() steps in. It's not a function you call directly in field definitions; instead, Python provides it behind the scenes when you use field(). The field() factory returns a Field descriptor object that controls behavior at the class level. Key parameters include default, default_factory, init, repr, compare, hash, and metadata. For example, a compare=False field won't participate in equality checks, perfect for timestamps or internal IDs. The metadata dict lets you attach arbitrary data (e.g., validation rules) without polluting the instance namespace. Use fields() on a dataclass to inspect its Field objects programmatically. This is how you build production-grade, self-documenting schemas without sacrificing Python's dynamic nature.

// io.thecodeforge — python tutorial
// 25 lines max
from dataclasses import dataclass, field, fields
import uuid

default_id = lambda: uuid.uuid4().hex[:8]

@dataclass
class User:
    name: str
    uid: str = field(default_factory=default_id, repr=False, compare=False)
    _internal_cache: dict = field(default_factory=dict, init=False, repr=False)

@dataclass
class Order:
    product: str
    quantity: int = field(default=1, metadata={'min': 1})

user = User(name="Alice")
print(user)  # User(name='Alice') — no uid leaked
print(fields(user)[1].metadata)  # {} (empty for uid)
print(fields(Order)[1].metadata)  # {'min': 1}

Post-Init Processing: Hook Into the Birth of Every Instance

Dataclasses generate __init__ automatically, but real-world objects often need validation, normalization, or derived attributes right after creation. Enter __post_init__: a special method Python calls immediately after the generated __init__ finishes. It receives no arguments beyond self, but you can access freshly assigned fields. Common uses: converting a birthdate string to a dataclass, computing age from a birth year, enforcing business rules (e.g., end date after start date), or populating fields marked with init=False. Combine with field(init=False) to define computed attributes that don't clutter constructor signatures. For type safety, declare those fields with a type hint and assign inside __post_init__. This keeps your API clean while ensuring every instance is invariants-valid. Beware: __post_init__ runs during __init__, not deserialization or unpickling—re-hook accordingly. It's your last chance to mutate before the object is 'live'.

// io.thecodeforge — python tutorial
// 25 lines max
from dataclasses import dataclass, field
from datetime import date

@dataclass
class Employee:
    name: str
    birth_year: int
    age: int = field(init=False)  # computed
    employee_id: str = field(default="TBD", init=False)

    def __post_init__(self):
        self.age = date.today().year - self.birth_year
        if self.age < 16:
            raise ValueError("Minimum age is 16")
        self.employee_id = f"EMP-{self.name[:3].upper()}-{self.birth_year}"

try:
    e = Employee("Alice", 2010)
except ValueError as err:
    print(err)  # Minimum age is 16

e2 = Employee("Bob", 1990)
print(e2)  # Employee(name='Bob', birth_year=1990, age=35, employee_id='EMP-BOB-1990')

Dataclasses in Python 3.12: slots=True and weakref_slot

Python 3.12 introduced two powerful enhancements to dataclasses: the slots=True parameter and the weakref_slot parameter. These features allow for more memory-efficient and flexible dataclass definitions.

slots=True

When you define a dataclass with @dataclass(slots=True), Python generates a __slots__ attribute for the class. This prevents the creation of a __dict__ per instance, significantly reducing memory usage. Slots also speed up attribute access. However, note that slots dataclasses cannot have class variables that are also instance fields, and inheritance requires careful handling (all parent classes must also use slots).

Example: ```python from dataclasses import dataclass

@dataclass(slots=True) class Point: x: float y: float

p = Point(1.0, 2.0) print(p.x) # 1.0 # p.z = 3.0 # AttributeError: 'Point' object has no attribute 'z' ```

weakref_slot

When weakref_slot=True is set (requires slots=True), a __weakref__ slot is added to the class, enabling weak references to instances. By default, slots dataclasses do not support weak references. This is useful for caching or observer patterns.

Example: ```python import weakref from dataclasses import dataclass

@dataclass(slots=True, weakref_slot=True) class Node: value: int

n = Node(42) ref = weakref.ref(n) print(ref() is n) # True ```

Production Considerations

Using slots=True is a best practice for high-performance applications with many instances. However, be aware of limitations: you cannot dynamically add new attributes, and inheritance from non-slots classes is problematic. The weakref_slot option should be used only when weak references are needed, as it adds a small overhead.

from dataclasses import dataclass
import weakref

@dataclass(slots=True, weakref_slot=True)
class Node:
    value: int

n = Node(42)
ref = weakref.ref(n)
print(ref() is n)  # True

Frozen Dataclasses: Immutability for Data Objects

Frozen dataclasses provide immutability by setting frozen=True in the @dataclass decorator. Once an instance is created, its attributes cannot be modified. This is ideal for representing data that should not change, such as configuration constants, database records, or value objects.

How Frozen Dataclasses Work

When frozen=True, the generated __setattr__ and __delattr__ methods raise FrozenInstanceError if you try to modify an attribute. The class also becomes hashable if eq=True (default) and all fields are hashable, allowing instances to be used in sets and as dictionary keys.

Example: ```python from dataclasses import dataclass

@dataclass(frozen=True) class ImmutablePoint: x: float y: float

p = ImmutablePoint(1.0, 2.0) # p.x = 3.0 # FrozenInstanceError: cannot assign to field 'x' ```

Post-Init and Computed Fields

Even with frozen dataclasses, you can use __post_init__ to compute fields. However, you must use object.__setattr__ to set fields inside __post_init__ because direct assignment is forbidden.

Example: ```python from dataclasses import dataclass, field

@dataclass(frozen=True) class Rectangle: width: float height: float area: float = field(init=False)

def __post_init__(self): object.__setattr__(self, 'area', self.width * self.height)

r = Rectangle(3, 4) print(r.area) # 12.0 ```

Performance and Use Cases

Frozen dataclasses are slightly slower due to the attribute access checks, but the safety benefits often outweigh the cost. They are perfect for functional programming patterns, caching, and multi-threaded environments where immutability prevents race conditions.

from dataclasses import dataclass, field

@dataclass(frozen=True)
class Rectangle:
    width: float
    height: float
    area: float = field(init=False)

    def __post_init__(self):
        object.__setattr__(self, 'area', self.width * self.height)

r = Rectangle(3, 4)
print(r.area)  # 12.0

Dataclasses vs NamedTuple vs TypedDict: Comparison

Python offers several ways to define structured data: dataclasses, NamedTuple, and TypedDict. Each has its strengths and trade-offs. Understanding when to use which can improve code clarity and performance.

Dataclasses - Mutable by default, but can be frozen. - Full class features: methods, inheritance, __post_init__, slots. - Type annotations required. - Best for complex data objects with behavior.

NamedTuple - Immutable (like tuples). - Lightweight, memory-efficient. - Supports indexing and unpacking. - Cannot have methods easily (though you can subclass). - Best for simple, immutable data containers.

TypedDict - Not a class; it's a type hint for dictionaries. - Mutable, but no runtime enforcement. - Allows dynamic keys and values. - Best for JSON-like data or when you need dictionary flexibility.

Comparison Example ```python from dataclasses import dataclass from typing import NamedTuple, TypedDict

@dataclass class PointDC: x: float y: float

class PointNT(NamedTuple): x: float y: float

class PointTD(TypedDict): x: float y: float

# Usage p_dc = PointDC(1.0, 2.0) p_nt = PointNT(1.0, 2.0) p_td: PointTD = {'x': 1.0, 'y': 2.0} ```

When to Choose - Use dataclasses for most cases: they offer the best balance of features and readability. - Use NamedTuple for lightweight, immutable data that benefits from tuple behavior (e.g., unpacking). - Use TypedDict when interfacing with JSON APIs or when you need dictionary methods.

Performance NamedTuple is slightly faster for creation and attribute access than dataclasses. TypedDict is just a dict, so it's fast but lacks type safety at runtime.

from dataclasses import dataclass
from typing import NamedTuple, TypedDict

@dataclass
class PointDC:
    x: float
    y: float

class PointNT(NamedTuple):
    x: float
    y: float

class PointTD(TypedDict):
    x: float
    y: float

p_dc = PointDC(1.0, 2.0)
p_nt = PointNT(1.0, 2.0)
p_td: PointTD = {'x': 1.0, 'y': 2.0}

print(p_dc, p_nt, p_td)