Suggest a cleaner way to handle Python exceptions?

Python uses the try-except block to handle errors during runtime. But as your program grows, handling exceptions can get messy with repeated code or too many nested blocks.

Using cleaner methods for exception handling can reduce duplication and make your code easier to manage. In this article, we explore better ways to handle exceptions in Python.

Using Specific Exception Types

It is best to catch specific exceptions like ValueError or FileNotFoundError instead of using a general except: block. This prevents hiding unexpected errors and improves debugging.

This approach avoids catching unrelated exceptions like KeyboardInterrupt or TypeError.

Example

In this example, only ValueError is caught, and other unexpected errors are not silently ignored ?

try:
    number = int("abc")  # This will cause ValueError
    print("Square is:", number ** 2)
except ValueError:
    print("Invalid input. Please enter a valid integer.")

Following is the output obtained ?

Invalid input. Please enter a valid integer.

Using Exception Chaining

Use the raise ... from ... syntax to raise a new exception while keeping the original one as context. This helps you trace back to the root cause of an error, making debugging easier and more informative.

Example

In the following example, we re-raise an exception with a custom message while preserving the original traceback ?

def read_number(data):
    try:
        return int(data)
    except ValueError as e:
        raise RuntimeError("Failed to read a valid integer from data") from e

# Use the function and handle errors
try:
    value = read_number("4b")  # Invalid integer format
    print("Read value:", value)
except RuntimeError as e:
    print("Error:", e)

We get the output as shown below ?

Error: Failed to read a valid integer from data

Grouping Multiple Exceptions

You can handle different types of exceptions in a single except block by listing them in a tuple. This keeps your code cleaner and avoids writing separate blocks for each exception type.

Example

Here, we are grouping ValueError and TypeError exceptions together in a single except block ?

try:
    number = int("abc")  # Causes ValueError
except (ValueError, TypeError) as e:
    print("Conversion failed:", e)

The error obtained is as shown below ?

Conversion failed: invalid literal for int() with base 10: 'abc'

Creating Reusable Error-Handling Functions

Instead of writing the same try-except logic multiple times, you can create a helper function or use a decorator to handle errors in one place. This makes your code more reusable, cleaner, and easier to update when handling exceptions.

This pattern is useful when you want uniform exception logging for multiple functions.

Example

This following function wraps another function and provides consistent error handling in one place ?

def safe_run(func):
    try:
        return func()
    except Exception as e:
        print("Error occurred:", e)

def divide():
    return 10 / 0

safe_run(divide)

The result produced is as follows ?

Error occurred: division by zero

Using Context Managers for Resource Management

Context managers automatically handle resource cleanup even when exceptions occur. Use with statements for files, database connections, and other resources that need proper cleanup.

Example

Context managers ensure files are properly closed even if an error occurs ?

# Safe file handling with context manager
try:
    with open("nonexistent.txt", "r") as file:
        content = file.read()
        print(content)
except FileNotFoundError:
    print("File not found. Creating a default file.")
    with open("nonexistent.txt", "w") as file:
        file.write("Default content")
    print("Default file created successfully.")

File not found. Creating a default file.
Default file created successfully.

Comparison of Exception Handling Approaches

Conclusion

Clean exception handling improves code maintainability and debugging. Use specific exception types, group related exceptions, and create reusable error-handling patterns. Context managers ensure proper resource cleanup even when errors occur.