Understanding Exceptions

Exceptions are runtime errors that disrupt the normal flow of a program. These disruptions can occur for various reasons, such as dividing by zero, accessing an out-of-bounds index, missing files, network failures, type mismatches, undefined variables, missing dictionary keys, or insufficient disk space.

Without proper handling, these errors will crash the application. Implementing robust exception handling mechanisms increases application resilience and fault tolerance, preventing unexpected terminations due to invalid user input or runtime issues. Furthermore, exceptions can be caught to display user-friendly error messages instead of raw stack traces.

The ability to debug, quickly locate, and resolve these issues is a critical skill for software developers.

Common Exception Manifestations

>>> numerator, denominator = 10, 0
>>> result = numerator / denominator
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero

>>> print(undefined_var)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'undefined_var' is not defined

>>> '5' + 5
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can only concatenate str (not "int") to str

>>> stream = open('missing_file.data', 'rb')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
FileNotFoundError: [Errno 2] No such file or directory: 'missing_file.data'

Core Concepts

Syntax errors and logical flaws are not considered exceptions, although syntax mistakes often lead to runtime exceptions (like misspelling a variable name causing a NameError).

An exception represents an action taken outside the normal control flow due to an error. When Python encounters an error, the interpreter determines that the current flow cannot continue, resulting in an exception.

Exception handling consists of two phases: the error occurrence that triggers the exception, and the detection and resolution of that exception.

While Python raises exceptions automatically upon errors, developers can also trigger them explicitly using the raise keyword.

Role of Exception Handling

• Enhancing application stability and fault tolerance.
• Translating cryptic system errors into clear, user-friendly messages.

Best Practices

• Avoid using exceptions for standard control flow where if...else conditions would suffice.
• Do not overuse exception handling; apply it only where necessary.
• Catch exceptions precisely, and design specific handling logic for different exception types.

Python Exception Classes

Python features a built-in hierarchy of exception classes. Developers can extend these built-in classes to create custom exceptions tailored to specific application needs.

class InsufficientLengthError(Exception):
    def __init__(self, current_len, required_len):
        super().__init__()
        self.current_len = current_len
        self.required_len = required_len

try:
    user_input = input('Enter a value: ')
    if len(user_input) < 5:
        raise InsufficientLengthError(len(user_input), 5)
except EOFError:
    print('End of file signal received.')
except InsufficientLengthError as err:
    print(f'Length is {err.current_len}, but minimum required is {err.required_len}')
else:
    print('Input accepted successfully.')

class CustomAppError(Exception):
    def __init__(self, error_val):
        self.error_val = error_val
    def __str__(self):
        return repr(self.error_val)

try:
    raise CustomAppError(3 * 3)
except CustomAppError as e:
    print(f'Custom error triggered with value: {e.error_val}')

When a module requires multiple distinct exceptions, it is best practice to define a base exception class for the module, followed by derived classes for specific errors.

class FrameworkBaseError(Exception):
    pass

class DataValidationError(FrameworkBaseError):
    def __init__(self, expr, msg):
        self.expr = expr
        self.msg = msg

class StateChangeError(FrameworkBaseError):
    def __init__(self, prev_state, next_state, msg):
        self.prev_state = prev_state
        self.next_state = next_state
        self.msg = msg

Common Exception Handling Structures

try...except Structure

Code that might fail is placed inside the try block, while the error handling logic resides in the except block.

while True:
    raw_val = input('Provide an integer: ')
    try:
        parsed_val = int(raw_val)
        print(f'Valid integer received: {parsed_val}')
        break
    except Exception as ex:
        print('Invalid input detected.')

To capture detailed information, assign the exception instance to a variable using the as keyword.

try:
    raise Exception('alpha', 'beta')
except Exception as err_instance:
    print(type(err_instance))
    print(err_instance.args)
    a, b = err_instance.args
    print(f'First arg: {a}')
    print(f'Second arg: {b}')

try...except...else Structure

If an exception occurs in the try block, the except block executes. If no exception occurs, the else block runs.

cities = ['London', 'Tokyo', 'Berlin', 'Sydney']
while True:
    idx_input = input('Enter city index: ')
    try:
        idx = int(idx_input)
        print(cities[idx])
    except IndexError:
        print('Index out of bounds. Try again.')
    else:
        break

import sys

for file_path in sys.argv[1:]:
    try:
        stream = open(file_path, 'r')
    except IOError:
        print(f'Failed to open {file_path}')
    else:
        print(f'{file_path} contains {len(stream.readlines())} lines')
        stream.close()

Multiple except Blocks

A try block can trigger different types of exceptions, which can be handled by multiple except blocks.

try:
    numerator = input('Enter numerator: ')
    denominator = input('Enter denominator: ')
    result = float(numerator) / float(denominator)
except ZeroDivisionError:
    print('Cannot divide by zero.')
except TypeError:
    print('Both operands must be numbers.')
except NameError:
    print('Undefined variable encountered.')
else:
    print(f'{numerator} / {denominator} = {result}')

Multiple exception types can be caught together using a tuple.

import sys

try:
    f = open('config.cfg')
    s = f.readline()
    i = int(s.strip())
    f.close()
except (OSError, ValueError, RuntimeError, NameError):
    pass

try...except...finally Structure

The finally block executes unconditionally, regardless of whether an exception occurred. It is typically used for cleanup operations, such as releasing resources.

try:
    file_handle = open('data.log', 'r')
    content = file_handle.readline()
    print(content)
finally:
    file_handle.close()

If an exception is unhandled within the try or else blocks, it is re-raised after the finally block completes. Be cautious when using return inside a finally block, as it can suppress exceptions or override the original return value.

def calculate_ratio(val1, val2):
    try:
        return val1 / val2
    except:
        pass
    finally:
        return -1  # Overwrites the actual return value

print(calculate_ratio(10, 2))  # Outputs -1, not 5.0

Comprehensive Structure

Python allows combining multiple except blocks, an else block, and a finally block in a single structure.

def safe_divide(x, y):
    try:
        print(x / y)
    except ZeroDivisionError:
        print('ZeroDivisionError caught')
    except TypeError:
        print('TypeError caught')
    else:
        print('Division successful')
    finally:
        print('Cleanup executed')

Assertions and Context Managers

Assertions

The assert statement verifies if an expression evaluates to True. If it evaluates to False, it raises an AssertionError. Assertions are intended for debugging and are ignored when the Python interpreter is run with the -O (optimize) flag.

x_val = 10
y_val = 20
assert x_val == y_val, 'x_val must equal y_val'

Context Managers

The with statement guarantees that resources are automatically released once the block completes, even if an exception occurs.

with open('document.txt') as f:
    for line in f:
        print(line, end="")

Tracing Exceptions with sys

When exceptions occur, Python provides a full traceback. For more concise error extraction, the sys module can be used to retrieve the last exception.

import sys

try:
    1 / 0
except:
    err_info = sys.exc_info()
    print(err_info)
    # (<class 'ZeroDivisionError'>, ZeroDivisionError('division by zero'), <traceback object at 0x...>)

While sys.exc_info() directly identifies the exception type and value, it lacks the exact code location. The traceback module provides detailed stack trace information.

import sys
import traceback

def layer_a(): 1 / 0
def layer_b(): layer_a()
def layer_c(): layer_b()

try:
    layer_c()
except:
    exc_type, exc_value, exc_tb = sys.exc_info()
    traceback.print_exception(exc_type, exc_value, exc_tb, limit=3)
    print(exc_value)
    traceback.print_tb(exc_tb)

Debugging with IDLE

To debug in Python's default IDE, open the "Debug" menu and select "Debugger" to open the debug control window. Run the target script, and step through execution via the debugger interface.

Debugging with pdb

The pdb module is Python's built-in interactive debugger. It supports setting breakpoints, stepping through code, inspecting stack frames, and evaluating expressions dynamically.

Interactive Mode

import pdb

def compute():
    count = 42
    print(count)

pdb.runcall(compute)
# > <string>(2)compute()
# (Pdb) n
# > <string>(3)compute()
# (Pdb) p count
# 42

Embedded Breakpoints

Insert pdb.set_trace() directly into the source code to pause execution and launch the debugger at that specific point.

import pdb

target = 49
pdb.set_trace()  # Execution pauses here
for divisor in range(2, target):
    if target % divisor == 0:
        print('Not prime')
        break
else:
    print('Prime number')

Script Mode

Initiate debugging from the command line interface by executing the script as a module: python -m pdb script_name.py. This automatically enters the debugging environment before execution begins.