raise / Custom Exception Classes

# Raise an exception
raise ExceptionClass("message")

# Chain a new exception with a cause
raise NewException from OriginalException

# Re-raise the current exception (inside an except block)
raise

# Define a custom exception class
class MyError(Exception):
    pass

class MyDetailedError(Exception):
    def __init__(self, message, code):
        super().__init__(message)
        self.code = code

# raise: basic exception raising
def divide(a, b):
    if b == 0:
        raise ZeroDivisionError("Division by zero is not allowed")
    return a / b

try:
    divide(10, 0)
except ZeroDivisionError as e:
    print(e)    # Division by zero is not allowed

# raise from: exception chaining (preserving the cause)
def load_config(path):
    try:
        with open(path) as f:
            return f.read()
    except FileNotFoundError as e:
        raise RuntimeError(f"Failed to load config file: {path}") from e

try:
    load_config('config.json')
except RuntimeError as e:
    print(e)            # Failed to load config file: config.json
    print(e.__cause__)  # The original FileNotFoundError

# Simple custom exception class
class ValidationError(Exception):
    pass

class AgeError(ValidationError):
    pass

def validate_age(age):
    if not isinstance(age, int):
        raise TypeError(f"Age must be an integer: {type(age).__name__}")
    if age < 0:
        raise AgeError(f"Age must be 0 or greater: {age}")
    if age > 150:
        raise AgeError(f"Age is too large: {age}")
    return age

try:
    validate_age(-5)
except AgeError as e:
    print(f"Age error: {e}")

# Custom exception with additional details
class HttpError(Exception):
    def __init__(self, message, status_code):
        super().__init__(message)
        self.status_code = status_code

    def __str__(self):
        return f"[{self.status_code}] {super().__str__()}"

def fetch(url):
    if not url.startswith('https://'):
        raise HttpError("Only HTTPS is allowed", 400)

try:
    fetch('http://example.com')
except HttpError as e:
    print(e)                    # [400] Only HTTPS is allowed
    print(e.status_code)        # 400

Using custom exception classes lets you represent different kinds of errors in code. For example, a web application might use HttpError while a validation routine uses ValidationError, allowing the caller to catch only the exceptions it needs to handle.

The raise NewException from OldException syntax is called exception chaining. It converts a low-level exception into a higher-level one while preserving the original cause in the __cause__ attribute. If you use raise without from, Python automatically stores the original exception in __context__, but using from explicitly is recommended when the conversion is intentional.