Python Exceptions — Professional Level¶

import dis
import sys

def example():
    try:
        x = 1
    except ValueError:
        x = 2

# In 3.11+, dis shows the exception table
dis.dis(example)
# The exception table is printed at the end:
# ExceptionTable:
#   2 to 6 -> 8 [0]

# Inspect the exception table directly
code = example.__code__
print("Exception table entries:")
# co_exceptiontable is a bytes object in 3.11+
if hasattr(code, 'co_exceptiontable'):
    print(f"  Raw bytes: {code.co_exceptiontable!r}")
    print(f"  Length: {len(code.co_exceptiontable)} bytes")

import dis

def basic_try():
    try:
        x = int("123")
    except ValueError:
        x = 0
    return x

dis.dis(basic_try)

def full_try():
    try:
        result = 1 / 1
    except ZeroDivisionError:
        result = 0
    else:
        result *= 2
    finally:
        print(result)
    return result

dis.dis(full_try)

import sys

def inspect_exception():
    try:
        try:
            raise ValueError("original")
        except ValueError as original:
            raise TypeError("wrapper") from original
    except TypeError as wrapper:
        print(f"Exception type: {type(wrapper).__name__}")
        print(f"args: {wrapper.args}")
        print(f"__cause__: {wrapper.__cause__}")
        print(f"__context__: {wrapper.__context__}")
        print(f"__suppress_context__: {wrapper.__suppress_context__}")
        print(f"__traceback__: {wrapper.__traceback__}")
        print(f"Memory size: {sys.getsizeof(wrapper)} bytes")

        # Traceback chain
        tb = wrapper.__traceback__
        while tb is not None:
            frame = tb.tb_frame
            print(f"  Frame: {frame.f_code.co_name} at line {tb.tb_lineno}")
            tb = tb.tb_next

inspect_exception()

def level_3():
    raise ValueError("bottom")

def level_2():
    level_3()

def level_1():
    level_2()

try:
    level_1()
except ValueError as e:
    tb = e.__traceback__
    # tb points to level_1's frame
    # tb.tb_next points to level_2's frame
    # tb.tb_next.tb_next points to level_3's frame (where raise happened)

# Python 3.11+ shows exact expression that caused the error
x = {"a": {"b": {"c": None}}}
result = x["a"]["b"]["c"]["d"]
#        ~~~~~~~~~~~~~~~^^^^^
# TypeError: 'NoneType' object is not subscriptable

# This is WHY order matters:
try:
    raise UnicodeDecodeError("utf-8", b"", 0, 1, "bad")
except ValueError:
    print("Caught as ValueError")  # This runs!
except UnicodeDecodeError:
    print("Caught as UnicodeDecodeError")  # Never reached

import threading
import sys

def thread_func(thread_id):
    """Each thread has independent exception state."""
    try:
        if thread_id % 2 == 0:
            raise ValueError(f"Thread {thread_id}")
        else:
            raise TypeError(f"Thread {thread_id}")
    except (ValueError, TypeError) as e:
        # sys.exc_info() returns THIS thread's exception
        exc_type, exc_value, exc_tb = sys.exc_info()
        print(f"Thread {thread_id}: {exc_type.__name__}: {exc_value}")

threads = [threading.Thread(target=thread_func, args=(i,)) for i in range(4)]
for t in threads:
    t.start()
for t in threads:
    t.join()

import threading
import time

def worker():
    try:
        raise ValueError("test")
    except ValueError:
        # GIL is held during Python bytecode
        time.sleep(0.1)  # GIL released during sleep → other threads can run
        print("Done handling")

# Python 3 compiles this:
try:
    raise ValueError("test")
except ValueError as e:
    pass

# Into approximately:
try:
    raise ValueError("test")
except ValueError as e:
    try:
        pass
    finally:
        del e  # Break reference cycle!

import sys
import tracemalloc

tracemalloc.start()

# Measure memory cost of exception creation
before = tracemalloc.get_traced_memory()

exceptions = []
for i in range(10_000):
    try:
        raise ValueError(f"Error #{i}")
    except ValueError as e:
        # Storing exceptions retains tracebacks and frames
        exceptions.append(e)

after = tracemalloc.get_traced_memory()
print(f"Memory for 10,000 exceptions: {(after[0] - before[0]) / 1024:.1f} KB")
print(f"Per exception: {(after[0] - before[0]) / 10_000:.0f} bytes")

# Clear tracebacks to free memory
for e in exceptions:
    e.__traceback__ = None
after_clear = tracemalloc.get_traced_memory()
print(f"After clearing tracebacks: {(after_clear[0] - before[0]) / 1024:.1f} KB")

tracemalloc.stop()

import logging

logger = logging.getLogger(__name__)

def process_batch(items: list) -> list:
    results = []
    errors = []

    for item in items:
        try:
            results.append(transform(item))
        except TransformError as e:
            # Log the traceback, then clear it to free memory
            logger.exception("Transform failed for item %s", item)
            e.__traceback__ = None  # Free the traceback and frame references
            errors.append((item, str(e)))

    return results

import dis

def except_star_example():
    try:
        raise ExceptionGroup("group", [ValueError("a"), TypeError("b")])
    except* ValueError as eg:
        print(f"ValueErrors: {eg.exceptions}")
    except* TypeError as eg:
        print(f"TypeErrors: {eg.exceptions}")

dis.dis(except_star_example)

# Manual equivalent of what except* does:
eg = ExceptionGroup("group", [ValueError("a"), TypeError("b"), ValueError("c")])

# except* ValueError:
match, rest = eg.split(ValueError)
print(f"Matched: {match}")   # ExceptionGroup('group', [ValueError('a'), ValueError('c')])
print(f"Rest: {rest}")       # ExceptionGroup('group', [TypeError('b')])