Python: Handle Exceptions with Try and Except

Python Exception Handling Tutorial

This tutorial will guide you through handling exceptions in Python using the `try` and `except` blocks. Understanding how to gracefully handle errors is crucial for writing robust and reliable Python code.

What are Exceptions?

Exceptions are events that disrupt the normal flow of a program’s execution. They typically occur when something unexpected happens, such as trying to divide by zero or accessing a non-existent file. Without exception handling, your program would crash when an exception is raised.

The `try` and `except` Blocks

The `try` block contains the code that might raise an exception. The `except` block specifies what to do if an exception occurs within the `try` block. You can have multiple `except` blocks to handle different types of exceptions.

Basic structure:

try: Code that might raise an exception.
except ExceptionType as e: Handles a specific type of exception. e is an optional variable that holds the exception object.
else: (Optional) Code to execute if no exception occurred in the `try` block.
finally: (Optional) Code that is always executed, regardless of whether an exception occurred. This is commonly used for cleanup tasks, such as closing files.

Example 1: Handling `ZeroDivisionError`

This example demonstrates how to handle a `ZeroDivisionError`, which occurs when you attempt to divide a number by zero.

def divide(x, y):
    try:
        result = x / y
        print(f"The result is: {result}")
    except ZeroDivisionError as e:
        print(f"Error: Cannot divide by zero. {e}")
        result = None  # Set a default value in case of error
    else:
        print("Division successful.")
    finally:
        print("Execution completed.")

    return result

# Example usage
divide(10, 2)
divide(5, 0)
divide(8, 2)

Let’s break down the code:

We define a function called `divide` that takes two arguments, `x` and `y`.
Inside the `try` block, we attempt to divide `x` by `y` and store the result in the `result` variable.
If `y` is 0 (which causes a `ZeroDivisionError`), the `except` block is executed. It prints an error message and sets `result` to `None`.
The `else` block is executed if no exception occurred. It prints a success message.
The `finally` block is always executed, regardless of whether an exception occurred. It prints a completion message.

The function is then called three times with different inputs to demonstrate its behavior.

# Example 1: divide(10, 2)
# Input: x = 10, y = 2
# Output:
# The result is: 5.0
# Division successful.
# Execution completed.

# Example 2: divide(5, 0)
# Input: x = 5, y = 0
# Output:
# Error: Cannot divide by zero. division by zero
# Execution completed.

# Example 3: divide(8, 2)
# Input: x = 8, y = 2
# Output:
# The result is: 4.0
# Division successful.
# Execution completed.

Output:

# Example 1: divide(10, 2)
# Input: x = 10, y = 2
# Output:
# The result is: 5.0
# Division successful.
# Execution completed.

# Example 2: divide(5, 0)
# Input: x = 5, y = 0
# Output:
# Error: Cannot divide by zero. division by zero
# Execution completed.

# Example 3: divide(8, 2)
# Input: x = 8, y = 2
# Output:
# The result is: 4.0
# Division successful.
# Execution completed.

Example 2: Handling `FileNotFoundError`

This example demonstrates handling a `FileNotFoundError`, which occurs when you attempt to open a file that does not exist.

def read_file(filename):
    try:
        with open(filename, 'r') as f:
            content = f.read()
            print(f"File content:n{content}")
    except FileNotFoundError as e:
        print(f"Error: File not found: {e}")
        content = "" # Provide a default value
    except Exception as e:
        print(f"An unexpected error occurred: {e}")
        content = ""
    finally:
        print("File operation attempted.")
    return content

# Example usage
read_file("my_file.txt")
read_file("nonexistent_file.txt")

Here’s the breakdown:

We define a function `read_file` that takes a filename as input.
Inside the `try` block, we attempt to open the file in read mode (`’r’`) using `with open(…)`. The `with` statement ensures the file is properly closed, even if errors occur.
If the file is not found, a `FileNotFoundError` is raised, and the `except` block is executed. It prints an error message and sets `content` to an empty string.
An additional `except` block catches any other exceptions that might occur during file operation.
The `finally` block always executes, indicating that the file operation has been attempted.

# Example 1: read_file("my_file.txt")
# Input: filename = "my_file.txt" (assuming my_file.txt exists)
# Output:
# File content:
# This is the content of my_file.txt
# File operation attempted.

# Example 2: read_file("nonexistent_file.txt")
# Input: filename = "nonexistent_file.txt"
# Output:
# Error: File not found: [Errno 2] No such file or directory: 'nonexistent_file.txt'
# File operation attempted.

Output:

# Example 1: read_file("my_file.txt")
# Input: filename = "my_file.txt" (assuming my_file.txt exists)
# Output:
# File content:
# This is the content of my_file.txt
# File operation attempted.

# Example 2: read_file("nonexistent_file.txt")
# Input: filename = "nonexistent_file.txt"
# Output:
# Error: File not found: [Errno 2] No such file or directory: 'nonexistent_file.txt'
# File operation attempted.

Example 3: Combining Multiple Exceptions

This example demonstrates handling multiple exception types in a single `except` block.

def process_data(data):
    try:
        num = int(data)
        result = 10  num
        print(f"The result is: {result}")
    except ValueError as e:
        print(f"Error: Invalid data format. Please enter a number: {e}")
    except TypeError as e:
        print(f"Error: Invalid data type. {e}")
    except Exception as e:
        print(f"An unexpected error occurred: {e}")

# Example usage
process_data("10")
process_data("abc")
process_data(15)

Explanation:

We define a function `process_data` that takes a string `data` as input.
Inside the `try` block, we attempt to convert the string to an integer using `int(data)`.
We calculate the result (10 times the number) and print it.
We have three `except` blocks to catch different types of errors:
`ValueError`: Raised if the input string cannot be converted to an integer.
`TypeError`: Raised if an unexpected data type is passed.
`Exception`: A general exception handler for any other unexpected errors.

# Example 1: process_data("10")
# Input: data = "10"
# Output:
# The result is: 100
# File operation attempted.

# Example 2: process_data("abc")
# Input: data = "abc"
# Output:
# Error: Invalid data format. Please enter a number: invalid literal for int() with base 10: 'abc'
# File operation attempted.

# Example 3: process_data(15)
# Input: data = 15
# Output:
# The result is: 150
# File operation attempted.

Output:

# Example 1: process_data("10")
# Input: data = "10"
# Output:
# The result is: 100
# File operation attempted.

# Example 2: process_data("abc")
# Input: data = "abc"
# Output:
# Error: Invalid data format. Please enter a number: invalid literal for int() with base 10: 'abc'
# File operation attempted.

# Example 3: process_data(15)
# Input: data = 15
# Output:
# The result is: 150
# File operation attempted.

Key Takeaways

Use `try` blocks to enclose code that might raise exceptions.
Use `except` blocks to handle specific exception types.
The `else` block executes if no exception occurred in the `try` block.
The `finally` block always executes, regardless of whether an exception occurred.
Handle exceptions gracefully to prevent your program from crashing.