field() is the answer. But also frozen=True for immutability, post_init for validation, and slots=True for memory. Four weapons that make dataclasses production-grade.

Let me start with the mutable default problem. You have a dataclass:

from dataclasses import dataclass

@dataclass
class PendingOrder:
    order_id: str
    items: list = []  # DANGER: One list shared by all instances

Every PendingOrder instance shares the same list object. You modify it in one order, all orders see the change.

They do not know better, or they learn the hard way. The fix is field(default_factory):

from dataclasses import dataclass, field

@dataclass
class PendingOrder:
    order_id: str
    items: list = field(default_factory=list)  # Each instance gets its own list

Now dataclasses calls list() for each instance. Three orders, three separate lists.

Exactly. default_factory is a function that produces a fresh default. You can use any callable:

from dataclasses import dataclass, field
from datetime import datetime

@dataclass
class Order:
    order_id: str
    items: list = field(default_factory=list)
    tags: set = field(default_factory=set)
    metadata: dict = field(default_factory=dict)
    created_at: datetime = field(default_factory=datetime.now)

Each field gets a fresh object. The list is new, the set is new, the dict is new, the timestamp is fresh.

Completely. Now move to immutability. An order is placed, payment is collected. It should never change. If you need to modify an order, you create a new one. This is where frozen=True comes in:

from dataclasses import dataclass, field

@dataclass(frozen=True)
class OrderSnapshot:
    order_id: str
    amount: float
    timestamp: str = field(default_factory=lambda: str(datetime.now()))

Frozen dataclasses generate setattr and delattr methods that raise FrozenInstanceError if you try to modify:

snapshot = OrderSnapshot('ORD-001', 99.99)
snapshot.amount = 50.0  # raises FrozenInstanceError: cannot assign to field 'amount'

Exactly. And frozen dataclasses have a bonus: they are hashable by default. You can use them as dict keys or in sets, which you cannot do with mutable dataclasses:

frozen_order = OrderSnapshot('ORD-001', 99.99)
order_set = {frozen_order}  # Works

# Mutable dataclass
@dataclass
class PendingOrder:
    order_id: str
    items: list = field(default_factory=list)

pending = PendingOrder('ORD-002', [])
order_set = {pending}  # TypeError: unhashable type

That is post_init. It runs after the init method, after all fields are assigned. Use it for validation:

from dataclasses import dataclass, field
from datetime import datetime

@dataclass(frozen=True)
class OrderSnapshot:
    order_id: str
    amount: float
    timestamp: str = field(default_factory=lambda: str(datetime.now()))
    
    def __post_init__(self):
        if self.amount <= 0:
            raise ValueError(f'Order amount must be positive, got {self.amount}')
        if not self.order_id.startswith('ORD-'):
            raise ValueError(f'Order ID must start with ORD-, got {self.order_id}')

Now creating an OrderSnapshot with invalid data fails immediately:

OrderSnapshot('INVALID', 99.99)  # raises ValueError: Order ID must start with ORD-
OrderSnapshot('ORD-001', -10.0)   # raises ValueError: Order amount must be positive

Great question. post_init runs before the dataclass is frozen. The fields are set, post_init runs, validation happens, and then the dataclass locks itself. You cannot modify fields from outside post_init because the dataclass is frozen. Inside post_init, you can — if needed — use object.setattr() to bypass the freeze, but validation is cleaner:

@dataclass(frozen=True)
class OrderSnapshot:
    order_id: str
    amount: float
    
    def __post_init__(self):
        # Validate, not modify
        if self.amount <= 0:
            raise ValueError(f'Order amount must be positive')

You validate. If validation fails, you raise. If validation passes, the instance is complete and frozen.

You remember. slots tells Python to allocate a fixed set of fields instead of a dict. By default, every instance has a dict that stores all the field names and values. With slots, Python preallocates memory for just those fields, no dict. For a class with 10 fields, you save roughly 240 bytes per instance — the dict overhead.

Dataclasses (Python 3.10+) support slots=True:

from dataclasses import dataclass, field

@dataclass(frozen=True, slots=True)
class OrderSnapshot:
    order_id: str
    amount: float

Now OrderSnapshot instances are smaller in memory and faster to access fields because there is no dict lookup.

They are. And they let you build dataclasses that are:

1. Immutable: frozen=True prevents modification
2. Safe defaults: field(default_factory) prevents the mutable default bug
3. Validated: post_init enforces invariants
4. Efficient: slots=True reduces memory

You also get repr=False and compare=False on individual fields if you want to exclude them from the string representation or equality checks:

from dataclasses import dataclass, field

@dataclass
class User:
    name: str
    email: str
    password_hash: str = field(repr=False)  # Not shown in str(user)
    internal_id: int = field(compare=False)  # Not used in == and !=