Handling Python Exceptions

Python
# Raise the most specific built-in exception that fits
def get_item(items, index):
    if not isinstance(index, int):
        raise TypeError(f"index must be int, got {type(index).__name__}")
    if index < 0 or index >= len(items):
        raise IndexError(f"index {index} out of range for length {len(items)}")
    return items[index]

# Catch specific exceptions, not bare except
try:
    value = get_item(my_list, user_input)
except (TypeError, IndexError) as e:
    logger.error(f"Invalid access: {e}")
    raise

Progress:

• Identify what error condition needs signaling
• Check if a built-in exception fits exactly
• If not, create a custom exception subclassing the closest built-in or Exception
• Raise with a clear, actionable message
• Catch at the appropriate level of specificity
• Use finally/context managers for cleanup, not exception handling for control flow

Step 1: Choose the right built-in exception

Core hierarchy (all inherit from BaseException):

BaseException
 ├── SystemExit
 ├── KeyboardInterrupt
 ├── GeneratorExit
 └── Exception
      ├── StopIteration / StopAsyncIteration
      ├── ArithmeticError
      │    ├── ZeroDivisionError
      │    ├── OverflowError
      │    └── FloatingPointError
      ├── AssertionError
      ├── AttributeError
      ├── BufferError
      ├── EOFError
      ├── ImportError
      │    └── ModuleNotFoundError
      ├── LookupError
      │    ├── IndexError
      │    └── KeyError
      ├── MemoryError
      ├── NameError
      │    └── UnboundLocalError
      ├── OSError
      │    ├── FileNotFoundError
      │    ├── FileExistsError
      │    ├── PermissionError
      │    ├── TimeoutError
      │    ├── InterruptedError
      │    ├── IsADirectoryError / NotADirectoryError
      │    └── ConnectionError (BrokenPipe/ConnectionReset/Refused/Aborted)
      ├── ReferenceError
      ├── RuntimeError
      │    ├── NotImplementedError
      │    ├── RecursionError
      │    └── PythonFinalizationError
      ├── SyntaxError
      │    └── IndentationError → TabError
      ├── SystemError
      ├── TypeError
      ├── ValueError
      │    └── UnicodeError (UnicodeDecodeError/EncodeError/TranslateError)
      └── Warning (DeprecationWarning, UserWarning, etc.)

Selection guide:

• Wrong type passed → TypeError
• Right type, invalid value → ValueError
• Missing key/index → KeyError / IndexError
• Missing attribute/name → AttributeError / NameError
• Abstract method not implemented → NotImplementedError
• Invalid state/logic error not covered elsewhere → RuntimeError
• File/OS-level failure → appropriate OSError subclass

Step 2: Only catch Exception, never BaseException

BaseException includes SystemExit and KeyboardInterrupt — catching it breaks Ctrl-C and sys.exit(). Bare except: is equivalent to except BaseException: — avoid it.

Step 3: Use exception chaining for context

Python
try:
    parse_config(path)
except FileNotFoundError as e:
    raise ConfigError(f"Cannot load config from {path}") from e

# Suppress chaining when the original is irrelevant noise
raise ConfigError("bad config") from None

Step 4: Custom exceptions — subclass meaningfully

Python
class AppError(Exception):
    """Base class for this application's exceptions."""

class ValidationError(AppError, ValueError):
    """Raised when input fails validation. Also catchable as ValueError."""
    def __init__(self, field, message):
        self.field = field
        super().__init__(f"{field}: {message}")

Define one base exception per package/library so callers can catch broadly (except AppError) or narrowly.

Step 5: Use exception groups for multiple concurrent errors (3.11+)

Python
try:
    results = run_concurrent_tasks()
except* ValueError as eg:
    for err in eg.exceptions:
        log_validation_error(err)
except* ConnectionError as eg:
    for err in eg.exceptions:
        log_network_error(err)

Raise multiple related errors together with ExceptionGroup("summary", [err1, err2]).

Example 1: Input: Function receives a negative value where only non-negative is valid. Output:

Python
def set_quantity(n):
    if not isinstance(n, int):
        raise TypeError(f"quantity must be int, got {type(n).__name__}")
    if n < 0:
        raise ValueError(f"quantity must be non-negative, got {n}")

Example 2: Input: Catching a file read error and re-raising with context. Output:

Python
try:
    with open(path) as f:
        data = f.read()
except FileNotFoundError as e:
    raise RuntimeError(f"Required file missing: {path}") from e

Example 3: Input: Abstract base class method that subclasses must implement. Output:

Python
class Shape:
    def area(self):
        raise NotImplementedError("Subclasses must implement area()")