Exceptions, Testing & Mini-Project 3

▶Today's videos

Watch each video, then work the matching sections below. Watching alone will not do it.

1try, except, and the ones people forget

Four clauses. Most people use two.

def read_config(path):
    try:
        f = open(path, encoding="utf-8")
    except FileNotFoundError:
        print(f"no config at {path}, using defaults")
        return {}
    else:
        # runs only if NOTHING was raised
        return parse(f.read())
    finally:
        # runs no matter what — success, failure, or return
        print("config load attempted")

Catch narrowly

2raise, and propagation

An exception travels up until something catches it.

def parse_age(raw):
    """Age as an int. Raises ValueError if it is not sensible."""
    age = int(raw)                       # may raise ValueError itself
    if age < 0 or age > 130:
        raise ValueError(f"age out of range: {age}")
    return age

Two things about that message. It says what was wrong and shows the offending value — "age out of range: 214" is actionable; "bad input" is not. And the function raises rather than printing, so a caller can decide what to do.

Custom exceptions

class ContactBookError(Exception):
    """Anything this program raises deliberately."""


class DuplicateContact(ContactBookError):
    """A contact with that name already exists."""


# now a caller can be precise about what it handles
try:
    book.add(contact)
except DuplicateContact:
    book.update(contact)

A custom exception earns its place when a caller needs to tell your failure from a built-in one. If nobody will ever catch it specifically, raise ValueError and save yourself the class.

3pytest

The known-answer habit from Day 5, written down and run automatically.

You have been testing since Day 1 — running a program with values whose answer you already knew. A test is that, saved to a file so the computer does it for you every time.

from stats import mean_of, count_above


def test_mean_of_typical():
    assert mean_of([12, 7, 25, 3]) == 11.75


def test_mean_of_single():
    assert mean_of([5]) == 5


def test_count_above_is_strict():
    """25 is not ABOVE 25."""
    assert count_above([12, 25], 25) == 0


def test_count_above_none_match():
    assert count_above([1, 2], 100) == 0

pip install pytest
pytest -q

Reading a failure

    def test_count_above_is_strict():
        """25 is not ABOVE 25."""
>       assert count_above([12, 25], 25) == 0
E       assert 1 == 0
E        +  where 1 = count_above([12, 25], 25)

test_stats.py:13: AssertionError

pytest shows the expression, the values it computed, and the line. That last line — where 1 = count_above([12, 25], 25) — is doing the work a print statement would have done, automatically.

4Mini-Project 3 — Tested Library System

Your third graded deliverable · 100 points

Everything from Week 3 in one program: classes, encapsulation, inheritance, exceptions and a real test suite.

Required behaviour

1. A LibraryItem base class, with Book, DVD and Magazine subclasses.
2. Each subclass has a different loan period and a different late-fee rule.
3. A Library class holding items, with check_out, return_item and search.
4. Invariants enforced in one place: no negative fees, no double check-out, no unknown item.
5. Custom exceptions — ItemUnavailable, ItemNotFound — raised deliberately.
6. Data persists to a file between runs.
7. A pytest suite with at least 15 tests, covering every subclass and every raised exception.

Suggested build order

1. LibraryItem and one subclass. Two tests. Run pytest and watch them pass.
2. Add the other two subclasses. Test that the loan periods genuinely differ.
3. Library with check_out. Test the happy path, then the double-check-out failure.
4. Custom exceptions. Test each one with pytest.raises.
5. Persistence. Test a save-then-load round trip.
6. Edges: empty library, unknown item, zero-day loan, negative fee attempt.
7. black, ruff, and read it once as a stranger.

import pytest


def test_double_checkout_raises():
    library = Library()
    book = Book("Think Python", 292)
    library.add(book)
    library.check_out(book)

    with pytest.raises(ItemUnavailable):
        library.check_out(book)

pytest.raises is how you assert that something must fail. A test suite that only checks the happy path is testing half a program — and the half that was already working.

>_Python playground

A real Python interpreter running inside your browser. Nothing is installed, nothing is uploaded, nothing can break.

✓Exercise set

Checked automatically the moment you submit. Work top to bottom — each one assumes the last. Your answers are saved in this browser.