Exception Handling

Why read this? Errors happen. A user enters text where a number is expected. A file doesn't exist. A network connection drops. Without proper handling, any of these errors crashes your program. Exception handling gives you the power to anticipate problems and respond gracefully — showing helpful messages, retrying operations, or safely shutting down.

🎯 Learning Objectives

1. Use try/except blocks to catch and handle exceptions
2. Handle specific exception types (ValueError, FileNotFoundError, etc.)
3. Use else and finally clauses for cleanup
4. Raise exceptions with raise for input validation
5. Create custom exception classes

📋 Prerequisites

• File Operations — File errors are common exceptions.
• Basic understanding of control flow.

📖 Core Content

27.1 What Problem Do Exceptions Solve?

27.2 Basic try/except

python
Run Inline
# runnable
try:
    num = int(input("Enter a number: "))
    print(f"100 / {num} = {100 / num}")
except ValueError:
    print("That's not a valid number!")
except ZeroDivisionError:
    print("Can't divide by zero!")
print("Program continues safely...")

1. Python executes the code in the try block.
2. If no error occurs, except blocks are skipped.
3. If a ValueError occurs (e.g., user types "abc"), the first matching except runs.
4. If a ZeroDivisionError occurs, that handler runs.
5. Any other exception type would crash the program (not caught).

27.3 Catching Multiple Exceptions

python
Run Inline
# runnable
try:
    numbers = [1, 2, 3]
    index = int(input("Index (0-2): "))
    print(f"Value: {numbers[index]}")
    result = 100 / index
    print(f"100/{index} = {result}")
except (ValueError, IndexError, ZeroDivisionError) as e:
    print(f"Error occurred: {type(e).__name__}: {e}")

27.4 try/except/else/finally

python
Run Inline
# runnable
def read_file_safe(filename):
    """Read a file safely with full exception handling."""
    try:
        f = open(filename, "r")
        content = f.read()
    except FileNotFoundError:
        print(f"Error: '{filename}' not found.")
        return None
    except PermissionError:
        print(f"Error: No permission to read '{filename}'.")
        return None
    else:
        # Runs ONLY if no exception occurred
        print(f"Successfully read {len(content)} characters.")
        return content
    finally:
        # ALWAYS runs — cleanup code
        print(f"Finished processing '{filename}'.")
        if 'f' in locals() and not f.closed:
            f.close()
# Test
result = read_file_safe("example.txt")
print(f"Result: {result}")

27.5 Raising Exceptions

python
Run Inline
# runnable
def get_positive_int(prompt):
    """Get a positive integer from user. Raises ValueError if invalid."""
    value = int(input(prompt))
    if value <= 0:
        raise ValueError(f"{value} is not positive!")
    return value
try:
    age = get_positive_int("Enter your age: ")
    print(f"You are {age} years old.")
except ValueError as e:
    print(f"Invalid input: {e}")

27.6 Custom Exception Classes

python
Run Inline
# runnable
class InsufficientFundsError(Exception):
    """Raised when account balance is too low."""
    pass
class NegativeAmountError(Exception):
    """Raised when deposit/withdrawal amount is negative."""
    pass
class BankAccount:
    def __init__(self, balance=0):
        self.balance = balance
    def withdraw(self, amount):
        if amount < 0:
            raise NegativeAmountError("Withdrawal amount can't be negative!")
        if amount > self.balance:
            raise InsufficientFundsError(f"Need ₹{amount}, have ₹{self.balance}")
        self.balance -= amount
        print(f"Withdrew ₹{amount}. Balance: ₹{self.balance}")
acc = BankAccount(1000)
try:
    acc.withdraw(1500)
except InsufficientFundsError as e:
    print(f"Transaction failed: {e}")
except NegativeAmountError as e:
    print(f"Invalid amount: {e}")

27.7 Common Exception Types

⚠️ Common Pitfalls

Pitfall 1: Bare except: Catches Everything

Pitfall 2: Swallowing Errors Silently

Pitfall 3: Not Cleaning Up Resources

Pitfall 4: Raising Exception Without Message

📝 Practice Questions

Q1: What's the output if user enters "five"?

python
Run Inline
try:
    x = int(input("Number: "))
    print(10 / x)
except ValueError:
    print("Bad number")
except ZeroDivisionError:
    print("Zero division")

Answer: Bad number — the ValueError from int("five") is caught. Q2: When does the finally block execute?

Answer: ALWAYS — whether an exception occurred or not. It's for cleanup code that must run. Q3: What's wrong with except: (bare except)?

Answer: It catches ALL exceptions including SystemExit, KeyboardInterrupt, and GeneratorExit. This can make the program impossible to terminate. Always specify the exception type. Q4: Write a function safe_divide(a, b) that handles ZeroDivisionError and TypeError.

Answer:

python
Run Inline
def safe_divide(a, b):
    try:
        return a / b
    except ZeroDivisionError:
        return None
    except TypeError:
        return None

Q5: What does the else clause in a try/except block do?

Answer: The else block runs ONLY if the try block did NOT raise an exception. It's useful for code that should run only on success. Q6-10: Additional exception handling questions follow the same format.

(Following the established pattern with detailed answers.)

🔗 Cross-References

• Next Topic: Modules & Packages
• Previous Topic: Advanced File Operations
• Reference: Python for Everybody, Chapter 3 (Section 3.7 — "Catching exceptions using try and except")
• Video: L82: Exception handling, L66: Introduction to advanced concepts & exception handling Join Discord Previous26. Advanced File OperationsNext28. Modules & Packages