Python: How to ignore an exception and proceed?

Using 'suppress' in contextlib to manage exceptions elegantly

Python 3.4 onwards, the contextlib module presents a cleaner alternative to handle exceptions deliberately ignored. Particularly useful when dealing with specific sets of exceptions.

from contextlib import suppress

with suppress(FileNotFoundError):
    # Me trying to remember where I left something :)
    os.remove('non_existent_file.txt')


Here, the code tries to delete a file, and typically, if that file doesn't exist, it leads to raising a FileNotFoundError. The suppress method ignores the exception and proceeds, avoiding unnecessary try-except blocks.

Avoiding some common traps

Ignoring exceptions needs to be done with caution. It's important to specifically mention the type of exception you expect, as a bare except: could lead to suppressing all exceptions, including those like KeyboardInterrupt and SystemExit that are fundamental to interrupt your program.

Wrong Way:

try:
    print("Doing stuff...")
    do_stuff()  # High-stakes gamble anonymous ;)
except:
    print("Well, that didn't go as planned.")
    pass


Right Way:

try:
    print("Doing more stuff...")
    do_more_stuff()  # Rolling dice again but smarter ;)
except KnownException:
    print("Not as planned, but expected.")
    pass


Moreover, **avoiding too broad **an exception, such as Exception, can mask unexpected issues. So, your except block needs to precisely cater to specific exceptions that you know could arise and are harmless to be ignored.

Delving deeper: Exception handling strategies

Handling exceptions requires in-depth understanding of underlying semantics. By using with suppress(..) it becomes easier to focus on specific, non-critical exceptions for a one-off occurrence.

In case of patterns with suppressions required across various places, one can use a Decorator to wrap functions with an ignore_exception functionality that will silently handle specific exception type(s).

Example:

from functools import wraps

def ignore_exception(exc_type):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            try:
                return func(*args, **kwargs)
            except exc_type:
                print("Phew! Narrow escape there. Just smiled and waved at the exception.")
                pass
        return wrapper
    return decorator

@ignore_exception(ValueError)
def parse_int(val):
    return int(val)


In Python 2, you might encounter references to sys.exc_clear(), a function to delete the last exception. While this may seem handy, it is outdated and deprecated in Python 3, encouraging more explicit exception handling.

Code Smarter with Exception Handling

Choosing the right strategy to handle exceptions depends greatly on your project requirements:

Elegance in code

Use with suppress(..) to keep your code clean and optimized:

with suppress(ConnectionError):
    pull_data()


Debugging Made Easy

Record suppressed exceptions for better debugging and tracing:

try:
    perform_operation()
except Exception as e:
    # I used to design user-friendly error messages, then I took an exception to the knee!
    logging.error(f"Encountered an error: {e}")
    pass


Robust System Design

In larger systems, a custom exception handler can streamline exception handling:

def custom_handler(exc_type, callable, *args, **kwargs):
    try:
        return callable(*args, **kwargs)
    except exc_type as e:
        # My spider-sense is tingling! Time to handle the exception.
        handle_custom_exception(e)


This approach helps to manage and structure handling of different exceptions across a larger codebase.