Python Dataclasses

Writing a class that just holds a handful of related values used to mean typing out __init__ with a repetitive self.field = field line per attribute, then usually adding __repr__ for debuggability and __eq__ if you ever needed to compare two instances by value — three methods of boilerplate for what is conceptually just a named tuple of fields.

@dataclass, decorating a class whose body is just type-annotated attributes, generates all three by default: __init__ accepting each field as a parameter (in declaration order, with correct defaults), __repr__ producing a readable ClassName(field=value, ...) string, and __eq__ comparing all fields for equality between two instances of the same class. You opt out of any of them individually via decorator arguments (@dataclass(eq=False), for example) if you need custom behavior.

Critically, @dataclass reads the class's type annotations to know which attributes are fields — this is the same annotation syntax from the Type Hints lesson, now doing double duty as both documentation/static-checking metadata and the literal specification dataclasses uses to generate code. A class attribute without a type annotation is *not* treated as a dataclass field at all.

Python's def f(items=[]): mutable-default-argument pitfall — where the same list object is reused across every call that doesn't supply its own — has a direct analog in dataclasses, and @dataclass actively refuses to let you write items: list = [] as a field default, raising a ValueError at class-definition time rather than letting the bug slip through silently.

The fix is field(default_factory=list), imported from dataclasses alongside the decorator: instead of a single shared default value, you supply a zero-argument callable that's invoked fresh for every new instance. default_factory=list calls list() each time a ShoppingCart is constructed, guaranteeing every cart starts with its own independent empty list rather than all carts secretly sharing one.

field() also accepts default (for immutable defaults, equivalent to the plain = value syntax), repr=False and compare=False to exclude a specific field from the generated __repr__ or __eq__ (useful for internal caches or large binary blobs you don't want dumped in logs), and init=False for computed fields that shouldn't be constructor parameters at all.

@dataclass(frozen=True) makes every field read-only after __init__ runs — any attempt to reassign a field raises dataclasses.FrozenInstanceError — and as a side effect, also makes the instance hashable (assuming all fields are themselves hashable), so frozen dataclass instances can be used as dictionary keys or set members, something ordinary mutable dataclasses cannot do safely.

This maps directly onto a very common professional need: value objects. A Coordinate, a Money amount, an immutable Config snapshot — anything that represents a value rather than an entity with a lifecycle benefits from being frozen, since it prevents an entire class of bugs where some distant piece of code mutates a shared object that other code didn't expect to change.

Dataclasses also automatically populate __match_args__ from field declaration order, which is exactly what makes case Point(x, y): — positional class patterns from the previous lesson — work out of the box. Combined with frozen=True and Success | Failure-style discriminated unions, dataclasses are the standard-library foundation that Python's modern typing and pattern-matching features are built to work with directly.

How many times have you written self.x = x, self.y = y, self.z = z in an __init__ just to hold three values? @dataclass ends that.

A plain class needs __init__ written by hand. @dataclass generates it from your annotated attributes instead.

You get a readable __repr__ and value-based __eq__ for free — no more comparing objects by identity when you meant by value.

Checkpoint: By default, does @dataclass generate __eq__ that compares by identity or by field values?

• →By field values (two instances with equal fields are ==)
• →By identity (same as the default object.__eq__)

field() gives you control over defaults for mutable types, since 'x: list = []' is a trap that shares one list across all instances.

Checkpoint: Why does items: list[str] = [] need field(default_factory=list) instead?

• →A plain mutable default is shared across every instance of the class
• →It is only a type-hinting syntax preference with no runtime effect

frozen=True makes instances immutable and hashable — perfect for values you never want mutated after creation, like config or coordinates used as dict keys.

Dataclasses are the natural home for constants and closed sets of values too — next, we cover Enums for exactly that.

Enforce Real Immutability. Finish check: frozen=True raises on attribute reassignment.