Повторное возбуждение: голый raise в except

Пойманное исключение — ещё не решённая проблема. Иногда внутри except положение можно исправить: подставить значение по умолчанию, спросить данные заново, пропустить бракованную строку. Но чаще ловящий код знает не больше того, кто вызвал его с плохими данными, — решение должен принимать вызывающий. Для такого случая в Python есть приём: поймать исключение, сделать что можно и пробросить его дальше голым raise.

Проглотили и забыли: except без проброса

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

def load_setting():
    try:
        int('не число')
    except ValueError:
        print('внутри: что-то не так, но я промолчу')

print('вызов начался')
load_setting()
print('вызов закончился: вызывающий ни о чём не догадался')

вызов начался
внутри: что-то не так, но я промолчу
вызов закончился: вызывающий ни о чём не догадался

Функция должна была вернуть настройку, а вернула пустоту — и никто об этом не узнал. Такое называют глотанием исключений: ошибка поймана и спрятана, программа продолжает работать с плохими данными. Баг потом ищут в другом месте: падает не там, где сломалось, а там, где накопившаяся пустота наконец взорвалась. Правило честное: если вы не можете решить проблему внутри except — дайте об этом знать наверх.

Голый raise: поймал — передай дальше

Для передачи наверх у raise есть особая форма — без аргументов вовсе. Внутри блока except голый raise означает: возьми текущее исключение и продолжи его путь, как будто обработчика и не было.

def load_setting():
    try:
        int('не число')
    except ValueError:
        print('журнал: настройка не разобралась, пробрасываю дальше')
        raise

try:
    load_setting()
except ValueError as e:
    print('наверху поймали:', type(e).__name__, '-', str(e))

журнал: настройка не разобралась, пробрасываю дальше
наверху поймали: ValueError - invalid literal for int() with base 10: 'не число'

Поймали, сделали что могли — записали в журнал, — и передали дальше. Это самый частый паттерн повторного возбуждения, у него даже есть имя: log and re-raise. Голый raise внутри except не создаёт новое исключение, а продолжает путь текущего: тот же объект, тот же тип, то же сообщение, которое читается через as e из пятого урока. Вызывающий код получает ровно ту ошибку, что возникла, со всеми подробностями.

def parse_record(line):
    try:
        return int(line)
    except ValueError:
        print('журнал: строка не разобралась')
        raise

for line in ['10', 'двадцать']:
    try:
        print('значение:', parse_record(line))
    except ValueError:
        print('пропускаем строку и идём дальше')

значение: 10
журнал: строка не разобралась
пропускаем строку и идём дальше

Исключение путешествует и через границы функций: внутренний обработчик пробросил — внешний, в совсем другой части программы, поймал и принял решение. Разделение труда получилось честным: нижний уровень знает, как записать в журнал, верхний — как пережить сбой. Заметьте: строка «значение: 10» успела напечататься до того, как вторая строка сломалась. Проброс отменяет только текущий шаг, а не всю работу.

def load_setting():
    try:
        int('abc')
    except ValueError:
        print('не смог прочитать конфиг')
        raise

load_setting()

raise и raise e: две формы проброса

Внутри except можно написать и raise e — если исключение поймано с as e, объект и так лежит в переменной. Работает: то же исключение долетит наверх. Но голый raise предпочтительнее: он короче, не сломается при переименовании переменной и не добавляет в traceback лишнюю запись о строке повторного возбуждения. Трассировка после голого raise читается чище — только реальный путь ошибки.

def load_setting():
    try:
        int('abc')
    except ValueError as e:
        raise e

try:
    load_setting()
except ValueError as e:
    print('поймали то же исключение:', type(e).__name__, '-', str(e))

поймали то же исключение: ValueError - invalid literal for int() with base 10: 'abc'

try:
    raise
except RuntimeError as e:
    print('поймали:', type(e).__name__, '-', str(e))

поймали: RuntimeError - No active exception to reraise

Голому raise нужно активное исключение: он по определению повторяет то, что летит прямо сейчас. Вне except такого нет — и Python поднимает RuntimeError, уже свою собственную ошибку кода, а не данных.

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