Dataclasses and type hints

@dataclass reads the annotated names in a class body and writes the dunder methods from the previous lesson for you: __init__ (parameters in field order), __repr__, and __eq__ (comparing all fields, in order, as a tuple).

from dataclasses import dataclass, field

@dataclass
class Order:
    id: int
    customer: str
    items: list[str] = field(default_factory=list)

Two rules follow from "the defaults go into __init__". Fields with a default must come after fields without one. And a mutable default such as [] would be shared by every instance — the mutable-default trap from lesson 1 — so @dataclass refuses it outright at class creation; field(default_factory=list) builds a fresh list per instance.

1from dataclasses import dataclass, field2 3 4@dataclass5class Order:6    id: int7    customer: str8    items: list[str] = field(default_factory=list)9 10 11def run():12    a = Order(1, "Nino")13    b = Order(1, "Nino")14    a.items.append("tea")15    try:16        @dataclass17        class Broken:18            items: list = []19        refused = "accepted"20    except ValueError as e:21        refused = f"ValueError: {e}"22    try:23        hash(a)24        hashing = "hashable"25    except TypeError as e:26        hashing = f"TypeError: {e}"27    return {28        "repr": repr(a),29        "equal_before_items": Order(2, "Ana") == Order(2, "Ana"),30        "a_equals_b": a == b,31        "b_items": b.items,32        "shared_default": refused,33        "hash": hashing,34    }

The switches that matter

• eq=True is the default, and, exactly as with a hand-written __eq__, it leaves the class unhashable unless it is frozen.
• frozen=True makes assignment to a field raise FrozenInstanceError and generates a __hash__ from the compared fields, so instances can be set members and dict keys.
• order=True adds <, <=, >, >=, comparing fields as a tuple in declaration order — the order you write the fields in is the sort order.
• field(compare=False) leaves a field out of equality, hashing and ordering: useful for a label, a cache or a timestamp that should not decide identity.
• __post_init__ runs after the generated __init__, the place for validation or derived fields; a derived field declared with field(init=False) is not an __init__ parameter and is set there.

1from dataclasses import dataclass, field, FrozenInstanceError2 3 4@dataclass(frozen=True, order=True)5class Release:6    major: int7    minor: int8    note: str = field(default="", compare=False)9 10 11def run():12    r = Release(1, 4, "first")13    try:14        r.minor = 515        assigned = "allowed"16    except FrozenInstanceError as e:17        assigned = f"FrozenInstanceError: {e}"18    downloads = {r: 120}19    downloads[Release(1, 4, "again")] += 30  # the same key: note does not count20    return {21        "assign": assigned,22        "equal_despite_note": Release(1, 4, "first") == Release(1, 4, "again"),23        "downloads": [[f"{k.major}.{k.minor}", n] for k, n in downloads.items()],24        "ten_after_four": Release(1, 10) > Release(1, 4),25        "newest": repr(max([Release(1, 10), Release(2, 0), r])),26    }

Type hints are not checks

The list[str] above is a type hint. Python stores hints (in __annotations__, readable with typing.get_type_hints) and otherwise ignores them: nothing stops Order("seven", None) at runtime. Hints are checked before the program runs, by a static checker such as mypy or pyright, and by your editor.

The vocabulary interviews expect: int | None (what Optional[int] means), list[int] and dict[str, float] for containers, and generics, which Python 3.12 can write inline:

def first[T](items: list[T]) -> T:
    return items[0]

A Protocol describes a type by the methods it has, not by what it inherits from — structural typing, the static version of duck typing. Marked @runtime_checkable, it also works with isinstance, but that check only confirms the method names exist, never their signatures.

1from dataclasses import dataclass2from typing import Protocol, runtime_checkable, get_type_hints3 4 5@dataclass6class Point:7    x: int8    y: int9 10 11@runtime_checkable12class Closer(Protocol):13    def close(self) -> None: ...14 15 16class File:17    def close(self) -> None:18        pass19 20 21class Door:22    def close(self, force, slam, loudly):  # same name, wrong shape23        pass24 25 26def first[T](items: list[T]) -> T:27    return items[0]28 29 30def run():31    p = Point("seven", None)32    return {33        "point": repr(p),34        "hints": {k: v.__name__ for k, v in get_type_hints(Point).items()},35        "file_is_closer": isinstance(File(), Closer),36        "door_is_closer": isinstance(Door(), Closer),37        "int_is_closer": isinstance(42, Closer),38        "first": first(["a", "b"]),39    }

Common mistakes

• Expecting a type hint to reject bad input. It does not; validate in __post_init__ or at the boundary where data enters.
• Writing items: list = [] in a dataclass. It fails at class creation with a ValueError pointing you to default_factory.
• Adding order=True without thinking about field order. The first declared field decides the sort, the next breaks ties, and so on.
• Trusting isinstance(x, SomeProtocol) to prove x is usable. It only checked that attributes with those names exist.

What interviewers ask

• What does @dataclass generate, and when would you not use one? __init__, __repr__, __eq__ (plus ordering and hashing on request); a class with real behaviour and invariants may want a hand-written constructor instead.
• Why is a regular dataclass unhashable, and how do you make it hashable? Equality is by value and the fields can change; frozen=True makes it immutable and generates __hash__.
• Are type hints enforced? No; they are metadata for static checkers and tools, and a runtime check is something you write (or a library such as pydantic does for you).