Dataclasses & Type Hints

@dataclass generates __init__, __repr__ and __eq__ from a list of annotated fields — the three you wrote by hand in the last module, exactly as you wrote them.

from dataclasses import dataclass

@dataclass
class Order:
    name: str
    quantity: int

The annotation is what makes a field a field. A line without one is a plain class attribute and will not appear in the generated __init__ at all.

Your task: replace the hand-written class with a dataclass holding the same three fields. The output must not change:

Order(name='tea', quantity=3, price=1250)
True
False

A field can have a default, and the same ordering rule applies as for function parameters: everything with a default comes after everything without one.

@dataclass
class Order:
    name: str
    quantity: int = 1
    express: bool = False

Your task: the fields below are in an order Python rejects. Reorder them so the class defines, keeping every default, then print three orders:

Order(name='tea', quantity=3, price=1250, express=True)
Order(name='cup', quantity=1, price=0, express=False)
Order(name='mat', quantity=5, price=300, express=False)

This is the only place in the language that stops you making the mutable default mistake. Run it and read the error — it names the fix.

ValueError: mutable default <class 'list'> for field tags
           is not allowed: use default_factory

field(default_factory=list) takes the function that makes the default — list, with no brackets — and calls it once per instance. The same shape as defaultdict(list), and the fix for the shared class attribute from the last module.

Your task: fix the field so each item gets its own list:

['hot']
[]
Item(name='tea', tags=['hot'])

frozen=True makes instances immutable: assigning to a field raises FrozenInstanceError. And because the object can no longer change, it becomes hashable — so it can be a dictionary key or a set member, which an ordinary dataclass cannot.

This is the tuple argument from module 2-06 with names on the fields. Use it for anything that represents a value rather than a thing with a life of its own.

Your task: make Point frozen, so the assignment is refused and the set works:

Point(x=1, y=2)
cannot assign to field 'x'
2
True

order=True generates the comparison methods, comparing fields in declaration order. So the field you want to sort by goes first, and the rest break ties.

Instances then sort with no key argument at all, and min and max work on them too.

Your task: make Result ordered and put the score first, so the results sort lowest score first:

[Result(score=54, name='grace'), Result(score=71, name='ada'), Result(score=88, name='kenji')]
Result(score=88, name='kenji')
Result(score=54, name='grace')

__post_init__ runs immediately after the generated __init__, with every field already assigned. That is where validation goes in a dataclass.

def __post_init__(self):
    if self.quantity < 0:
        raise ValueError(f"quantity must not be negative: {self.quantity}")

Your task: add validation refusing a negative quantity and a price of zero or less, with the offending value in each message:

Order(name='tea', quantity=3, price=1250)
quantity must not be negative: -2
price must be positive: 0

Python records annotations and does nothing else with them. Nothing is checked at runtime, ever.

def line_total(quantity: int, price: int) -> int:
    return quantity * price

line_total("3", 4)   # "3333" — no error at all

Hints exist so a type checker — mypy, pyright, your editor — can find that before the code runs, and so a reader can tell what a function expects. When you need the guarantee at runtime, that is validation, and it is ordinary code.

Your task: add hints to line_total, then show both halves: the wrong-typed call that Python allows, and a checked_total that validates and refuses it.

3750
3333
quantity must be a whole number, got '3'

A bare list says almost nothing. list[str] says what is in it, which is the part a reader actually needs.

names: list[str]
counts: dict[str, int]
pair: tuple[str, int]
maybe: str | None

str | None is the one that earns its keep: it says out loud that a value can be missing, and a checker will then insist you deal with that before using it.

Your task: annotate summarise, which takes a list of names and returns a dictionary of name to length, and first_long, which returns the first name over four characters or None when there is none:

{'tea': 3, 'whisk': 5, 'cloth': 5}
whisk
None

A dataclass replaces only the predictable methods. Everything else about a class works exactly as before — methods, properties, the lot.

Your task: take the dataclass below and add a total property and an add_note method, with the notes list built per instance:

3750
12500
['checked']
[]

The last two lines are one order's notes after adding one, and a second order's, which must still be empty.