Прошлый урок расставил по местам область видимости и аргументы, так что функции теперь принимают ровно то, что им передают. Неприкрытой осталась последняя брешь в обороне программы, и прячется она не в коде, а в мире вокруг него. Пользователь вводит букву там, где ждут число, нужный файл кто-то успел переименовать, а в знаменателе внезапно обнаруживается ноль. На любой из таких сюрпризов интерпретатор отвечает исключением, и без обработки программа падает целиком, бросая на полпути всё, что успела посчитать и записать. Конструкция try except переводит сбой из разряда катастроф в разряд обычных ситуаций: подозрительный участок уходит под охрану, ошибка перехватывается, и программа выбирает запасной путь. Урок пятнадцатый стоит на экваторе курса не случайно, потому что без этого навыка настоящая программа не выдержит и пяти минут рядом с живым пользователем.
Трейсбек и чтение сообщения об ошибке
Сначала стоит разобраться, что именно видит программист, когда что-то идёт не так. Одна строка кода без всякой защиты:
print(10 / 0)
Интерпретатор немедленно останавливает программу и печатает в консоль многострочное сообщение, которое называют трейсбеком, следом ошибки. Читают его снизу вверх. Самая нижняя строка содержит главное, тип исключения и краткое пояснение:
Traceback (most recent call last):
File "demo.py", line 1, in <module>
print(10 / 0)
ZeroDivisionError: division by zero
Из сообщения ясно, что случился ZeroDivisionError, то есть деление на ноль. Строки выше показывают маршрут к месту сбоя: имя файла demo.py, номер строки, вызов прямо в теле программы. В большом проекте с функциями след превращается в лестницу вызовов, и по ней легко спуститься от точки обрыва туда, где всё началось. Новички часто пугаются объёмного текста, хотя трейсбек скорее друг: он честно называет тип проблемы, приводит её описание и показывает точное место. Английская пометка most recent call last подсказывает, что самый свежий вызов находится в конце списка. Под капотом исключение оказывается обычным объектом, экземпляром специального класса. У него есть тип, текстовое описание и целая родословная в виде иерархии классов, поэтому с ним можно работать как с данными: сохранять в переменную, передавать дальше, анализировать. Пока же достаточно уметь читать сообщение целиком, от последней строки к первой. Перед разбором любого сбоя выручает простой порядок действий:
- Прочитать нижнюю строку трейсбека, где записаны тип исключения и его описание;
- Найти строкой выше имя файла и номер строки, где произошёл сбой;
- Проследить цепочку вызовов, если ошибка поднялась из вложенной функции;
- Сверить тип исключения с документацией и понять, какие данные оказались неверными.
Первый try except на примере деления на ноль
Защитная конструкция строится из двух блоков. В блок try помещают рискованный код, а в блок except записывают запасной план:
try:
result = 10 / 0
except ZeroDivisionError:
result = "на ноль делить нельзя"
print(result)
Питон выполняет блок try построчно, и пока всё гладко, до except дело не доходит. Стоит в try возникнуть исключению, как интерпретатор прерывает обычный ход, находит подходящий блок except и передаёт управление ему. Программа не останавливается, а спокойно печатает заготовленный результат. Существенно и то, что территория под except уже безопасна: здесь можно подставить значение по умолчанию, записать предупреждение в журнал или просто продолжить работу. Внутри try может стоять сколько угодно строк, но срабатывает правило первого сбоя: как только одна из строк выбрасывает исключение, остальные строки пропускаются, и управление сразу уходит в обработчик. Если же весь блок прошёл чисто, питон просто игнорирует раздел обработки, как будто того и не было. Такое устройство превращает try в компактную страховку вокруг конкретной операции, а не вокруг всей программы сразу, поэтому рискованные вызовы стараются окружать точечно. Для новичков важна и форма записи: после имени конструкции обязательны двоеточие и отступ в четыре пробела, и в этом смысле блоки не отличаются от знакомых по прошлым урокам if, циклов и функций.
Перехват конкретных исключений вместо ловли всего подряд
Исключения в питоне типизированы, и у каждого сбоя есть собственное имя. Деление на ноль порождает ZeroDivisionError, неудачное преобразование текста в число даёт ValueError, а обращение к отсутствующему файлу оборачивается FileNotFoundError:
try:
number = int("двенадцать")
except ValueError:
print("Это не число, а просто текст")
try:
with open("settings.txt", encoding="utf-8") as file:
content = file.read()
except FileNotFoundError:
print("Файла нет, поработаем без настроек")
Перехват по конкретному типу работает точечно. Если в первом примере всплывёт какая-то иная ошибка, скажем опечатка в имени переменной, она не будет проглочена молча, а честно остановит программу и покажет трейсбек. Так и правильно: внезапный сбой обязан оставаться видимым, иначе отладка превращается в гадание. Голый except без указания типа ловит вообще всё, включая сигнал прерывания с клавиатуры, и потому не приветствуется. Разумный компромисс, когда типы заранее неизвестны, выглядит как except Exception: такой блок перехватывает обычные программные ошибки, оставляя системные сигналы в покое. Правило простое: конкретный тип всюду, где он известен, широкая сетка только там, где без неё никак.
Среди часто встречающихся имён есть ещё несколько. IndexError всплывает при обращении к несуществующему индексу списка, KeyError при запросе отсутствующего ключа словаря, TypeError при сложении несовместимых типов вроде строки и числа, NameError при использовании переменной, которой никто не создавал. Узнавание этих имён в трейсбеке экономит минуты: по одному слову ясно, смотреть ли на длину списка, на ключи словаря или на опечатку в имени.
Несколько блоков except и текст ошибки через as e
Реальный код редко ограничивается одной угрозой, поэтому после одного try разрешено ставить столько блоков except, сколько требуется. Интерпретатор сверяет возникшее исключение с блоками сверху вниз и выполняет первый подходящий:
raw = input("Введите число: ")
try:
value = int(raw)
print("Сто поделить на", value, "равно", 100 / value)
except ValueError:
print("Введено не число")
except ZeroDivisionError:
print("Ноль в знаменателе недопустим")
Если несколько разных ошибок обрабатываются одинаково, их типы перечисляются в круглых скобках через запятую:
try:
value = int(input("Сколько штук: "))
print("Итого:", 99.9 * value)
except (ValueError, TypeError):
print("Данные не похожи на число")
Нередко нужен и текст самого сбоя, и для этого служит форма as e. Переменная e получает объект исключения, из которого достаётся готовое описание:
try:
value = int("тридцать три")
except ValueError as e:
print("Не получилось:", e)
print("Тип сбоя:", type(e).__name__)
Имя после as выбирается свободно, сокращение e стало традицией, но никто не мешает написать as err или as problem. У объекта исключения есть и другие данные: свойство e.args хранит кортеж аргументов, с которых исключение создавалось, а стандартная функция str(e) возвращает человекочитаемую строку. Для учебных задач хватает печати сообщения, но привычка смотреть на тип и аргументы пригодится, когда придётся различать похожие сбои. Полезно знать и про иерархию: у ZeroDivisionError есть родитель ArithmeticError, а над всей обычной семьёй стоит класс Exception. Перехват родителя автоматически ловит и его потомков, поэтому сетка из Exception получается такой широкой.
Блоки else и finally в связке с try
Полную сборку конструкции дополняют ещё два блока. else срабатывает, когда в try не случилось ни одной ошибки, и туда помещают код, который нужен только при успехе. finally выполняется всегда, независимо от исхода, поэтому он стал стандартным местом для уборки, закрытия файлов и соединений:
try:
file = open("notes.txt", encoding="utf-8")
except FileNotFoundError:
print("Заметок пока нет, начнём с чистого листа")
else:
print(file.read())
file.close()
finally:
print("Проверка папки завершена")
Ход выполнения здесь прозрачен. Нашёлся файл, отработают else и finally, не нашёлся, выполнится except и тот же самый finally. Финальный блок не пропустит ничего: даже если внутри try случится исключение, не покрытое ни одним except, или сработает return внутри функции, управление всё равно дойдёт до finally. Такое железобетонное поведение делает блок удобным местом для записи итога в журнал. Порядок блоков жёсткий: сначала try, затем один или несколько except, после них при желании else и в самом конце finally. Отдельной тонкостью отличается else: в этот блок код не попадёт, если в try произошла хоть какая-то ошибка, даже успешно перехваченная. Там хорошо живёт логика, зависящая от успеха всей операции, например сохранение результата или печать итогового отчёта. Сам try при этом стараются делать коротким, оставляя в нём ровно ту операцию, которая может сорваться, а всю остальную работу перенося в else.
Оператор raise и вызов собственной ошибки
Перехватывать чужие сбои полезно, но не менее часто программе нужно объявить о проблеме самостоятельно. Для этого служит оператор raise, после которого указывают объект исключения. Типичная ситуация: данные формально корректны, но по смыслу непригодны:
def set_discount(percent):
if percent < 0 or percent > 90:
raise ValueError("Скидка должна быть от 0 до 90 процентов")
return percent
try:
final = 1000 - 1000 * set_discount(150) / 100
except ValueError as e:
print("Отказ:", e)
Функция set_discount не пытается угадывать намерения вызывающего кода и честно сообщает о негодных данных, поднимая исключение. Тот, кто функцию вызвал, решает, что делать дальше: перехватить, показать сообщение или передать проблему выше. Без обработки исключение действительно поднимается по цепочке вызовов, пока не встретит подходящий except, а дойдя до самого верха, останавливает программу с уже знакомым трейсбеком:
def average(numbers):
return sum(numbers) / len(numbers)
try:
print(average([]))
except ZeroDivisionError:
print("Список пуст, среднего нет")
Функция average не знает ни о вводе пользователя, ни о печати на экран, она просто сообщила о пустом списке, а стратегию обработки выбрал внешний код. Разделение ответственности делает программу гибче: библиотечные функции поднимают исключения, прикладной код решает, что с ними делать. Собственный тип ошибки объявляется как обычный класс с наследованием от Exception, и двух строк хватает для полноценного применения:
class OutOfStockError(Exception):
pass
stock = {"ручка": 3}
try:
if stock.get("ручка", 0) < 5:
raise OutOfStockError("Ручек на складе меньше пяти")
except OutOfStockError as e:
print("Внимание:", e)
Такое имя говорит о бизнес-смысле проблемы громче, чем универсальное ValueError, и перехватывается отдельным блоком except. Иногда внутри except логично повторно бросить то же исключение командой raise без аргументов, когда локально проблему не решить и решение отдают верхнему уровню. Умение вовремя сказать raise дисциплинирует код: функции перестают возвращать загадочные минус единицы и None в знак отказа, а вместо этого формулируют проблему человеческим языком.
Надёжный ввод числа через while True и try except
Всё изученное собирается в практический шаблон, который нужен почти в каждом проекте. Задача звучит так: программа должна получить от пользователя целое число и не сдаваться, пока не получит корректное значение. Связка while True с try except и командой break решает её в десяток строк:
while True:
try:
age = int(input("Сколько вам лет: "))
except ValueError:
print("Нужны только цифры, попробуйте ещё раз")
continue
if age < 0 or age > 130:
print("Такого возраста не бывает, проверьте ввод")
continue
break
print("Принято. Через десять лет вам будет", age + 10)
Разберём ход работы. Цикл крутится бесконечно, и единственный законный выход из него стоит в самом конце, за всеми проверками. Неудачное преобразование int перехватывается, печатается подсказка, а continue отправляет пользователя на новый круг. Проверка диапазона отсекает фантастические значения вроде минус пяти или трёхсот. Корректные данные доходят до break, цикл завершается, и в переменной age остаётся готовое число. Тот же шаблон с небольшими правками обслуживает ввод цен, количества товаров, координат и любых других числовых данных, поэтому его стоит сохранить в личную копилку. Небольшая модификация с float вместо int принимает и дробные значения, а дополнительный блок else внутри цикла отделяет успешный разбор от проверок: в else уходит расчёт, в except остаётся реакция на неверный формат.
Обработка ошибок меняет само отношение к сбою. Вместо обвала всей программы получается предсказуемая ветка логики с понятным сообщением: трейсбек называет тип и место проблемы, try хранит рискованный код, except перехватывает конкретные исключения, as e отдаёт их текст, else и finally доводят конструкцию до полной сборки, а raise позволяет программе самой объявлять о негодных данных. Следующий урок посвящён модулям и импорту, то есть тому, как не писать всё с нуля и подключать готовые инструменты одной строкой. Тема сбоев там встретится сразу, ведь даже обычный import module умеет заканчиваться исключением, если файла с модулем нет.