try и except: ловим ошибку и не падаем

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

Запасной план: try и except

Схема проста. Слово try: открывает блок рискованного кода — строки с отступом, которые могут упасть. Слово except: — блок запасного плана: что делать, если в try случилось исключение. Вернёмся к разбору слова в число из первого урока, но теперь с планом Б:

try:
    n = int('двенадцать')
    print('Разобрали:', n)
except:
    print('Не получилось разобрать число')
print('Программа работает дальше')

Не получилось разобрать число
Программа работает дальше

Никакого traceback: программа не упала. Python начал выполнять try, дошёл до int('двенадцать'), получил ValueError — и вместо печати traceback перескочил в except. Там выполнился запасной план, а после него программа продолжилась по обычному пути: последняя строка отработала как ни в чём не бывало. Блок try выполняет рискованный код, блок except держит запасной план, который срабатывает вместо падения.

Если ошибки не случилось

Подсунем в тот же код число, которое разбирается без проблем:

try:
    n = int('42')
    print('Разобрали:', n)
except:
    print('Запасной план')
print('Дальше идёт обычный код')

Разобрали: 42
Дальше идёт обычный код

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

Прыжок в except: остаток try пропускается

Исключение случается не в начале try, а в конкретной строке. Что происходит с остальными строками блока? Они пропускаются: прыжок в except происходит в момент сбоя, и выполнение в try не возвращается.

try:
    print('первая строка try')
    n = int('нет числа')
    print('эта строка не выполнится')
except:
    print('перешли в except')
print('после try')

первая строка try
перешли в except
после try

Первая строка try успела напечататься, вторая упала — и четвёртая строка блока осталась невыполненной навсегда. Python не возвращается в try после except: попытка сделана, план Б отработан, программа идёт дальше. Если в рискованном коде есть строки, которые должны выполниться даже при ошибке, им место не внутри try.

Ловим деление на ноль

ZeroDivisionError из первого урока — классический кандидат на обработку: сумма на ноль участников делится в любой статистике.

a = 10
b = 0
try:
    print('Делим', a, 'на', b)
    result = a / b
    print('Результат:', result)
except:
    print('Делить на ноль нельзя — считаем по-другому')
print('Конец программы')

Делим 10 на 0
Делить на ноль нельзя — считаем по-другому
Конец программы

Печать «Делим 10 на 0» успела сработать — она была до аварийной строки. Само деление упало, и Python ушёл в except, не выполнив печать результата. Заметьте: программа не просто не упала — она дошла до конца. В первом уроке тот же код печатал traceback и обрывался.

try внутри цикла: спасти весь список

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

values = ['3', '5', 'кошка', '7']
for v in values:
    try:
        n = int(v)
        print(v, '-> число', n)
    except:
        print(v, '-> не число')

3 -> число 3
5 -> число 5
кошка -> не число
7 -> число 7

Слово «кошка» не разобралось — и вместо падения всего отчёта мы получили одну честную строку «кошка -> не число». Цикл продолжился и разобрал семёрку. Этот приём — сердце обработки ошибок в данных, и к нему раздел вернётся ещё не раз: в уроке про несколько except мы уточним типы, а в уроке про as e начнём печатать текст ошибки в лог.

try и except — не для всего

У конструкции есть жёсткая граница: она ловит ошибки времени выполнения. Ошибки синтаксиса Python обнаруживает до запуска, когда ни try, ни except ещё не существуют.

try:
    print('привет'
except:
    print('не спасёт')

Вторая граница — минимальная комплектность. Одинокий try без запасного плана не имеет смысла, и Python проверяет это тоже — ещё до запуска:

try:
    x = 1

Шпаргалка по поведению try

Остался последний кандидат — IndexError: обращение к списку по несуществующему номеру. Потренируемся ловить и его.

numbers = [10, 20, 30]
try:
    print(numbers[5])
except:
    print('Такого номера нет в списке')
print('Программа цела')

Такого номера нет в списке
Программа цела

numbers = [10, 20, 30]
print(numbers[5])
print('эта строка не выполнится')

Traceback (most recent call last):
  File "app.py", line 2, in <module>
    print(numbers[5])
          ~~~~~~~^^^
IndexError: list index out of range

Два блока с одними данными — два исхода. С try программа доходит до конца, без него обрывается на первой же строке с неверным индексом. Теперь у вас есть выбор для каждой рискованной операции: написать её как есть и получить traceback при сбое — или окружить try и except и решить, что делать при сбое. В следующем уроке мы сделаем обработчик точным: except ValueError ловит конкретный тип и не прячет чужие ошибки.