Иерархия исключений Python: кто чей родитель

К этому моменту курса вы встречались с ValueError, ZeroDivisionError, KeyError — и могло показаться, что это просто набор имён без внутренней логики. На самом деле исключения Python образуют семейное дерево: у каждого класса есть родители, у родителей — свои дети. Знание родства объясняет удивительное поведение цепочки except: один обработчик ловит сразу несколько типов ошибок, а порядок веток решает, кто сработает.

Родословная класса: __mro__

Каждый класс исключения знает свою родословную. Её показывает атрибут __mro__ — цепочка классов от самого класса до корня всех объектов Python. Посмотрим на родословную уже знакомого ZeroDivisionError:

for cls in ZeroDivisionError.__mro__:
    print(cls.__name__)

ZeroDivisionError
ArithmeticError
Exception
BaseException
object

Читается цепочка снизу вверх: ZeroDivisionError — сын ArithmeticError, тот — сын Exception, а над всеми стоит BaseException, корень системы исключений, и наконец object, общий предок всего в Python. Два новых имени появились не случайно: ArithmeticError — семейная ветка математики (деление на ноль, переполнение числа), а Exception — большой ствол, в который входит почти всё, что ловят в обычном коде.

pairs = [
    (ZeroDivisionError, ArithmeticError),
    (KeyError, LookupError),
    (IndexError, LookupError),
    (ValueError, Exception),
    (ValueError, TypeError),
]
for child, parent in pairs:
    print(child.__name__, '->', parent.__name__, ':', issubclass(child, parent))

ZeroDivisionError -> ArithmeticError : True
KeyError -> LookupError : True
IndexError -> LookupError : True
ValueError -> Exception : True
ValueError -> TypeError : False

Функция issubclass отвечает на вопрос «чьё это дитя» без всяких догадок. Из ответов видно и неожиданное родство: KeyError и IndexError — братья, у них общий родитель LookupError, ветка поиска. Один из них знаком вам по словарям, другой по спискам, а оба случаются, когда искомое не нашлось. А ValueError и TypeError, при всём сходстве, друг другу роднёй не приходятся.

Ловля родителя ловит детей

Практический смысл иерархии — в работе цепочки except. Проверка «это ArithmeticError?» срабатывает и для ZeroDivisionError, потому что он в этой семье:

try:
    1 / 0
except ArithmeticError as e:
    print('поймали', type(e).__name__, 'через родителя ArithmeticError')

поймали ZeroDivisionError через родителя ArithmeticError

Ловля родителя ловит и всех его детей — один обработчик вместо длинного списка типов. Обратите внимание: напечатанное имя — ZeroDivisionError, настоящее имя пойманного исключения, а не имя родителя из заголовка. Проверка в except — это вопрос «подходит ли к этой семье», а сам объект ошибки остаётся собой. Отсюда и правило порядка веток в цепочке except из четвёртого урока: проверка идёт сверху вниз, и побеждает первая подходящая ветка.

data = {}
try:
    data['город']
except KeyError:
    print('ветка ребёнка: поймали KeyError')
except LookupError:
    print('ветка родителя: сюда не дошли')

ветка ребёнка: поймали KeyError

data = {}
try:
    data['город']
except LookupError:
    print('родитель стоит первым — поймал он')
except KeyError:
    print('до ветки ребёнка очередь не дошла')

родитель стоит первым — поймал он

Две одинаковые программы с переставленными ветками дают разный результат. KeyError в паре с LookupError — тот случай, когда порядок реально влияет на жизнь: родитель перехватил ошибку раньше, и специфичная ветка ребёнка стала мёртвым кодом. Python при этом не ругается и не предупреждает — он честно идёт по цепочке сверху вниз и берёт первое совпадение.

BaseException: самый верх дерева

На вершине дерева стоят Exception и его собрат BaseException. Разница между ними принципиальна: у BaseException есть ещё двое детей — KeyboardInterrupt и SystemExit. Первый прилетает, когда пользователь прерывает программу сочетанием клавиш, второй — когда программа сама просит себя завершить. Это не ошибки данных, а сигналы управления жизнью программы, и их ловить обычным кодом не положено. Проверим родство:

print('KeyboardInterrupt - потомок Exception:', issubclass(KeyboardInterrupt, Exception))
print('KeyboardInterrupt - потомок BaseException:', issubclass(KeyboardInterrupt, BaseException))
print('SystemExit - потомок Exception:', issubclass(SystemExit, Exception))

KeyboardInterrupt - потомок Exception: False
KeyboardInterrupt - потомок BaseException: True
SystemExit - потомок Exception: False

Вот почему в обычном коде ловят Exception, а не BaseException: ветка Exception пропускает сигналы прерывания мимо себя, и пользователь всегда может остановить зависший скрипт. Ловля BaseException отняла бы и этот рычаг. Подробнее о границе между «ловить конкретное» и «ловить почти всё» — в пятнадцатом уроке.

Иерархия работает в обе стороны: не только встроенные исключения состоят в родстве, но и ваши собственные классы могут занять место в дереве — с общим предком для целого семейства своих ошибок. Этим займётся десятый урок о своих исключениях.