Mastering Python Exception Handling | How to Use try-except and Best Practices

By 佐川 直弘 (運営者)

※記事内に広告を含みます。Amazonアソシエイトとして適格販売により収入を得ています。

1. Overview of Exception Handling in Python

What is Exception Handling in Python?

During program execution, unexpected errors may occur. These are called “exceptions,” and when they happen, the program usually stops running. Python provides exception handling to manage these errors. By using exception handling, you can respond to errors appropriately and ensure that the program continues running smoothly.

Why is Exception Handling Important?

Exception handling is crucial for keeping the program running smoothly for users, even when errors occur. It also helps in identifying the cause of errors and making debugging easier, ultimately leading to more reliable programs.

2. What is the try-except Statement?

Basic Syntax

In Python, the try-except statement is used to handle potential errors. The code that may cause an error is written inside the try block, while the except block contains the handling mechanism in case an error occurs. Here is the basic syntax:

try:
    # Code that may cause an error
except SomeError:
    # Code to handle the error

If the code inside the try block runs without errors, the except block is ignored. However, if an error occurs, the program executes the appropriate handling code in the except block.

Common Example: Division by Zero Error

Attempting to divide by zero results in a ZeroDivisionError. This error can be handled as follows:

try:
    result = 10 / 0
except ZeroDivisionError:
    print("Cannot divide by zero")

3. Common Exceptions and How to Handle Them

1. ZeroDivisionError

This exception occurs when division by zero is attempted. For example, trying to divide a number by 0 will automatically raise a ZeroDivisionError in Python.

try:
    result = 10 / 0
except ZeroDivisionError:
    print("Cannot divide by zero")

2. ValueError

A ValueError occurs when an invalid value is passed to a function or operation. In the following example, we attempt to convert a string that is not a valid number into an integer.

try:
    num = int("not_a_number")
except ValueError:
    print("Invalid value")

3. Handling Multiple Exceptions

If you want to handle multiple exceptions at once, you can use the except statement with multiple exceptions grouped together:

try:
    result = 10 / "string"
except (ZeroDivisionError, TypeError):
    print("An error occurred")

4. Retrieving Error Details Using Exception Objects

Using as to Capture Exception Objects

With the except statement, you can use the as keyword to capture the exception object. This allows you to reference error details or log them for further analysis.

try:
    a = 10 / 0
except ZeroDivisionError as e:
    print(f"An error occurred: {e}")

In this code, when a ZeroDivisionError occurs, the error message is stored in the variable e and displayed in the output.

5. Using the finally Block

What is finally?

The finally block is used to execute code regardless of whether an exception occurs or not. It is especially useful for tasks like closing files or cleaning up database connections, ensuring that necessary operations are always performed.

try:
    file = open("test.txt", "r")
except FileNotFoundError:
    print("File not found")
finally:
    print("File operation completed")

Cleaning Up Resources

The finally block is useful for releasing resources at the end of a program. For example, you can use finally to make sure a file is always closed.

try:
    file = open("data.txt", "r")
    # Perform file operations
finally:
    file.close()

By using the finally block, you can ensure that the file is closed properly, even if an error occurs.

6. Raising Exceptions with raise

The Role of raise

The raise statement allows developers to manually trigger exceptions. This is useful for validating inputs or enforcing conditions by explicitly throwing an error.

def check_value(value):
    if value < 0:
        raise ValueError("Negative values are not allowed")

Example of a Custom Exception

By raising errors for specific conditions, you can prevent invalid input and unexpected behavior.

7. Best Practices for Exception Handling in Python

1. Avoid Excessive Exception Handling

Overusing exception handling can make code harder to read and debug. Exceptions should only be used in parts of the code where errors are likely to occur, rather than being integrated into the normal program flow.

2. Use Logging to Record Errors

When an exception occurs, it is important to log the error message. This helps in tracking down the cause of the error later. The following example shows how to use the logging module:

import logging

try:
    a = 10 / 0
except ZeroDivisionError as e:
    logging.error(f"An error occurred: {e}")

3. Avoid Using Broad except Statements

It is recommended to catch specific errors rather than using a broad except Exception statement. Catching too many errors at once can make it harder to identify the exact issue, so handling specific exceptions separately is a better approach.