Forge Learn/Errors & Robustness

Browsing as a guest. Sign in to save your progress and earn XP as you complete chapters.

Exceptions: try / except / finally / raise

6 min read

You'll learn to

-Use try/except to catch and handle a runtime error instead of crashing
-Catch specific exception types rather than everything indiscriminately
-Raise your own exceptions with `raise` to signal a failure to the caller

So far, any runtime error, dividing by zero, looking up a missing dictionary key, indexing past the end of a list, has crashed the whole program. Exceptions are Python's mechanism for handling those errors gracefully: catching them, recovering, or deliberately raising your own when something your code considers invalid happens.

try / except

Code that might fail goes inside a try block. If an exception occurs, Python immediately jumps to the matching except block instead of crashing the program.

Basic try/except

def safe_divide(a, b):
    try:
        return a / b
    except ZeroDivisionError:
        print("Cannot divide by zero")
        return None

print(safe_divide(10, 2))  # 5.0
print(safe_divide(10, 0))  # Cannot divide by zero \n None

Catching Specific Exception Types

You can and should catch the specific exception type you expect, rather than a bare except: that swallows everything, including bugs you would actually want to know about, like a TypeError from a typo.

Catching a specific exception: KeyError

def get_score(scores, name):
    try:
        return scores[name]
    except KeyError:
        return 0  # a missing player just has no score yet

scores = {"Ada": 95, "Grace": 88}
print(get_score(scores, "Ada"))    # 95
print(get_score(scores, "Alan"))  # 0 - no crash

A bare except: (or except Exception:) catches everything, including errors you did not anticipate and did not actually intend to hide, like a typo'd variable name raising a NameError. Always catch the narrowest, most specific exception type that matches the failure you are actually handling.

else and finally

A try statement can have two more optional clauses: else, which runs only if no exception occurred, and finally, which always runs, whether an exception happened or not, useful for cleanup that must happen no matter what.

try / except / else / finally

def parse_number(text):
    try:
        value = int(text)
    except ValueError:
        print(f"'{text}' is not a valid number")
        return None
    else:
        print(f"Parsed successfully: {value}")
        return value
    finally:
        print("Done attempting to parse")

parse_number("42")
# Parsed successfully: 42
# Done attempting to parse

parse_number("oops")
# 'oops' is not a valid number
# Done attempting to parse

Raising Your Own Exceptions

The raise statement lets your own code signal that something has gone wrong, using either a built-in exception type or a custom one (covered in the next chapter). Always include a clear message. A future reader (often you, weeks later) will thank you.

Raising a built-in exception with a message

def withdraw(balance, amount):
    if amount > balance:
        raise ValueError(f"Cannot withdraw {amount}: balance is only {balance}")
    return balance - amount

try:
    withdraw(100, 150)
except ValueError as e:
    print(f"Transaction failed: {e}")
# Transaction failed: Cannot withdraw 150: balance is only 100

-try/except attempts risky code, handling specific failures without crashing.
-else runs only when the try block succeeded with no exception.
-finally always runs: success, failure, or even a return inside the try block.
-raise SomeException("message") signals your own failure condition, with a message explaining what went wrong.

Interview Signal is part of Pro

See a real weak answer next to a real strong one for this exact topic.

Quiz is part of Pro

Test what you just read with a short quiz, and bank the XP.

Dunder Methods & Operator Overloading Custom Exceptions & Defensive Coding Patterns

Discussion0

Join the Discussion

No comments yet. Be the first to start the thread!