Chapter 10: Error Handling

🛡️ Understanding Errors

Errors are a normal part of programming! Instead of letting your program crash, you can handle errors gracefully and provide helpful feedback to users.

Think of error handling like a safety net - it catches problems before they break your program!

Why Error Handling Matters

Imagine you're building a calculator app. Without error handling:

User enters "abc" instead of a number → Program crashes
User tries to divide by zero → Program crashes
File doesn't exist → Program crashes

With error handling, you can catch these problems and show friendly messages instead!

Two Types of Errors

There are two main types of errors in Python:

1️⃣ Syntax Errors

What: Code that doesn't follow Python's rules

When: Detected before code runs

Examples: Missing colons, typos, wrong indentation

Fix: Correct the code

2️⃣ Exceptions

What: Errors during program execution

When: Occur while code is running

Examples: Division by zero, file not found

Fix: Use try/except blocks

Example 1: Program Without Error Handling (Bad!)

Output will appear here...

Example 2: With Error Handling (Good!)

Output will appear here...

Example 3: Real-World Scenario

Output will appear here...

🔍 What Happens When An Error Occurs?

When Python encounters an error, here's what happens step-by-step:

Error Detected: Python finds a problem (e.g., can't convert "abc" to int)
Exception Created: Python creates an exception object with error details
Looking for Handler: Python searches for try/except blocks
Two Outcomes:
- ✅ Handler found → Runs the except block, program continues
- ❌ No handler → Program crashes with traceback

Think of it like: Throwing a ball (exception) and someone catches it (except block) vs. nobody catches it (crash)!

🎯 Key Takeaway

Error handling = making your programs robust and user-friendly. Instead of crashing, your program handles problems gracefully and keeps running!

🎯 try/except Blocks - Your Safety Net

The try/except block lets you "try" code that might fail and "catch" any errors that occur.

Think of it as: Try something risky, but if it fails, except (handle) the problem!

The Basic Structure

try:
    # Code that might cause an error
    risky_operation()
except ErrorType:
    # Code to handle the error
    handle_error()

🔍 How try/except Works (Step-by-Step)

Enter try block: Python starts executing code inside try
If success: Code runs normally, skip the except block
If error occurs: Stop immediately, jump to matching except block
Handle error: Execute code in except block
Continue: Program continues after the try/except

Example 1: Simple Division

Output will appear here...

Example 2: Division by Zero

Output will appear here...

Example 3: Safe Division Function

Output will appear here...

Example 4: Converting String to Number

Output will appear here...

Example 5: Converting Invalid String

Output will appear here...

Example 6: Safe Number Converter Function

Output will appear here...

💡 Best Practices

Be specific: Catch specific exceptions (ValueError, not just Exception)
Keep try blocks small: Only include code that might fail
Provide helpful messages: Tell users what went wrong
Have a recovery plan: What should happen after catching an error?

📋 Common Error Types - Know Your Enemies!

Python has many built-in exception types. Here are the most common ones you'll encounter:

The "Big 7" Exceptions Every Beginner Should Know

ValueError

When: Right type, wrong value

Example: int("abc")

TypeError

When: Wrong type for operation

Example: "hi" + 5

ZeroDivisionError

When: Divide by zero

Example: 10 / 0

IndexError

When: Invalid list/string index

Example: list[999]

KeyError

When: Dictionary key missing

Example: dict["missing"]

FileNotFoundError

When: File doesn't exist

Example: open("nope.txt")

AttributeError

When: Attribute doesn't exist

Example: list.invalid()

Let's See Each One in Action!

Example 1: ValueError

Scenario: Converting invalid string to number

Output will appear here...

Example 2: TypeError

Scenario: Mixing incompatible types

Output will appear here...

Example 3: ZeroDivisionError

Scenario: Division by zero

Output will appear here...

Example 4: IndexError

Scenario: Accessing invalid list index

Output will appear here...

Example 5: KeyError

Scenario: Accessing missing dictionary key

Output will appear here...

Example 6: AttributeError

Scenario: Calling non-existent method

Output will appear here...

Example 7: Multiple Errors in One Program

Scenario: Handling different errors appropriately

Output will appear here...

🔍 How to Remember These Exceptions

ValueError: Value is wrong (wrong VALUE)
TypeError: Type is wrong (wrong TYPE)
ZeroDivisionError: Self-explanatory - dividing by ZERO
IndexError: Index out of bounds (bad INDEX)
KeyError: Dictionary key not found (missing KEY)
FileNotFoundError: File doesn't exist (FILE NOT FOUND)
AttributeError: Method/property doesn't exist (missing ATTRIBUTE)

🔄 Handling Multiple Exceptions

You can handle different types of errors with separate except blocks!

Think of it as: Different problems need different solutions!

Part 1: Creating the Function

First, let's create a function that can handle multiple types of errors:

Output will appear here...

Part 2: Testing Valid Input

Let's test with valid input first:

Output will appear here...

Part 3: Testing ValueError (Invalid Number)

What happens when we pass text instead of a number?

Output will appear here...

Part 4: Testing ZeroDivisionError

What happens when we try to divide by zero?

Output will appear here...

Part 5: Testing IndexError

What happens when we use an invalid index?

Output will appear here...

🔍 How Python Checks Multiple except Blocks

Python checks except blocks in order:

Error occurs in try block
Python checks first except - does it match? If yes, run it and stop
If no, check next except block
Repeat until a match is found
If no match found, error crashes the program

Order matters! Put specific exceptions before general ones.

Catching Multiple Exceptions in One Block

You can also catch multiple exception types with a single except block using a tuple:

Output will appear here...

🎯 Key Takeaways

Multiple except blocks = handle different errors differently
Python checks except blocks in order from top to bottom
Always return a value (even if it's None) to avoid confusion
Use tuple syntax to catch multiple exceptions with same handling

🔚 The finally Clause

finally runs no matter what - whether an exception occurred or not. Perfect for cleanup tasks like closing files!

def divide_numbers(a, b):
    try:
        print(f"Attempting to divide {a} by {b}")
        result = a / b
        print(f"Success! Result: {result}")
        return result
    except ZeroDivisionError:
        print("Error: Cannot divide by zero!")
        return None
    finally:
        print("Cleanup: This always runs!\n")

# Test cases
divide_numbers(10, 2)   # Success
divide_numbers(10, 0)   # Error

# Real-world example: file handling
def read_file_safe(filename):
    file = None
    try:
        file = open(filename, 'r')
        content = file.read()
        return content
    except FileNotFoundError:
        print(f"Error: {filename} not found")
        return None
    finally:
        if file:
            file.close()
            print("File closed")

# Even better: use 'with' statement!
def read_file_best(filename):
    try:
        with open(filename, 'r') as file:
            return file.read()
    except FileNotFoundError:
        print(f"Error: {filename} not found")
        return None

print("The 'with' statement automatically handles cleanup!")

Output will appear here...

🚨 Raising Exceptions

You can raise your own exceptions using the raise keyword. This is useful for validation!

Output will appear here...

🐛 Debugging Tips

Essential Debugging Techniques

Print statements: Add print() to see variable values
type(): Check what type a variable is
Read the traceback: Error messages tell you exactly what went wrong
Test small pieces: Test functions individually
Use meaningful names: Makes bugs easier to spot

Debugging Example

# Buggy function
def calculate_average(numbers):
    print(f"DEBUG: Input: {numbers}")
    print(f"DEBUG: Type: {type(numbers)}")

if not numbers:
        print("DEBUG: List is empty!")
        return 0

total = sum(numbers)
    count = len(numbers)

print(f"DEBUG: Total={total}, Count={count}")

average = total / count
    print(f"DEBUG: Average={average}")

return average

# Test cases
test_data = [
    [10, 20, 30],
    [],
    [5, 15, 25, 35]
]

for data in test_data:
    print(f"\nTesting with {data}:")
    result = calculate_average(data)
    print(f"Result: {result}\n" + "="*40)

# Common debugging checks
def debug_variable(var, name="variable"):
    """Print detailed info about a variable."""
    print(f"\n{'='*40}")
    print(f"Debugging: {name}")
    print(f"Value: {var}")
    print(f"Type: {type(var)}")
    print(f"Length: {len(var) if hasattr(var, '__len__') else 'N/A'}")
    print(f"{'='*40}")

# Examples
debug_variable([1, 2, 3], "my_list")
debug_variable("Hello", "my_string")
debug_variable(42, "my_number")

Output will appear here...

📺 Video Resources

🤖 AI Learning Prompts

Understanding Error Handling

Help me master Python error handling:

1. Explain try/except/finally with examples
2. When should I catch specific vs general exceptions?
3. Show me 10 real-world error handling scenarios
4. How do I write custom error messages?
5. Give me practice problems for exception handling

Include best practices!

Debugging Skills

Teach me effective debugging:

1. What are the best debugging strategies?
2. How do I read Python tracebacks?
3. Show me debugging techniques for different error types
4. Give me exercises where I fix broken code
5. How do professionals debug complex programs?

Make it practical!

✏️ Practice Exercises

Challenge: Input Validator

def get_positive_number(prompt="Enter a positive number: "):
    """Get a positive number from user with error handling."""
    while True:
        try:
            # In real code, use input(). Here we simulate:
            user_input = "42"  # Simulated input
            number = float(user_input)

if number <= 0:
                raise ValueError("Number must be positive")

return number
        except ValueError as e:
            print(f"Error: {e}. Please try again.")
            return None  # In real code, loop would continue

# Test it
result = get_positive_number()
if result:
    print(f"You entered: {result}")
    print(f"Square: {result**2}")

# Safe calculator
def safe_calculator(a, b, operation):
    """Perform safe calculations with error handling."""
    try:
        if operation == "add":
            return a + b
        elif operation == "subtract":
            return a - b
        elif operation == "multiply":
            return a * b
        elif operation == "divide":
            if b == 0:
                raise ZeroDivisionError("Cannot divide by zero")
            return a / b
        else:
            raise ValueError(f"Unknown operation: {operation}")
    except (TypeError, ValueError, ZeroDivisionError) as e:
        print(f"Error: {e}")
        return None

# Test calculator
print("\nCalculator tests:")
print("10 + 5 =", safe_calculator(10, 5, "add"))
print("10 / 0 =", safe_calculator(10, 0, "divide"))
print("10 % 5 =", safe_calculator(10, 5, "modulo"))

Output will appear here...

Challenge 2: File Handler with Error Handling

Difficulty: Medium | Time: 15 minutes

Task: Create a safe file reader that handles missing files and permission errors.

Output will appear here...

def safe_read_file(filename):
    """Safely read a file with proper error handling."""
    try:
        # Simulating file operations
        if filename == "missing.txt":
            raise FileNotFoundError(f"File '{filename}' not found")
        elif filename == "protected.txt":
            raise PermissionError(f"Permission denied for '{filename}'")
        else:
            # Simulate successful read
            return f"Contents of {filename}: Hello, World!"
    except FileNotFoundError as e:
        return f"Error: {e}. Please check the filename."
    except PermissionError as e:
        return f"Error: {e}. Check file permissions."
    except Exception as e:
        return f"Unexpected error: {e}"
    finally:
        print(f"Attempted to read: {filename}")

# Test cases
print(safe_read_file("data.txt"))
print(safe_read_file("missing.txt"))
print(safe_read_file("protected.txt"))

Challenge 3: List Index Error Handler

Difficulty: Easy | Time: 10 minutes

Task: Create a safe list accessor that handles index errors gracefully.

Output will appear here...

def safe_get_element(my_list, index, default=None):
    """Safely get element from list with error handling."""
    try:
        return my_list[index]
    except IndexError:
        print(f"Warning: Index {index} out of range. Returning default.")
        return default
    except TypeError:
        print(f"Error: Invalid index type. Returning default.")
        return default

# Test cases
numbers = [10, 20, 30, 40, 50]

print("Valid index (2):", safe_get_element(numbers, 2))
print("Out of range (10):", safe_get_element(numbers, 10, "N/A"))
print("Negative index (-1):", safe_get_element(numbers, -1))
print("Invalid index ('abc'):", safe_get_element(numbers, 'abc', 0))

Challenge 4: Dictionary Key Error Handler

Difficulty: Medium | Time: 15 minutes

Task: Create a safe dictionary accessor with multiple error checks.

Output will appear here...

def safe_dict_get(dictionary, key, convert_to=None):
    """
    Safely get and optionally convert dictionary values.
    Args:
        dictionary: The dictionary to access
        key: The key to look up
        convert_to: Optional type to convert to (int, float, str)
    """
    try:
        value = dictionary[key]

        # If conversion requested
        if convert_to is not None:
            try:
                return convert_to(value)
            except (ValueError, TypeError) as e:
                print(f"Conversion error: {e}")
                return None

        return value
    except KeyError:
        print(f"Error: Key '{key}' not found in dictionary")
        return None
    except TypeError:
        print("Error: Invalid dictionary or key type")
        return None

# Test cases
user_data = {"name": "Alice", "age": "25", "score": "95.5"}

print("Get name:", safe_dict_get(user_data, "name"))
print("Get age as int:", safe_dict_get(user_data, "age", int))
print("Get score as float:", safe_dict_get(user_data, "score", float))
print("Missing key:", safe_dict_get(user_data, "email", str))
print("Invalid conversion:", safe_dict_get(user_data, "name", int))

Challenge 5: Custom Exception Practice

Difficulty: Hard | Time: 20 minutes

Task: Create custom exceptions for a banking system with validation.

Output will appear here...

# Custom exceptions
class InsufficientFundsError(Exception):
    """Raised when account has insufficient funds."""
    pass

class InvalidAmountError(Exception):
    """Raised when amount is invalid."""
    pass

# Bank account class with error handling
class BankAccount:
    def __init__(self, balance=0):
        if balance < 0:
            raise InvalidAmountError("Initial balance cannot be negative")
        self.balance = balance

    def deposit(self, amount):
        if amount <= 0:
            raise InvalidAmountError("Deposit amount must be positive")
        self.balance += amount
        print(f"Deposited ${amount:.2f}. New balance: ${self.balance:.2f}")

    def withdraw(self, amount):
        if amount <= 0:
            raise InvalidAmountError("Withdrawal amount must be positive")
        if amount > self.balance:
            raise InsufficientFundsError(
                f"Cannot withdraw ${amount:.2f}. Balance: ${self.balance:.2f}"
            )
        self.balance -= amount
        print(f"Withdrew ${amount:.2f}. New balance: ${self.balance:.2f}")

# Test cases with error handling
try:
    account = BankAccount(100)
    print(f"Account created with ${account.balance}")

    account.deposit(50)
    account.withdraw(30)

    # This will raise InsufficientFundsError
    account.withdraw(200)

except InvalidAmountError as e:
    print(f"Invalid amount: {e}")
except InsufficientFundsError as e:
    print(f"Transaction failed: {e}")
except Exception as e:
    print(f"Unexpected error: {e}")

🎯 Knowledge Check

🎓 Course Complete!

Congratulations! You've completed all Python fundamentals! You now have a solid foundation in Python programming. Keep practicing and building projects to reinforce your skills!

Error Handling & Debugging

🛡️ Understanding Errors

Why Error Handling Matters

Two Types of Errors

1️⃣ Syntax Errors

2️⃣ Exceptions

Example 1: Program Without Error Handling (Bad!)

Example 2: With Error Handling (Good!)

Example 3: Real-World Scenario

🔍 What Happens When An Error Occurs?

🎯 Key Takeaway

🎯 try/except Blocks - Your Safety Net

The Basic Structure

🔍 How try/except Works (Step-by-Step)

Example 1: Simple Division

Example 2: Division by Zero

Example 3: Safe Division Function

Example 4: Converting String to Number

Example 5: Converting Invalid String

Example 6: Safe Number Converter Function

💡 Best Practices

📋 Common Error Types - Know Your Enemies!

The "Big 7" Exceptions Every Beginner Should Know

ValueError

TypeError

ZeroDivisionError

IndexError

KeyError

FileNotFoundError

AttributeError

Let's See Each One in Action!

Example 1: ValueError

Example 2: TypeError

Example 3: ZeroDivisionError

Example 4: IndexError

Example 5: KeyError

Example 6: AttributeError

Example 7: Multiple Errors in One Program

🔍 How to Remember These Exceptions

🔄 Handling Multiple Exceptions

Part 1: Creating the Function

Part 2: Testing Valid Input

Part 3: Testing ValueError (Invalid Number)

Part 4: Testing ZeroDivisionError

Part 5: Testing IndexError

🔍 How Python Checks Multiple except Blocks

Catching Multiple Exceptions in One Block

🎯 Key Takeaways

🔚 The finally Clause

🚨 Raising Exceptions

🐛 Debugging Tips

Essential Debugging Techniques

Debugging Example

📺 Video Resources

Python Exception Handling

Python Debugging

🤖 AI Learning Prompts

Understanding Error Handling

Debugging Skills

✏️ Practice Exercises

Challenge: Input Validator

Challenge 2: File Handler with Error Handling

Challenge 3: List Index Error Handler

Challenge 4: Dictionary Key Error Handler

Challenge 5: Custom Exception Practice

🎯 Knowledge Check

Quiz Results

🎓 Course Complete!