20 Essential Python Exception Handling Techniques

Exception handling is a crucial aspect of writing robust Python code; this article presents twenty techniques to improve readability, efficiency, and Pythonic style.

1. Simplest Exception Handling

Shows the basic try‑except‑finally structure and explains the exception hierarchy, where IOError is caught before the generic Exception .

try:
    # Your code here
except IOError:
    # Handle I/O errors
except Exception as e:
    # Handle other exceptions
finally:
    # Cleanup, runs no matter what

2. Custom Exceptions

Creating a user‑defined exception class improves code readability and clearly signals specific error conditions.

class MyCustomError(Exception):
    pass

try:
    raise MyCustomError("A specific error occurred")
except MyCustomError as e:
    print(e)

3. Else in Try‑Except

The else clause runs only when no exception is raised, a feature not present in many other languages.

try:
    # Attempt operation
except Exception:
    # Handle error
else:
    # Executes if no exceptions

4. Using the as Keyword

Assigns the caught exception to a variable for detailed inspection and easier debugging.

try:
    # Some operation
except Exception as e:
    print(f"Error: {e}")

5. Capturing Multiple Exceptions

Uses a tuple to catch several exception types in a single except clause, simplifying error handling.

try:
    # Risky operation
except (TypeError, ValueError) as e:
    # Handle both exceptions

6. Raising a New Exception from Another

Python can raise a new exception while preserving the original traceback using raise ... from , aiding complex debugging.

try:
    # Some operation
except Exception as original_error:
    raise RuntimeError("Something bad happened") from original_error

7. Ignoring Exceptions with contextlib.suppress

The suppress function gracefully ignores specified exceptions, making code clearer.

from contextlib import suppress

with suppress(FileNotFoundError):
    # Operation that might not find a file

8. Using Assertions

Assertions raise an AssertionError when a condition is false, but they can be disabled with optimization flags, so use them cautiously.

assert condition, "Condition was not met"

9. Formatting Exception Information

The traceback module prints detailed exception data, helping developers understand the error context.

import traceback

try:
    raise ValueError("An error occurred")
except:
    traceback.print_exc()  # Print exception information to stderr

10. Emitting Non‑Fatal Warnings

The warnings module issues warning messages without stopping program execution.

import warnings

warnings.warn("This is a warning message", UserWarning)

11. Ignoring Exceptions (Repeated)

Shows again how contextlib.suppress can be used to ignore specific exceptions while ensuring resources are cleaned up.

from contextlib import suppress

with suppress(FileNotFoundError):
    open('non_existent_file.txt', 'r')  # Suppresses the FileNotFoundError

12. Exception‑Handling Wrapper Function

A decorator created with functools.wraps centralises exception handling for multiple functions.

from functools import wraps

def exception_handler(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        try:
            return func(*args, **kwargs)
        except Exception as e:
            print(f"Handled exception: {e}")
            return None
    return wrapper

@exception_handler
def risky_function():
    raise ValueError("Something went wrong")

risky_function()

13. Accessing Exception Attributes with sys.exc_info

sys.exc_info() returns the type, value, and traceback of the current exception for logging or further processing.

import sys

try:
    raise TypeError("An error occurred")
except:
    exc_type, exc_value, exc_traceback = sys.exc_info()
    print(exc_type, exc_value)

14. Analyzing the Current Exception Context

The inspect module can walk the stack to locate frames related to a specific function, useful for complex error‑handling scenarios.

import inspect

def current_exception():
    for frame in inspect.trace():
        if frame[3] == 'risky_function':
            return frame[0].f_locals.get('e')

try:
    risky_function()
except Exception as e:
    print(current_exception())

15. Creating Dynamic Exception Classes

The types module can generate exception classes at runtime, allowing flexible error definitions based on conditions.

import types

DynamicException = types.new_class('DynamicException', (Exception,))
raise DynamicException("A dynamically created exception")

16. Listing All Built‑in Exceptions

Iterating over builtins reveals every built‑in exception type, helping developers understand the exception hierarchy.

import builtins

for name in dir(builtins):
    obj = getattr(builtins, name)
    if isinstance(obj, type) and issubclass(obj, BaseException):
        print(name)

17. Customising Exception String Representation

Overriding __str__ and __repr__ in a subclass provides richer error messages.

class MyException(Exception):
    def __str__(self):
        return "This is a custom message for MyException"
    def __repr__(self):
        return "MyException()"

raise MyException

18. Exceptions Not Caught by except Exception

Deriving from BaseException creates errors that bypass a generic except Exception block, useful for critical failures.

class MyCriticalError(BaseException):
    pass

try:
    raise MyCriticalError("A critical error")
except Exception as e:
    print("This will not catch MyCriticalError")

19. Gracefully Handling User and System Interrupts

Catching KeyboardInterrupt and SystemExit allows programs to shut down cleanly.

import sys

try:
    while True:
        continue
except KeyboardInterrupt:
    print("User interrupted the process")
    sys.exit(0)

20. Generator Resource Cleanup

Handling GeneratorExit lets a generator perform cleanup actions when it is closed.

def my_generator():
    try:
        yield "Hello"
    except GeneratorExit:
        print("Generator closing")
        raise

gen = my_generator()
next(gen)
gen.close()

Conclusion

Proper exception handling dramatically enhances code robustness and clarity; the twenty examples compiled here equip Python developers with the tools to master error management and write cleaner, more maintainable programs.