Type Hints Checkpoint

25 min · Intermediate

Fix the mistakes

The slips that cost marks in this module. Spot each one, then check the fix.

A real module uses every tool from this module: containers, None, a protocol, and a checker. This checkpoint builds one small design and then tests your choices.

Give every part the type it needs

A small order system has three parts: a lookup that can fail, a rule that changes an amount, and a function that joins them. Ask of each one what goes in, what comes out, and whether it can be missing.

Example 1 · One typed design

Python

1from typing import Protocol2
3
4class Discount(Protocol):5    def apply(self, amount: float) -> float: ...6
7
8class Percent:9    def __init__(self, rate: float) -> None:10        self.rate = rate11
12    def apply(self, amount: float) -> float:13        return amount - amount * self.rate / 10014
15
16def find_order(orders: dict[int, float], order_id: int) -> float | None:17    return orders.get(order_id)18
19
20def final_amount(orders: dict[int, float], order_id: int, discount: Discount) -> float | None:21    amount = find_order(orders, order_id)22    if amount is None:23        return None24    return discount.apply(amount)25
26
27orders = {101: 2000.0, 102: 450.0}28print(final_amount(orders, 101, Percent(10)))29print(final_amount(orders, 999, Percent(10)))

Output

1800.0
None

What this code does

Percent never names Discount, but it has apply, so it fits the protocol.
A missing order gives None, which final_amount passes on to the caller.

The lookup returns float | None, because the order may not exist. The rule only needs an apply method, so it is a protocol, and any discount class fits. The function that joins them returns float | None as well, because the missing case passes through.

Let the checker guard None

Once a function returns float | None, every caller must deal with the None. mypy points at each caller that forgets. That is the main gain from the hints.

Example 2 · mypy finds the unhandled None

Runs in: Your terminal

Terminal

mypy orders.py

Output

orders.py:28: error: Unsupported operand types for + ("None" and "int")  [operator]
orders.py:28: note: Left operand is of type "float | None"
Found 1 error in 1 file (checked 1 source file)

What this code does

The file adds 5 to a result that might be None.
The program would crash for a missing order. mypy reports it before that happens.

The fix is a test, such as if amount is not None. Do not silence the message with # type: ignore. That hides the exact case the hint was added to catch.

Questions to ask when hinting

Before you add a hint, ask these. Can this value be missing? Then use | None. Does the function accept anything with a certain method? Then use a protocol. Does the output type follow the input type? Then use a type variable.

Example 3 · After the None check

Python

1from typing import Protocol2
3
4class Discount(Protocol):5    def apply(self, amount: float) -> float: ...6
7
8class Percent:9    def __init__(self, rate: float) -> None:10        self.rate = rate11
12    def apply(self, amount: float) -> float:13        return amount - amount * self.rate / 10014
15
16def find_order(orders: dict[int, float], order_id: int) -> float | None:17    return orders.get(order_id)18
19
20def final_amount(orders: dict[int, float], order_id: int, discount: Discount) -> float | None:21    amount = find_order(orders, order_id)22    if amount is None:23        return None24    return discount.apply(amount)25
26
27orders = {101: 2000.0, 102: 450.0}28result = final_amount(orders, 101, Percent(10))29total = (result if result is not None else 0.0) + 530print(total)

Output

1805.0

What this code does

The conditional expression handles None before adding.
mypy accepts this version and Python prints the same result.

Run mypy after each change. A clean run means the types agree, not that the logic is right, so keep your tests.

Finish up

Mark complete & continue

Next: Packages and __init__.py

1from typing import Protocol2 3 4class Discount(Protocol):5 def apply(self, amount: float) -> float: ...6 7 8class Percent:9 def __init__(self, rate: float) -> None:10 self.rate = rate11 12 def apply(self, amount: float) -> float:13 return amount - amount * self.rate / 10014 15 16def find_order(orders: dict[int, float], order_id: int) -> float | None:17 return orders.get(order_id)18 19 20def final_amount(orders: dict[int, float], order_id: int, discount: Discount) -> float | None:21 amount = find_order(orders, order_id)22 if amount is None:23 return None24 return discount.apply(amount)25 26 27orders = {101: 2000.0, 102: 450.0}28print(final_amount(orders, 101, Percent(10)))29print(final_amount(orders, 999, Percent(10)))

1from typing import Protocol2 3 4class Discount(Protocol):5 def apply(self, amount: float) -> float: ...6 7 8class Percent:9 def __init__(self, rate: float) -> None:10 self.rate = rate11 12 def apply(self, amount: float) -> float:13 return amount - amount * self.rate / 10014 15 16def find_order(orders: dict[int, float], order_id: int) -> float | None:17 return orders.get(order_id)18 19 20def final_amount(orders: dict[int, float], order_id: int, discount: Discount) -> float | None:21 amount = find_order(orders, order_id)22 if amount is None:23 return None24 return discount.apply(amount)25 26 27orders = {101: 2000.0, 102: 450.0}28result = final_amount(orders, 101, Percent(10))29total = (result if result is not None else 0.0) + 530print(total)