Errors and Context Managers

Write a class that inherits from Exception; an empty body with a docstring is enough. Name it with an Error suffix, give the module one base class of its own, and derive every specific error from that base.

EAFP means easier to ask forgiveness than permission: attempt the operation and catch the exception it raises. LBYL means look before you leap: check the preconditions with an if first. Python favours EAFP, because a separate guard can drift away from the operation it protects.

BaseException is the root of Python's exception tree; Exception is the branch that ordinary errors inherit from. SystemExit, KeyboardInterrupt and GeneratorExit sit outside Exception deliberately, so shutdown signals are not swept up with programming errors.

TypeError means the object is the wrong kind for the operation; ValueError means the type is right but the particular value is unusable. int([]) raises TypeError, int('twelve') raises ValueError.

Inside the except block call logging.exception(msg), or pass exc_info=True to any logging call, so the record carries the active exception and its traceback. traceback.format_exc() returns that same text as a string; logging str(exc) throws the stack away.

Each except* clause splits the group by type: the matching members arrive as a group, the rest move on to the next clause. Several clauses can run for one raise, and whatever stays unmatched is re-raised after the try statement.

ExceptionGroup is a built-in exception added in Python 3.11 that carries several exceptions at once in its exceptions tuple. asyncio.TaskGroup raises one when its child tasks fail, so no failure is silently discarded.

BaseExceptionGroup derives from BaseException and can hold any exception, including KeyboardInterrupt, SystemExit and asyncio.CancelledError. ExceptionGroup derives from Exception and rejects those with a TypeError. Constructing BaseExceptionGroup with only ordinary exceptions returns an ExceptionGroup.

subgroup(condition) returns a new group holding only the members that match, or None if none do. split(condition) returns both halves as a (matching, non_matching) pair, either of which may be None. Nesting, tracebacks and notes are preserved.

contextlib.asynccontextmanager decorates an async generator function that yields exactly once. Calling it builds an object for use with async with: everything before the yield is the setup, the yielded value is what as binds, and everything after the yield is the teardown.

contextlib.contextmanager decorates a generator function that yields exactly once. Everything before the yield runs on entry, the yielded value is what the as clause binds, and everything after the yield runs on exit.

Only cleanup. The with statement calls the manager's exit on the way out, so the file gets closed or the lock released, but the exception keeps travelling up unless exit deliberately returns a truthy value.

x is bound to whatever __enter__ returns, not to obj itself. Any object usable in a with statement must define both __enter__ and __exit__; __exit__ runs on the way out whether the block succeeded or raised.

They do the same thing: contextlib.suppress(FileNotFoundError) is the with-statement spelling of try/except FileNotFoundError: pass. It reads as deliberate rather than accidental, and since Python 3.12 it also strips matching exceptions out of an ExceptionGroup.

assert expr, msg raises AssertionError with msg when expr is falsy and does nothing otherwise. Starting the interpreter with -O, or with PYTHONOPTIMIZE set, removes every assert statement at compile time, so the check never runs.

assert is a statement, so those parentheses build a two-element tuple rather than passing two arguments. A non-empty tuple is always truthy, so the condition holds for every value of total and the assertion can never fire.

PYTHONOPTIMIZE=1 is equivalent to -O, so the compiler emits no bytecode for any assert statement and the row checks were never in the deployed program. Data arriving from a CSV file needs an explicit raise; assertions can only carry internal invariants.

Python ships default entries in warnings.filters that ignore DeprecationWarning everywhere except when it is reported from main, because the category targets developers rather than end users. Run with -W default::DeprecationWarning, PYTHONWARNINGS or -X dev to see it.

Python walks warnings.filters from the front and stops at the first entry whose message, category and module all match; that entry's action decides the outcome. filterwarnings and simplefilter insert at the front, so the newest entry is checked first.

The default warning action shows a message once per location — the text, category and reported line — and records that in a per-module registry, so later identical warnings from the same line are skipped entirely. Switch the filter to always to see every occurrence.

Escalate where someone can act and observe where they cannot: -W error scoped to your own modules in CI, warnings recorded and aggregated in staging, plain defaults in production. Libraries emit warnings; only applications configure filters.

A bare except: catches every BaseException subclass, including KeyboardInterrupt, SystemExit and GeneratorExit. except Exception stops one level lower, so Ctrl-C and an exit request still propagate. Catch Exception, or a narrower type, instead.

A return inside finally overrides everything already in flight: the try block's return value, a pending break or continue, and even an exception on its way out. The function returns the finally value, and the exception disappears silently.

It is catching SystemExit. sys.exit(1) does not end the process directly -- it raises SystemExit, which derives from BaseException rather than Exception, so a bare except: or except BaseException intercepts the exit request and execution simply continues.

A finally block runs while the exception is still in flight and re-raises it only when the block ends normally. A break or continue leaves the block early, so the held exception is dropped and the loop simply carries on.

The loop's handler catches BaseException, so KeyboardInterrupt is treated as a retryable failure and each Ctrl-C only aborts the current attempt. Narrow the handler to Exception, or keep it broad, run cleanup, and end it with a bare raise.

Not by itself. The del statement removes a name binding and drops one reference. CPython runs the object's del finalizer only when the last reference to that object disappears, which may be later, or during cycle collection, or never.

A bound method holds a strong reference to its instance, so storing obj.close as the callback keeps obj permanently reachable. The object is never collected, and the finalizer only runs during the interpreter's exit pass. Capture the raw resource instead.

weakref.finalize registers func as a cleanup callback for obj and returns a finalizer object. Python calls func exactly once: when obj is garbage collected, or at interpreter exit if obj is still alive. Registering does not keep obj alive.

It never reaches the surrounding code. CPython hands it to sys.unraisablehook, whose default prints an "Exception ignored in" traceback to stderr and returns. The rest of the finalizer is skipped, and the program carries on as if nothing failed.

Call the finalizer object to run the cleanup now and mark it dead; call its detach() method to cancel it so it never runs; read its alive property to see whether it is still pending. peek() inspects the registration without cancelling it.

logging.exception() logs at ERROR level and attaches the traceback of the exception currently being handled, because it passes exc_info=True for you. logging.error() logs only the message unless you pass exc_info=True yourself.

So callers depend on your abstraction rather than on the library. If a database driver's error class escapes your function, every caller must import that driver to catch it, and replacing the driver breaks all of them.

Pickle does not serialize a class body. It stores the class by reference -- module name plus qualified name -- and the receiving process re-imports that module and looks the name up. If the lookup fails there, your exception never reconstructs.

So a caller can write one except PackageError to mean 'this library failed' without resorting to except Exception. The base marks the package's public error surface; the subclasses let callers who care be specific.

A re-raised exception keeps travelling with its full traceback, so every layer that logs it emits a complete report of the same failure. One error becomes N log records, N alerts and N counted errors. Log it once, where it stops.