Python Exceptions — Language Specification¶

# BaseException attributes (always available):
exception.args          # tuple of constructor arguments
exception.__traceback__ # traceback object or None
exception.__context__   # implicitly chained exception (or None)
exception.__cause__     # explicitly chained exception (or None)
exception.__suppress_context__  # True if 'from' was used (or from None)
exception.__notes__     # list of note strings (Python 3.11+, PEP 678)

class MyError(Exception):
    def __init__(self, message: str, code: int = 0):
        super().__init__(message)
        self.code = code

    def __str__(self) -> str:
        return f"[{self.code}] {super().__str__()}"

object.__enter__(self)  -> value    # called by 'with'; result bound by 'as'
object.__exit__(self, exc_type, exc_val, exc_tb) -> bool | None
# If __exit__ returns a truthy value, the exception is suppressed.
# Called even if no exception occurred (exc_type=None).

ExceptionGroup(message: str, exceptions: Sequence[Exception])
BaseExceptionGroup(message: str, exceptions: Sequence[BaseException])

# Methods:
eg.exceptions   # tuple of contained exceptions
eg.subgroup(predicate)   # returns new group with matching exceptions
eg.split(predicate)      # returns (matching_group, rest_group)
eg.derive(exceptions)    # returns new group with same message but new exceptions

def risky():
    try:
        raise ValueError("original")
    finally:
        return 42   # silently discards the ValueError!

result = risky()
print(result)   # 42 — ValueError was swallowed

try:
    raise ValueError("test")
except ValueError as e:
    print(e)   # test
# print(e)    # NameError: name 'e' is not defined

# Workaround if you need e after the block:
try:
    raise ValueError("test")
except ValueError as e:
    err = e
print(err)   # test  — safe because 'err' is not auto-deleted

# AVOID: bare except catches KeyboardInterrupt, SystemExit, etc.
try:
    ...
except:
    pass   # BAD: catches ctrl+c, sys.exit(), etc.

# PREFER:
try:
    ...
except Exception:
    pass   # catches only non-system exceptions

def fetch_user(user_id):
    try:
        data = {}
        return data[user_id]
    except KeyError as e:
        raise ValueError(f"User {user_id!r} not found") from e

try:
    fetch_user("alice")
except ValueError as e:
    print(e)                # User 'alice' not found
    print(e.__cause__)      # 'alice'   (KeyError)
    print(e.__context__)    # same as __cause__ here

try:
    raise ValueError("internal error")
except ValueError:
    raise RuntimeError("public error") from None
# The traceback shows only RuntimeError; internal ValueError is hidden

try:
    x = int("abc")
except ValueError as e:
    e.add_note("Input must be a decimal integer string")
    raise

try:
    raise ExceptionGroup("multiple errors", [
        ValueError("bad value"),
        TypeError("wrong type"),
        KeyError("missing key"),
    ])
except* ValueError as eg:
    print(f"Caught ValueErrors: {eg.exceptions}")
except* TypeError as eg:
    print(f"Caught TypeErrors: {eg.exceptions}")
# KeyError propagates as a new ExceptionGroup

import sys
from contextlib import suppress

# ----------------------------------------------------------------
# 1. Basic try / except
# ----------------------------------------------------------------
try:
    result = 10 / 0
except ZeroDivisionError as e:
    print(f"Caught: {e}")   # Caught: division by zero


# ----------------------------------------------------------------
# 2. Multiple except clauses
# ----------------------------------------------------------------
def parse_int(s):
    try:
        return int(s)
    except ValueError:
        print(f"Not a valid integer: {s!r}")
    except TypeError:
        print(f"Expected str, got {type(s).__name__}")
    return None

print(parse_int("42"))    # 42
print(parse_int("abc"))   # Not a valid integer: 'abc'
print(parse_int(None))    # Expected str, got NoneType


# ----------------------------------------------------------------
# 3. except with tuple of types
# ----------------------------------------------------------------
def safe_lookup(d, key):
    try:
        return d[key]
    except (KeyError, TypeError) as e:
        print(f"Lookup failed: {e}")
        return None

safe_lookup({"a": 1}, "b")   # Lookup failed: 'b'
safe_lookup(None, "key")      # Lookup failed: 'NoneType' object is not subscriptable


# ----------------------------------------------------------------
# 4. try / except / else / finally
# ----------------------------------------------------------------
def read_file(path):
    f = None
    try:
        f = open(path)
        data = f.read()
    except FileNotFoundError:
        print(f"File not found: {path}")
        data = None
    else:
        print(f"Successfully read {len(data)} bytes")
    finally:
        if f:
            f.close()
            print("File closed")
    return data


# ----------------------------------------------------------------
# 5. raise with custom exception
# ----------------------------------------------------------------
class ValidationError(ValueError):
    def __init__(self, field: str, message: str):
        super().__init__(f"Validation error on '{field}': {message}")
        self.field = field

def validate_age(age):
    if not isinstance(age, int):
        raise TypeError(f"age must be int, got {type(age).__name__}")
    if age < 0 or age > 150:
        raise ValidationError("age", f"{age} is out of range [0, 150]")
    return age

try:
    validate_age(-5)
except ValidationError as e:
    print(e)       # Validation error on 'age': -5 is out of range [0, 150]
    print(e.field) # age


# ----------------------------------------------------------------
# 6. Exception chaining
# ----------------------------------------------------------------
class DatabaseError(Exception):
    pass

def get_user(user_id: int):
    try:
        users = {}
        return users[user_id]
    except KeyError as e:
        raise DatabaseError(f"User {user_id} not found") from e

try:
    get_user(42)
except DatabaseError as e:
    print(e)              # User 42 not found
    print(e.__cause__)    # 42  (KeyError)


# ----------------------------------------------------------------
# 7. raise from None (suppress context)
# ----------------------------------------------------------------
def public_api(x):
    try:
        return 1 / x
    except ZeroDivisionError:
        raise ValueError("x must not be zero") from None

try:
    public_api(0)
except ValueError as e:
    print(e)                  # x must not be zero
    print(e.__cause__)        # None  (suppressed)
    print(e.__context__)      # ZeroDivisionError (still set)
    print(e.__suppress_context__)  # True


# ----------------------------------------------------------------
# 8. bare raise (re-raise)
# ----------------------------------------------------------------
def process(data):
    try:
        return int(data)
    except ValueError:
        print("Logging error...")
        raise   # re-raise preserves original traceback


# ----------------------------------------------------------------
# 9. contextlib.suppress
# ----------------------------------------------------------------
with suppress(FileNotFoundError):
    open("/nonexistent/file.txt")
print("Continued after suppressed exception")


# ----------------------------------------------------------------
# 10. add_note (Python 3.11+)
# ----------------------------------------------------------------
try:
    raise ValueError("connection failed")
except ValueError as e:
    e.add_note("Check that the server is running")
    e.add_note("Verify the port number is correct")
    raise
# The notes appear in the traceback output


# ----------------------------------------------------------------
# 11. ExceptionGroup (Python 3.11+)
# ----------------------------------------------------------------
def run_all(tasks):
    errors = []
    results = []
    for task in tasks:
        try:
            results.append(task())
        except Exception as e:
            errors.append(e)
    if errors:
        raise ExceptionGroup("task failures", errors)
    return results

try:
    def bad1(): raise ValueError("v1")
    def bad2(): raise TypeError("t1")
    def good(): return 42

    run_all([bad1, bad2, good])
except* ValueError as eg:
    print(f"ValueErrors: {[str(e) for e in eg.exceptions]}")
except* TypeError as eg:
    print(f"TypeErrors: {[str(e) for e in eg.exceptions]}")


# ----------------------------------------------------------------
# 12. sys.exception() (Python 3.12+)
# ----------------------------------------------------------------
try:
    raise RuntimeError("test")
except RuntimeError:
    exc = sys.exception()
    print(f"Active exception: {exc}")   # Active exception: test