What is the root of the Python exception hierarchy?

BaseException is the root of every exception. Ordinary errors derive from Exception, which itself derives from BaseException. SystemExit, KeyboardInterrupt and GeneratorExit derive directly from BaseException so they bypass a plain except Exception.

Why should I subclass Exception and not BaseException?

User-defined exceptions should subclass Exception so that a bare 'except Exception' catches them. Subclassing BaseException would let them slip past normal error handling and is reserved for interpreter-level signals like SystemExit.

What is the difference between KeyError and IndexError?

Both derive from LookupError. KeyError is raised when a dictionary key is missing, while IndexError is raised when a sequence index is out of range. Guard dicts with .get() or 'in', and check len() before indexing.

What does the errno attribute on OSError mean?

OSError and its subclasses carry an errno (the numeric system error code), strerror (its message) and filename. They map operating-system failures such as FileNotFoundError (ENOENT) or PermissionError (EACCES) into specific Python classes.

Is anything I search uploaded?

No. The full exception table and the search both run entirely in your browser. Nothing you type is sent anywhere.

Python Exception Reference

Email me this result

Get this tool's output sent to your inbox, plus one useful tool a week. No spam, unsubscribe any time.

This is a searchable reference for Python’s built-in exception hierarchy — the class tree that every error in the standard library belongs to. For each exception it shows the direct parent class, the attributes it carries, and a plain-English description of what typically triggers it, so you can decide exactly what to catch and how to handle it.

How it works

Every Python exception derives from BaseException. Below it sits Exception, the base for ordinary catchable errors, and a small set of special signals — SystemExit, KeyboardInterrupt, GeneratorExit — that derive directly from BaseException so they are not swallowed by a plain except Exception. The table groups errors by family: arithmetic errors under ArithmeticError, lookup errors (KeyError, IndexError) under LookupError, and the large OSError family covering file and network failures, each carrying an errno.

When you catch an exception, catch the most specific class you can actually handle. Catching a parent like OSError handles a whole family at once, which is useful for I/O, while catching Exception is a last resort that should usually re-raise or log.

Example

A practical guard against a missing key versus a missing file:

try:
    value = config["timeout"]          # may raise KeyError
    fh = open(path)                     # may raise FileNotFoundError
except KeyError:
    value = 30                          # sensible default
except FileNotFoundError as e:
    print(f"missing {e.filename}")      # OSError subclass with errno/filename

Because FileNotFoundError is a subclass of OSError, an except OSError would also catch it — handy when you do not care which specific I/O error occurred. Everything runs in your browser; nothing is uploaded.