Exceptions in Python originate from two primary mechanisms: automatic interpreter detection of invalid runtime operations, and explicit developer intervention when preconditions are violated. While the runtime engine automatically generates errors for invalid operations (e.g., dividing by zero triggers ZeroDivisionError), programmers intentionally halt execution using the raise statement.

import os

def load_configuration(file_path):
    if not os.path.exists(file_path):
        raise FileNotFoundError(f"Configuration file not found at {file_path}")

Frequently Encountered Exception Types

Understanding standard error classes accelerates debugging. Below are core exceptions and typical resolution strategies:

• SyntaxError: The parser encounters invalid language structure. Verify indentation, missing parentheses, or incorrect keyword usage.
• NameError: A variable or function name is referenced before assignment or outside its scope. Confirm spelling and variable lifecycle.
• IndexError: Sequence access exceeds valid bounds. Validate list/tuple lengths before indexing.
• KeyError: Dictionary lookup fails because the specified key is absent. Utilize .get() or verify key existence with in.
• TypeError: An operation receives an inappropriate object type. Ensure operands match the operator requirements or convert types explicitly.
• ValueError: A function receives a correctly typed argument but with an unacceptable value (e.g., passing non-numeric text to int()). Validate input ranges and formats.
• AttributeError: Attempting to access or invoke a non-existent object attribute or method. Verify the object class definition and inheritance chain.
• OSError (formerly IOError): System-level input/output failures, typically involving file paths, permissions, or network sockets. Verify paths, access rights, and device availability.

Exception Handling Control Structures

Python provides several constructs to intercept and manage runtime failures gracefully.

Basic Interception

The fundamental try...except block isolates risky operations. If an error occurs, execution jumps to the matching handler.

def process_data(input_str):
    try:
        numeric_val = float(input_str)
        result = 100 / numeric_val
        print(f"Calculated result: {result}")
    except ZeroDivisionError:
        print("Division by zero is not permitted.")

Executing on Success

Attaching an else clause ensures that certain logic runs only when the try block completes without raising any exceptions.

def validate_and_parse(data_json):
    try:
        import json
        parsed = json.loads(data_json)
        print("JSON parsing initiated.")
    except json.JSONDecodeError:
        print("Invalid JSON format detected.")
    else:
        print("Parsing completed successfully, data is ready for use.")

Handling Multiple Specific Exceptions

You can define sequential except clauses to route different error types to specialized handlers. Order matters; more specific exceptions should precede general ones.

def fetch_resource(url, timeout_sec):
    try:
        if timeout_sec < 0:
            raise ValueError("Timeout cannot be negative.")
        print(f"Connecting to {url}...")
    except ValueError as ve:
        print(f"Configuration error: {ve}")
    except Exception as generic:
        print(f"Unexpected failure: {generic}")
    else:
        print("Connection parameters are valid.")

Grouping Exception Types

When multiple error conditions require identical handling logic, specify them as a tuple within a single except statement.

def calculate_metrics(numerator, denominator):
    try:
        outcome = int(numerator) / int(denominator)
        print(f"Metric: {outcome}")
    except (ValueError, ZeroDivisionError) as calc_err:
        print(f"Calculation failed due to invalid operands: {calc_err}")

Guaranteed Cleanup

The finally block executes regardless of whether an exception was raised, caught, or bypassed. Its ideal for releasing resources like file handles or database connections.

def read_secure_file(path):
    resource_handle = None
    try:
        resource_handle = open(path, 'r')
        content = resource_handle.read()
        print(f"Loaded {len(content)} bytes.")
    except OSError as io_issue:
        print(f"System I/O failure: {io_issue}")
    finally:
        if resource_handle:
            resource_handle.close()
            print("Resource handle safely released.")

Catching All Exceptions

While targeting specific errors is preferred, except Exception serves as a catch-all for unforeseen runtime issues. Always alias the caught error to inspect diagnostic information.

def execute_pipeline(task_data):
    try:
        print("Starting pipeline execution...")
        step1 = int(task_data.get('priority'))
        step2 = task_data['missing_key']
    except Exception as err:
        print(f"Pipeline halted. Reason: {type(err).__name__} -> {err}")
    else:
        print("Pipeline finished without interruptions.")