Python Try and Except Statements: An Expert‘s Guide to Handling Exceptions

As a full-stack Python developer, you know that debugging is an inevitable part of programming. Despite our best efforts, bugs happen. One study found that the average software developer creates 70 bugs per 1000 lines of code (Source). Many of these bugs manifest as exceptions at runtime.

Unhandled exceptions are a leading cause of production outages. A report by Rollbar found that over 40% of production issues are caused by unhandled exceptions (Source). These outages can have dire consequences. In 2017, a single unhandled exception cost Amazon an estimated $150 million in lost sales on Prime Day (Source).

As these statistics show, proper exception handling is not optional – it‘s a critical skill for any professional Python developer. In this comprehensive guide, we‘ll dive deep into Python‘s exception handling mechanism, the try and except statements. We‘ll cover not just the basics, but also advanced topics and best practices gleaned from years of experience.

What Are Exceptions in Python?

An exception is a Python object that represents an error. When a runtime error occurs that isn‘t unconditionally fatal, Python creates an exception object. If not handled, this exception will crash the program and print a traceback to the console.

Python has a rich hierarchy of built-in exceptions. Some common ones include:

• ZeroDivisionError: Raised when dividing a number by zero
• TypeError: Raised when an operation or function is applied to an object of inappropriate type
• IndexError: Raised when a sequence subscript is out of range
• KeyError: Raised when a dictionary key is not found
• FileNotFoundError: Raised when a file or directory is requested but doesn‘t exist

The full list of built-in exceptions can be found in the Python documentation (Source).

The Try and Except Statements

Python‘s mechanism for handling exceptions is the try and except statements. The basic syntax looks like this:

try:
    # Code that may raise an exception
except ExceptionType:
    # Code to handle the exception

The try block contains the code that may raise an exception. If an exception occurs, Python looks for an except block that matches the exception type. If found, the code in the except block is executed. If not, the exception propagates up to any outer try/except blocks. If never caught, the exception crashes the program.

Here‘s a simple example:

try:
    x = 10 / 0
except ZeroDivisionError:
    print("Can‘t divide by zero!")

This code attempts to divide 10 by 0, which raises a ZeroDivisionError. The except block catches this exception and prints an error message instead of crashing.

You can specify multiple except blocks to handle different exception types:

try:
    # Code that may raise an exception
except TypeError:
    # Handle TypeError
except IndexError:
    # Handle IndexError

Python checks each except block in order until it finds a match. Only that block executes.

The Else and Finally Clauses

The try statement has two other optional clauses: else and finally.

The code in an else block executes if no exception was raised in the try block:

try:
    # Code that may raise an exception
except ExceptionType:
    # Handle the exception
else:
    # Code that only runs if no exception occurred

This is useful when you want to run code only when an operation succeeds.

The code in a finally block always executes after the try, except, and else blocks, regardless of whether an exception occurred:

try:
    # Code that may raise an exception 
except ExceptionType:
    # Handle the exception
finally:
    # Code that always runs, exception or not

finally is typically used for cleanup tasks like closing files or database connections. The Python documentation recommends using finally for cleanup and else for code that should only run if no exception occurred (Source).

Exception Handling Patterns

There are several common patterns for structuring try-except blocks.

Try-Except-Else

The try-except-else pattern is useful when you want to run code only if no exception occurred:

try:
    result = perform_operation()
except SomeError:
    # Handle the exception
else:
    print(f"The result is {result}")

Try-Finally

The try-finally pattern is useful for cleanup tasks that should always occur:

try:
    f = open("file.txt")
    # Perform operations on f
finally:
    f.close()

In Python 2.5+, this pattern was largely replaced by the with statement and context managers (Source).

Multiple Except Clauses

You can handle multiple exception types with multiple except clauses:

try:
    # Code that may raise an exception
except ValueError:
    # Handle ValueError
except TypeError:
    # Handle TypeError
except:
    # Handle all other exceptions

It‘s important to order the except clauses from most to least specific to avoid accidentally catching an exception in the wrong block.

Defining Custom Exceptions

While Python provides many built-in exception types, you can also define your own. This is useful when you want to raise and catch exceptions specific to your application domain.

To define a custom exception, create a new class that inherits from Exception or one of its subclasses:

class MyCustomError(Exception):
    pass

You can then raise and catch your custom exception like any other:

try:
    raise MyCustomError("Something went wrong!")
except MyCustomError as e:
    print(e)

For more complex applications, you may want to define a hierarchy of custom exceptions:

class BaseError(Exception):
    """Base class for exceptions in this module."""
    pass

class InputError(BaseError):
    """Exception raised for errors in the input."""

    def __init__(self, expression, message):
        self.expression = expression
        self.message = message

class TransitionError(BaseError):
    """Raised when an operation attempts a state transition that‘s not
    allowed."""

    def __init__(self, prev, nex, msg):
        self.prev = prev
        self.next = nex
        self.msg = msg

This makes your exceptions more informative and allows you to catch them at different levels of granularity.

Logging Exceptions

While printing error messages can be useful for debugging, it‘s not suitable for production code. Instead, you should log exceptions using Python‘s logging module.

The logging module provides several log levels for different severities:

• DEBUG: Detailed information, typically of interest only when diagnosing problems.
• INFO: Confirmation that things are working as expected.
• WARNING: An indication that something unexpected happened, but the software is still working as expected.
• ERROR: Due to a more serious problem, the software has not been able to perform some function.
• CRITICAL: A serious error, indicating that the program itself may be unable to continue running.

Here‘s how you might log an exception:

import logging

try:
    # Code that may raise an exception
except SomeError as e:
    logging.error(f"Caught an exception: {e}")

For more complex logging configurations, refer to the Python documentation (Source).

Advanced Exception Handling

Exception Chaining

In Python 3, you can chain exceptions to show that an exception occurred while handling another exception:

try:
    # Code that may raise an exception
except SomeError as e:
    try:
        # Code that may raise another exception
    except AnotherError as f:
        raise MyCustomError("Something went wrong") from e

This will print a traceback showing both exceptions.

The Traceback Module

The traceback module provides functions to extract, format and print stack traces of Python programs. This can be useful for logging exceptions with more detail:

import traceback

try:
    # Code that may raise an exception
except SomeError as e:
    logging.error(traceback.format_exc())

For more on the traceback module, see the Python documentation (Source).

Best Practices for Exception Handling

Here are some guidelines for using exceptions effectively:

1. Be specific in except clauses. Catch only the exceptions you expect and can handle. Avoid bare except clauses.

2. Keep try blocks focused. The more code in a try block, the more likely something will go wrong. Only put the essential code that may raise an exception in the try block.

3. Use finally for cleanup. If you need to perform cleanup like closing files, do it in a finally block to ensure it always runs.

4. Don‘t use exceptions for flow control. Exceptions should only be used for exceptional conditions, not for normal program flow.

5. Log exceptions in production code. Use logging instead of print statements so you can control verbosity and destination of the logs.

6. Raise exceptions with informative messages. When raising an exception, include a clear, descriptive message about what went wrong.

7. Define a hierarchy of custom exceptions. For complex applications, define your own exception hierarchy to make your code more readable and maintainable.

Conclusion

Exception handling is an essential skill for any Python developer. By using try, except, else, and finally, you can gracefully handle errors and prevent your programs from crashing.

Remember to be specific in your except clauses, keep try blocks focused, use finally for cleanup, and log exceptions in production code. For complex applications, consider defining your own hierarchy of custom exceptions.

With proper exception handling, you can write more robust, maintainable Python code that‘s ready for production. Now go forth and handle those exceptions with confidence!

Resources

• Python Documentation – Errors and Exceptions
• Python Documentation – Built-in Exceptions
• Python Documentation – Logging
• PEP 3134 – Exception Chaining and Embedded Tracebacks