Python - Handling exceptions with try-except blocks

Handling Exceptions with try-except Blocks in Python

Exception handling is an essential part of writing robust, user-friendly Python programs. Python provides a powerful mechanism to catch and handle exceptions using the try-except block. This allows developers to anticipate errors that might occur during program execution and handle them gracefully without crashing the entire application. In this comprehensive guide, we will delve deep into exception handling in Python, focusing on the syntax, best practices, common exceptions, advanced features, and practical examples.

What is an Exception?

Definition

An exception is an error that occurs during the execution of a program. When a Python program encounters an error, it raises an exception. If not handled, the program terminates with a traceback. Handling exceptions allows the program to recover or exit gracefully.

Difference Between Errors and Exceptions

• Errors: Problems in the code like syntax errors that cannot be handled at runtime.
• Exceptions: Problems that occur during execution, like trying to divide by zero or accessing a file that doesn’t exist. These can be handled.

Basic Syntax of try-except

try:
    # risky code
except SomeException:
    # handling code

Example

try:
    result = 10 / 0
except ZeroDivisionError:
    print("You can't divide by zero!")

In this example, a ZeroDivisionError is caught and handled, preventing a crash.

Using Multiple except Blocks

You can handle different types of exceptions separately by using multiple except blocks.

try:
    number = int(input("Enter a number: "))
    result = 10 / number
except ValueError:
    print("Invalid input. Please enter a number.")
except ZeroDivisionError:
    print("Cannot divide by zero.")

This approach allows more specific error messages and behaviors for different problems.

Using a Single except Block for Multiple Exceptions

try:
    # risky operations
except (TypeError, ValueError) as e:
    print("An error occurred:", e)

This technique is useful when multiple exceptions should result in the same handling behavior.

Using the else Clause

The else clause executes if no exception occurs in the try block.

try:
    result = 10 / 2
except ZeroDivisionError:
    print("Division error.")
else:
    print("Result is:", result)

This is helpful for separating normal logic from exception handling logic.

Using the finally Clause

The finally block always executes, regardless of whether an exception occurred.

try:
    f = open("sample.txt")
except FileNotFoundError:
    print("File not found.")
finally:
    print("Execution completed.")

The finally block is commonly used for cleanup actions like closing files or releasing resources.

Common Built-in Exceptions in Python

Accessing Exception Information

You can access exception details using the as keyword:

try:
    x = int("abc")
except ValueError as e:
    print("Error details:", e)

Nested try-except Blocks

try-except blocks can be nested within each other for granular error handling.

try:
    num = int(input("Enter a number: "))
    try:
        result = 10 / num
    except ZeroDivisionError:
        print("Cannot divide by zero.")
except ValueError:
    print("Invalid input.")

Raising Exceptions

You can use the raise keyword to throw an exception manually.

def check_age(age):
    if age < 0:
        raise ValueError("Age cannot be negative")
    return True

try:
    check_age(-5)
except ValueError as e:
    print("Caught an error:", e)

Custom Exception Classes

Creating a Custom Exception

class MyCustomError(Exception):
    pass

try:
    raise MyCustomError("Something went wrong!")
except MyCustomError as e:
    print("Handled custom error:", e)

Inheriting from Exception

All custom exceptions should inherit from Python’s Exception class. You can also add more functionality or attributes.

class AgeError(Exception):
    def __init__(self, age, message="Invalid age"):
        self.age = age
        self.message = message
        super().__init__(self.message)

try:
    raise AgeError(-3)
except AgeError as e:
    print(f"AgeError: {e.message} (Age: {e.age})")

Best Practices for Exception Handling

• Catch specific exceptions instead of using a bare except.
• Use finally for cleanup actions.
• Don’t suppress exceptions without reason.
• Log exceptions for debugging in production code.
• Use custom exceptions for application-specific errors.
• Keep the try block minimal—only wrap code that might fail.

Logging Exceptions

Use the logging module for production-level exception handling:

import logging

try:
    1 / 0
except ZeroDivisionError as e:
    logging.error("Exception occurred", exc_info=True)

This will log a detailed traceback to the console or file.

Real-World Scenarios

File Handling

try:
    with open('data.txt', 'r') as f:
        content = f.read()
except FileNotFoundError:
    print("The file was not found.")
finally:
    print("File operation complete.")

Input Validation

try:
    age = int(input("Enter your age: "))
    if age < 0:
        raise ValueError("Age must be positive")
except ValueError as e:
    print("Input error:", e)

Database Connection

try:
    connection = db.connect()
except ConnectionError as e:
    print("Failed to connect:", e)
finally:
    db.close()

Advanced: Exception Chaining

Use raise from to indicate that one exception was raised while handling another:

try:
    int("abc")
except ValueError as e:
    raise RuntimeError("Parsing failed") from e

Using Assertions

Assertions are used for debugging by testing assumptions. If the assertion fails, an AssertionError is raised.

assert 2 + 2 == 4
assert 1 == 0, "Math error!"

Exception handling using try-except blocks is a vital part of Python programming. It allows programs to deal with unexpected situations gracefully, improving reliability and user experience. By understanding how to handle exceptions effectively—using try, except, else, finally, raising custom exceptions, and logging errors—you can write Python applications that are not only functional but also robust and user-friendly. Mastering exception handling is key to becoming a proficient Python developer.