Raising Exceptions¶

Raising exceptions defines the contract of a function. It specifies what inputs are valid, what conditions are unacceptable, and how violations are communicated to the caller. Instead of returning error codes, functions raise exceptions to signal failure clearly.

Python programs can raise exceptions explicitly using the raise statement.

flowchart LR
    A[Function detects problem]
    A --> B[raise exception]
    B --> C[Caller handles exception]
````

!!! tip "Mental Model"
    `raise` is how a function says "I cannot do what you asked." Instead of returning a special error value that callers might ignore, raising an exception forces the issue---execution stops immediately and unwinds the call stack until something handles it. This makes failures impossible to silently overlook.

---

## 1. Basic raise

```python
raise ValueError("Invalid value")

This immediately stops execution and raises the specified exception.

2. Raising Exceptions in Functions¶

python def divide(a, b): if b == 0: raise ValueError("b cannot be zero") return a / b

Example:

python print(divide(10, 2)) print(divide(10, 0))

3. Custom Error Checking¶

Raising exceptions helps enforce constraints.

python def withdraw(balance, amount): if amount > balance: raise ValueError("Insufficient funds") return balance - amount

4. Re-raising Exceptions¶

Sometimes a function catches an exception but wants to propagate it upward.

python try: x = int("abc") except ValueError: print("Conversion error") raise

This re-raises the same exception.

5. Custom Exception Classes¶

Programs may define their own exception types.

python class NegativeNumberError(Exception): pass

Example:

python def sqrt(x): if x < 0: raise NegativeNumberError("Negative value")

Custom exceptions help express domain-specific errors.

6. Worked Examples¶

Example 1¶

python def check_age(age): if age < 0: raise ValueError("Age cannot be negative")

Example 2¶

python def temperature(c): if c < -273.15: raise ValueError("Below absolute zero")

7. When to Raise Exceptions¶

Raising exceptions is appropriate when:

• inputs violate assumptions
• an operation cannot be completed
• continuing would produce incorrect results

Do not raise exceptions for normal control flow---use if/else or return instead.

8. Summary¶

Key ideas:

• raise explicitly signals errors
• functions can validate inputs and raise exceptions
• exceptions propagate up the call stack
• custom exception classes can represent domain-specific problems

Raising exceptions allows programs to enforce correctness and communicate errors clearly.

Putting It Together¶

Exceptions provide a complete system for handling failure:

• exception types describe what went wrong
• try/except defines how to respond
• raise communicates failure to callers

Together, control flow and exceptions describe all possible execution paths in a program: what happens when operations succeed, and what happens when they fail.

Exercises¶

Exercise 1. A programmer raises ValueError for invalid input but is unsure when to use TypeError instead. For each scenario, state which exception is more appropriate and why:

python def set_age(age): # age is "hello" -- should this raise TypeError or ValueError? # age is -5 -- should this raise TypeError or ValueError? # age is [25] -- should this raise TypeError or ValueError? pass

Exercise 2. The bare raise re-raises the current exception. Predict the output:

```python def process(): try: return int("hello") except ValueError: print("Logging error...") raise

try: process() except ValueError as e: print(f"Caught: {e}") ```

Why is raise (without arguments) preferable to raise ValueError(...) in the except block? What information would be lost if you raised a new exception instead?

Exercise 3. Custom exceptions help organize error handling. Explain why this pattern is useful:

```python class AppError(Exception): pass

class DatabaseError(AppError): pass

class AuthError(AppError): pass ```

How does this hierarchy let a caller handle all application errors with one except clause while still being able to handle specific errors differently? What advantage does this have over raising built-in exceptions like RuntimeError?