except Exception в Python: когда ловить всё и чем это грозит

Урок 9 об иерархии показал: ловля родителя ловит и детей, а почти вся рабочая семья ошибок живёт под Exception. Отсюда соблазн — вместо перечисления типов написать except Exception и закрыть вопрос разом. Программа действительно перестаёт падать. У этого урока две задачи: показать, где широкая сетка — правильный инструмент, и что происходит с кодом, где она стоит на месте конкретных типов.

Что именно ловит except Exception

Exception — родитель почти всех ошибок, с которыми программа сталкивается в работе: ValueError, KeyError, TypeError, FileNotFoundError, ZeroDivisionError и ваших собственных классов из урока 10. Один except с этим типом — сетка с крупными ячейками: в неё попадает что угодно, лишь бы это был ребёнок Exception. Проверим на трёх разных ошибках сразу:

def make_error(kind):
    if kind == 'num':
        return int('abc')
    if kind == 'key':
        return {}['имя']
    return 'text' + 5

for kind in ['num', 'key', 'type']:
    try:
        make_error(kind)
    except Exception as e:
        print(kind, '->', type(e).__name__, '-', e)

num -> ValueError - invalid literal for int() with base 10: 'abc'
key -> KeyError - 'имя'
type -> TypeError - can only concatenate str (not "int") to str

Три разные проблемы — один обработчик. Переменная e из урока 5 каждый раз получает свой объект ошибки, а type(e).__name__ показывает, кто именно прилетел: это минимальная гигиена широкого перехвата, без неё вы не узнаете даже тип. Свои исключения-классы ловятся той же сеткой — наследование от Exception сделало их детьми:

class InsufficientFundsError(Exception):
    pass

def withdraw(balance, amount):
    if amount > balance:
        raise InsufficientFundsError(f'не хватает {amount - balance}')
    return balance - amount

try:
    withdraw(100, 150)
except Exception as e:
    print('поймано:', type(e).__name__, '-', e)

поймано: InsufficientFundsError - не хватает 50

Кого Exception не ловит

У широкого перехвата есть слепая зона, и она задумана как защита. Прямо от BaseException, мимо Exception, наследуются SystemExit — сигнал выхода и KeyboardInterrupt — прерывание по Ctrl+C. except Exception их пропускает: выход из программы и просьба пользователя остановиться не считаются ошибками данных. Если бы сетка ловила и их, программу было бы не выключить.

def quit_app():
    raise SystemExit('пора выходить')

try:
    try:
        quit_app()
    except Exception as e:
        print('Exception поймал:', type(e).__name__)
except BaseException as e:
    print('мимо Exception проскочил:', type(e).__name__)
print('программа ещё работает')

мимо Exception проскочил: SystemExit
программа ещё работает

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

try:
    risky_operation()
except:  # это except BaseException - ловит даже Ctrl+C
    print('какая-то проблема')

Чем грозит: проглоченный баг

Самая дорогая цена широкого перехвата — спрятанный баг. Представьте отчёт по числам: в функции подсчёта опечатка, и вместо len написано lne. NameError — это не грязные данные, это сломанный код. Но except Exception не различает одно от другого:

def average(values):
    total = sum(values)
    return total / lne(values)  # опечатка: должно быть len

try:
    print('среднее:', average([2, 4, 6]))
except Exception:
    print('не получилось, идём дальше')

print('отчёт готов')

не получилось, идём дальше
отчёт готов

Программа напечатала отчёт готов и ушла дальше, хотя среднее не посчитано вовсе. Уберите try — и traceback из первого урока честно покажет строку с опечаткой:

print('среднее:', average([2, 4, 6]))

Где широкий перехват уместен

Есть место, где ловить всё — не лень, а архитектура. Граница программы: фоновый обработчик очереди задач, главный цикл сервера, обёртка вокруг чужого плагина. Там правило другое: одна упавшая задача не должна ронять соседние. Программа обязана пережить любую ошибку внутри задачи — даже ту, тип которой автор обработчика не предвидел. Границ в настоящей системе больше, чем кажется: ежеминутная задача планировщика, обработчик запроса веб-сервера, разбор входящего сообщения. Во всех случаях упавший элемент — не повод будить дежурного ночью: пусть видит запись в журнале утром. Именно поэтому фреймворки сами ставят широкий перехват вокруг пользовательского кода — печатают traceback и живут дальше вместо того, чтобы падать целиком.

tasks = [
    ('письмо', 'Анне'),
    ('число', 'abc'),
    ('письмо', 'Борису'),
]

log = []
for name, arg in tasks:
    try:
        if name == 'число':
            int(arg)
            print('разобрано число:', arg)
        else:
            print('отправлено:', arg)
    except Exception as e:
        log.append(f'{name}: {type(e).__name__} - {e}')

print('задачи кончились, журнал:')
for line in log:
    print(' ', line)

отправлено: Анне
отправлено: Борису
задачи кончились, журнал:
  число: ValueError - invalid literal for int() with base 10: 'abc'

Средняя задача упала, журнал получил запись, соседние выполнены. Это и есть формула уместного широкого перехвата, и в ней три условия сразу: перехват стоит на границе, ошибка фиксируется в журнале, продолжение работы осмысленно. Уберите любой пункт — и сетка превратится из страховки в дыру. Граница — не единственный сценарий: второй легальный приём — залогировать и пробросить дальше, как учил урок 8 о голом raise. Тогда перехват не прячет ошибку, а добавляет ей контекст:

def process(value):
    return int(value)

try:
    try:
        process('7x')
    except Exception as e:
        print('журнал:', type(e).__name__, '-', e)
        raise
except ValueError:
    print('ошибка ушла наверх тем же типом')

журнал: ValueError - invalid literal for int() with base 10: '7x'
ошибка ушла наверх тем же типом

Три вопроса перед except Exception

• граница ли это: код принимает задания от чужого кода или считает сам?
• что попадёт в журнал: тип ошибки, сообщение, контекст задачи?
• осмысленно ли продолжение: программа без этой операции всё ещё полезна?

Три ответа «да» — пишите except Exception спокойно. Хотя бы один «нет» — сузьте до конкретного типа из урока 3. Широкая сетка — инструмент границы, а не замена конкретике; следующий урок ставит её на рабочее место: циклы, которые переживают сбои — там except внутри for обрабатывает поток данных построчно.