Exception Handling¶

Exception handling is a form of control flow that separates normal logic from error recovery. This separation allows programs to remain clean while still handling errors correctly.

Python allows programs to catch and handle exceptions using try and except.

flowchart TD
    A[try block]
    A --> B{exception occurs?}
    B -->|yes| C[except block]
    B -->|no| D[continue normally]
````

!!! tip "Mental Model"
    `try/except` is a safety net. The `try` block says "attempt this," and the `except` block says "if it fails, do this instead." This separates the happy path from error recovery, keeping your main logic clean while still handling things that can go wrong.

---

## 1. Basic try / except

```python
try:
    x = int("hello")
except ValueError:
    print("Conversion failed")

Output:

text Conversion failed

The program continues running instead of stopping.

2. Handling Multiple Exceptions¶

python try: x = int(input("Number: ")) print(10 / x) except ValueError: print("Invalid number") except ZeroDivisionError: print("Cannot divide by zero")

Each exception type can be handled separately.

3. Catching Multiple Types Together¶

python except (ValueError, TypeError): print("Invalid input")

This handles multiple error types with a single handler.

4. The finally Clause¶

The finally block runs regardless of whether an exception occurred.

python try: f = open("data.txt") finally: print("Done")

This is often used for cleanup tasks.

flowchart TD
    A[try]
    A --> B{exception?}
    B -->|yes| C[except]
    B -->|no| D[skip except]
    C --> E[finally]
    D --> E

5. else Clause¶

else runs only when no exception occurs.

python try: x = int("10") except ValueError: print("Bad input") else: print("Success")

6. Worked Example¶

python try: value = int(input("Enter number: ")) result = 10 / value print(result) except ValueError: print("Please enter a valid number") except ZeroDivisionError: print("Division by zero") finally: print("Program finished")

7. Design Principles¶

• Catch only exceptions you expect --- avoid hiding bugs
• Keep try blocks small --- isolate failure points
• Prefer specific exceptions --- communicate intent clearly
• Avoid bare except: --- it catches unintended signals like KeyboardInterrupt

8. Summary¶

Key ideas:

• try protects code that might fail
• except handles specific exceptions
• finally always executes
• else runs when no error occurs

Exception handling allows programs to recover gracefully from unexpected situations. This reflects Python's EAFP philosophy: write code for the common (successful) case, and handle exceptions for uncommon (failure) cases. EAFP keeps the success path clean while isolating failure handling separately.

Exceptions are raised either by Python or explicitly using raise, covered next.

Exercises¶

Exercise 1. Explain the difference between the else and finally clauses in a try statement. When does each execute? Consider this code:

python try: result = int("42") except ValueError: print("error") else: print("success") finally: print("cleanup")

What is the output? What would change if the string were "abc" instead of "42"?

Exercise 2. A common anti-pattern is using a bare except: clause:

python try: do_something() except: pass

Explain why this is dangerous. What kinds of exceptions does bare except: catch that you probably do NOT want to catch? What should you write instead?

Exercise 3. Why does Python use exceptions for "expected" situations (like a missing dictionary key raising KeyError) rather than returning error codes? Compare Python's EAFP ("Easier to Ask Forgiveness than Permission") style with the LBYL ("Look Before You Leap") style. Which approach does this code follow, and why?

python try: value = my_dict[key] except KeyError: value = default