Master Python Exception Handling: Safer, Cleaner Code with Helper Functions

Exception handling principles are sound and Python even encourages their use, but treating them as a "big hammer" to hide errors or overusing them is a mistake.

Consider classic pitfalls:

try:
    data = json.loads(input_str)
except:
    data = {}

This is dangerous because it catches all exceptions, including KeyboardInterrupt, MemoryError, and others you might not want to ignore.

try:
    os.remove(file_path)
except:
    pass

Now you get a silent failure—you have no idea why the file wasn’t deleted.

In short, try-except should be specific, not perfunctory.

More Concise, Safer Pattern: Use Helper Functions

Instead of lengthy try-except blocks, write small, intent‑clear functions to encapsulate operations that may raise exceptions.

Don’t Do This:

try:
    value = int(user_input)
except ValueError:
    value = None

Do This Instead:

def safe_int(value):
    try:
        return int(value)
    except ValueError:
        return None

value = safe_int(user_input)

This tiny abstraction keeps your core logic clean, simple, and easier to audit.

It also scales: if your exception handling grows more complex, it stays confined to one place.

def safe_int(value, default=None):
    try:
        return int(value)
    except (ValueError, TypeError):
        return default

Keep try-except Blocks Narrow and Purposeful

Another way to simplify error handling is to make the try block as short as possible, wrapping only the lines that may fail.

Chaotic Code:

try:
    connect_to_db()
    query = build_query()
    results = run_query(query)
except Exception as e:
    log_error(e)
    raise

Cleaner Code:

connect_to_db()

query = build_query()
try:
    results = run_query(query)
except QueryExecutionError as e:
    log_error(e)
    raise

This immediately reveals which lines may raise exceptions while preventing accidental masking of other errors.

Pattern: Use Context Managers for Resource Handling

When dealing with file I/O, network sockets, or locks, you might reach for try-finally to clean up:

f = open('data.txt')
try:
    process(f)
finally:
    f.close()

Python offers a more idiomatic solution: context managers.

Better Code:

with open('data.txt') as f:
    process(f)

This not only handles exceptions elegantly but also shortens the code, making it safer and easier to understand.

Extra Tip: Use contextlib.suppress for Known Harmless Exceptions

Sometimes you don’t mind ignoring a specific error. Python provides a graceful way to do this:

from contextlib import suppress

with suppress(FileNotFoundError):
    os.remove('temp.txt')

This is preferable (and safer) to using a minimal except block or a bare pass.