Errors & Debugging like a Pro

Python stops when it reaches a problem it can't safely continue from. The error type and message tell you what kind of assumption was wrong; the traceback tells you where it happened and how execution got there.

A traceback is a path of function calls. Start at the bottom to find the exception and failing line, then move upward to see who called it. Pick an error to inspect the stack frames.

Real story: a customer adds a mango to their cart, but the shop's price list has no mango. Remember the call stack from Chapter 5? When an error happens, Python throws away the top box and hands the error to the box below — again and again — until some function catches it with try/except. If nobody does, the program crashes.

Use try around the small operation that may fail. Catch the error you can recover from, and show a useful next step. Don't use exceptions to hide bugs you don't understand.

try:
    result = risky_step()
except ValueError as error:
    recover(error)
else:
    celebrate(result)
finally:
    close_file()

Python exceptions form a family tree. A broad parent like Exception can catch many different problems. If it comes first, narrower handlers below it never get a chance.

try:
    do_work()
except Exception:
    log("something failed")
except FileNotFoundError:
    recover_specific_case()

Closing a file manually is easy to forget, especially when an exception interrupts the function. A context manager takes responsibility for cleanup when its block exits.

with open("notes.txt") as file:
    text = file.read()
# file closes here — even if read() fails

When your application has a meaningful failure case, define a custom exception. Callers can then handle it explicitly while unexpected errors remain visible.

class InvalidQuantityError(Exception):
    pass

if quantity < 1:
    raise InvalidQuantityError("quantity must be at least 1")

1. Reproduce: make the bug happen with the smallest input you can.
2. Read the exact error: don't skip the type or message.
3. Inspect the failing line: check the types and values it actually received.
4. Change one thing: then rerun the same reproduction case.
5. Keep a test: make sure the bug doesn't quietly return.

Five short questions on tracebacks, exception handling, and cleanup. Get all five right to complete Chapter 7.

def safe_divide(total, count):
    try:
        return total / count
    except ZeroDivisionError:
        return 0

print(safe_divide(12, 3))
print(safe_divide(12, 0))

1def safe_divide(total, count):
2    try:
3        return total / count
4    except ZeroDivisionError:
5        return 0
6 
7print(safe_divide(12, 3))
8print(safe_divide(12, 0))

Run the code to see its output.

Try the checkout example in the Python Playground (code preloaded).

• Read the traceback's final frame to locate the failing line, then trace calls upward.
• Catch specific errors you can recover from; put a broad fallback last.
• Use else for the no-error path and finally for cleanup.
• Use with to manage files and other resources safely.
• Raise custom exception types for meaningful application-level failures.