Exceptions

It's a mechanism to react to runtime errors: try/except catches them, raise throws one. You raise an instance (or class, auto-constructed) of BaseException or a subclass. Uncaught ones propagate up.

Subclass Exception (not BaseException), conventionally naming it with an Error suffix. You may add attributes or a custom __init__ to carry data. Then raise MyError("msg") like any built-in exception.

BaseException is the root. Exception derives from it and is the base for ordinary errors. But SystemExit, KeyboardInterrupt, and GeneratorExit derive from BaseException directly, so except Exception does not catch them.

The finally block always runs — whether the try succeeds, raises, or returns — so it's used for guaranteed cleanup like closing files or releasing locks, while letting any exception propagate uncaught.

Handlers are checked top-to-bottom and only the first match runs, so more-specific exceptions must come before their general bases, or the general one shadows them. A bare except: must be last.

The else runs only if the try block completed without raising any exception. It holds code that shouldn't be guarded by the except, keeping the protected try minimal. It runs before finally.

except Exception is checked first and catches ValueError too (it is a subclass), so the ValueError handler is unreachable (Python even flags it). Put specific exceptions before general ones. Also avoid a bare except: — it swallows KeyboardInterrupt / SystemExit.

Use a bare raise with no argument inside the except block — it re-raises the currently handled exception while preserving its original traceback. Writing raise exc instead would reset or alter that traceback.

Warnings flag non-fatal issues without stopping execution. Warning is a subclass of Exception; warnings.warn(message, category=UserWarning) emits one. The warnings filter can suppress them or escalate them to errors.

If an exception is raised while handling another, Python implicitly links the old one in __context__. Explicit raise New from old sets __cause__ for a direct cause; raise New from None suppresses the displayed context.

It propagates outward to the nearest enclosing try/except; if none catches it, the interpreter prints the traceback to sys.stderr and exits. But SystemExit exits quietly, and one raised in __del__ only prints "Exception ignored".

A SyntaxError in the main module aborts before execution, so it can't be caught there. It is catchable at runtime: importing a module with bad syntax, or running eval/exec on a malformed string. SyntaxError subclasses Exception.