Python 3. Исключения
Исключения (exceptions)
Исключение в программировании — это нетипичная ситуация (ошибка), которая возникает во время работы программы и, если с ней ничего не сделать, приводит к аварийному завершению. При этом Python не просто “падает”, а пишет сообщение о том, где и какая ошибка произошла.
Исключения можно обрабатывать. Например, можно заставить программу сообщить пользователю о проблеме и продолжить работу, а не завершаться.
Для примеров я использую Python 3.14, но всё, что описано в статье, работает и в более старых версиях (начиная с 3.8). Отличается только оформление сообщений об ошибках.
Вот несколько примеров, когда срабатывает исключение.
- Деление на ноль:
res = 10 / 0
ZeroDivisionError: division by zero
- Обращение к несуществующему индексу:
my_str = 'alex'
print(my_str[4])
IndexError: string index out of range
- Попытка преобразовать строку в число:
int('строка')
ValueError: invalid literal for int() with base 10: 'строка'
- Попытка прочитать закрытый файл:
f = open('example.txt', 'w')
f.close()
print(f.read())
ValueError: I/O operation on closed file.
Ошибки в самом синтаксисе (например, забытое двоеточие после if) — это SyntaxError. Они обнаруживаются ещё до запуска программы. В статье речь идёт об ошибках, которые возникают уже во время выполнения.
Как читать сообщение об ошибке
Сообщение об ошибке называется traceback (трассировка стека). Давайте разберём его на примере, где ошибка возникает не в основном коде, а внутри вложенных функций:
def divide(a, b):
return a / b
def calculate():
return divide(10, 0)
calculate()
То есть, в основном коде вызывается функция calculate(), она вызывает другую функцию divide(10, 0), там происходит вычисления.
Результат:
Traceback (most recent call last):
File "program.py", line 7, in <module>
calculate()
~~~~~~~~~^^
File "program.py", line 5, in calculate
return divide(10, 0)
File "program.py", line 2, in divide
return a / b
~~^~~
ZeroDivisionError: division by zero
Читать traceback нужно снизу вверх:
- Последняя строка — тип исключения (
ZeroDivisionError) и его текст (division by zero). Это самое важное, с него и нужно начинать. - Строки выше — цепочка вызовов. Самый нижний блок показывает, где именно произошла ошибка (функция
divide, строка 2). - Каждый блок выше показывает, откуда эта функция была вызвана:
divideвызвана изcalculate(строка 5), аcalculateвызвана из основного кода (строка 7).
То есть в начале сообщения вы видите, где началась цепочка вызовов, а в конце — где она закончилась ошибкой.
Частые исключения
Вот исключения, с которыми вы будете сталкиваться чаще всего:
| Исключение | Когда возникает |
|---|---|
ZeroDivisionError | Деление на ноль |
ValueError | Тип значения верный, а само значение не подходит (int('abc')) |
TypeError | Операция применена к неподходящему типу ('a' + 1) |
IndexError | Индекс вне диапазона списка, строки, кортежа |
KeyError | Обращение к несуществующему ключу словаря |
AttributeError | У объекта нет такого атрибута или метода |
NameError | Используется переменная, которую не объявили |
FileNotFoundError | Файл или каталог не найден |
PermissionError | Не хватает прав для операции с файлом |
ImportError | Не удалось импортировать модуль |
Оператор raise (создание исключений)
Исключения возникают в двух случаях: либо их создаёт сам Python (как в примерах выше, когда мы выполнили некорректную операцию), либо мы создаём их вручную с помощью оператора raise. После оператора raise пишется тип исключения, а скобках можно указать текст, который будет выведен вместе с исключением.
Следующая строка кода приведёт к исключению деления на ноль:
raise ZeroDivisionError('Деление на ноль')
Результат выполнения:
ZeroDivisionError: Деление на ноль
Обычно оператор raise используют, когда Python сам не видит проблемы, а с точки зрения логики программы она есть. Например, мы пишем приложение для отправки данных на печать. Python не знает, доступен принтер или нет, а нам нужно как-то сообщить об этой проблеме.
Давайте напишем тестовую функцию отправки данных на печать с проверкой принтера:
def send_to_print(data):
printer_ready = False
if not printer_ready:
raise ConnectionError("Принтер не отвечает")
print(data)
send_to_print("Привет!")
Результат выполнения:
ConnectionError: Принтер не отвечает
Так как принтер не отвечает (printer_ready = False), сработает исключение, которое мы создали вручную.
Обратите внимание, я использовал ConnectionError, а не общий Exception. Чем точнее тип исключения, тем проще его потом обработать. Общий Exception лучше не использовать, если есть более подходящий тип.
Оператор try (обработка исключений)
Когда срабатывает исключение, программа завершает свою работу. Но иногда нужно, чтобы она продолжила работать. Для этого код, в котором может произойти ошибка, помещают в блок try. Если в нём возникнет исключение, программа не упадёт, а выполнится код из блока except.
Блоков except может быть несколько — по одному на каждый тип ошибки. Python проверяет их сверху вниз и выполняет первый подходящий.
Дополнительно можно использовать два необязательных блока:
- else — выполняется, только если в блоке try исключения не было.
- finally — выполняется в любом случае: и при ошибке, и без неё.
Вот пример:
try:
x = int(input("Введите первое число: "))
y = int(input("Введите второе число: "))
print(x / y)
except ZeroDivisionError:
print("Ошибка! На ноль делить нельзя.")
except ValueError:
print("Ошибка! Вы ввели строку, а нужно было число.")
except Exception as e:
print(f"Что-то пошло не так: {type(e).__name__}: {e}")
else:
print("Ошибок не было.")
finally:
print("Конец!")
Здесь
print(f"Что-то пошло не так ...я использовал f-строки, про них я писал в статье .
В программе требуется ввести два числа, затем первое число делится на второе. Вот примеры работы этой программы:
- Ввели строку вместо числа:
Введите первое число: as
Ошибка! Вы ввели строку, а нужно было число.
Конец!
- Попытались делить на ноль:
Введите первое число: 1
Введите второе число: 0
Ошибка! На ноль делить нельзя.
Конец!
- Ввели корректные числа (исключения не было, поэтому выполнился блок else):
Введите первое число: 6
Введите второе число: 3
2.0
Ошибок не было.
Конец!
Блок finally выполнился во всех трёх случаях. Его используют для действий, которые нужно сделать обязательно: закрыть файл, закрыть соединение с базой данных, удалить временный файл.
Получение информации об исключении
Если написать except ZeroDivisionError as e, то само исключение будет доступно в переменной e.
try:
print(10 / 0)
except ZeroDivisionError as e:
print("Тип:", type(e))
print("Текст:", e)
Результат выполнения:
Тип: <class 'ZeroDivisionError'>
Текст: division by zero
Это удобно, когда нужно записать причину ошибки в лог или показать её пользователю.
Если нужно обработать несколько типов исключений одинаково, их можно перечислить в круглых скобках:
try:
print(10 / 0)
except (ZeroDivisionError, ValueError) as e:
print("Поймали:", e)
Результат выполнения:
Поймали: division by zero
Иерархия исключений
Классы исключений выстроены в иерархию: у каждого есть “родитель”.
object -> BaseException -> Exception -> ArithmeticError -> ZeroDivisionError
|
-> KeyboardInterrupt
|
-> SystemExit
ZeroDivisionError— это частный случайArithmeticError, а тот, в свою очередь, частный случайException.KeyboardInterrupt(нажатие Ctrl+C) иSystemExit(вызовexit()) не наследуются отException. Они наследуются напрямую отBaseException.
Из этого следуют правило: блок except с родительским классом ловит и всех его потомков. Поэтому except ArithmeticError поймает и ZeroDivisionError. Из-за этого в цепочке блоков except нужно сначала писать более конкретные исключения, а потом более общие. Иначе до конкретного блока дело никогда не дойдёт.
Почему не стоит писать пустой except
В старых статьях (и в первой версии этой тоже) можно встретить вот такую запись:
try:
...
except:
print("Что-то пошло не так...")
Пустой except: ловит вообще всё, включая KeyboardInterrupt и SystemExit. В итоге вы не сможете остановить программу через Ctrl+C. Кроме того, такой код скрывает причину ошибки, и потом сложно понять, что именно пошло не так.
Поэтому правила такие:
- Ловите конкретные исключения, которые вы ожидаете и знаете, что с ними делать.
- Если нужно поймать “всё остальное”, пишите
except Exception as eи обязательно записывайте информацию об ошибке. - Не пишите
except: pass— это самый верный способ получить программу, которая работает всегда, но неправильно.
Ещё один совет: старайтесь помещать в try как можно меньше кода — только ту строку (или несколько строк), где ожидается ошибка. Иначе вы можете случайно перехватить исключение, которого не ожидали.
Вот пример реальной задачи — чтение конфигурационного файла, которого может не быть:
def read_config(path):
try:
with open(path) as f:
return f.read()
except FileNotFoundError:
print(f"Файл {path} не найден, используем настройки по умолчанию")
return ""
read_config("no_such_file.conf")
Результат выполнения:
Файл no_such_file.conf не найден, используем настройки по умолчанию
Собственные исключения
Встроенных исключений хватает не всегда. Если в вашей программе есть своя логика (например, ошибки работы с принтером), можно создать собственный тип исключения. Для этого нужно создать класс, который наследуется от Exception:
class PrinterError(Exception):
"""Ошибка работы с принтером"""
def send_to_print(data):
printer_ready = False
if not printer_ready:
raise PrinterError("Принтер не отвечает")
print(data)
try:
send_to_print("Привет!")
except PrinterError as e:
print("Ошибка печати:", e)
Результат выполнения:
Ошибка печати: Принтер не отвечает
Теперь except PrinterError ловит только ошибки печати и не трогает остальные. Классы мы подробнее разбирали в статье про ООП
, а здесь достаточно запомнить шаблон: class ИмяОшибки(Exception):. Названия таких классов принято заканчивать на Error.
Повторный вызов исключения
Иногда нужно поймать исключение, что-то сделать (например, записать в лог), а затем передать его дальше. Для этого внутри блока except используется raise без параметров:
try:
1 / 0
except ZeroDivisionError:
print("Записали ошдибку в лог")
raise
Результат выполнения:
Записали ошибку в лог
ZeroDivisionError: division by zero
Оператор assert (тестирование кода)
Оператор assert позволяет проверить, что в этом месте программы выполняется нужное нам условие. Чаще всего его используют для простых тестов.
Например, вы написали функцию для оценки надёжности пароля. Можно запускать программу и вручную вводить разные пароли, проверяя результат. Но после любой правки кода придётся проверять всё заново.
Чтобы избежать ручной работы, можно написать тесты с помощью assert. Синтаксис такой:
assert условие, "необязательное сообщение об ошибке"
Если условие истинно, ничего не происходит. Если ложно — возникает исключение AssertionError (с вашим сообщением, если вы его указали).
В тестах мы пишем вызов проверяемой функции с параметром, затем знак равенства (==) и значение, которое функция должна вернуть. Если функция вернёт что-то другое, сработает исключение. Если программа завершилась без исключений, значит все тесты пройдены.
import string # Содержит наборы различных строк
def password_strength(my_str):
digits = string.digits # Все цифры
lowers = string.ascii_lowercase # Все строчные латинские буквы
uppers = string.ascii_uppercase # Все заглавные латинские буквы
# Если пароль короче 8 символов
if len(my_str) < 8:
return 'Слишком слабый пароль'
# Если пароль состоит только из цифр, или только из строчных, или только из заглавных букв
if all(e in digits for e in my_str) or all(e in lowers for e in my_str) or all(e in uppers for e in my_str):
return 'Слабый пароль'
# Если в пароле есть и цифры, и строчные, и заглавные буквы
if any(e in digits for e in my_str) and any(e in lowers for e in my_str) and any(e in uppers for e in my_str):
return 'Очень хороший пароль'
# В остальных случаях (используются два набора символов из трёх)
return 'Хороший пароль'
# Блок с тестами. Передаём в функцию разные строки и проверяем результат
assert password_strength('') == 'Слишком слабый пароль'
assert password_strength('123') == 'Слишком слабый пароль'
assert password_strength('1234567') == 'Слишком слабый пароль'
assert password_strength('qazwsxe') == 'Слишком слабый пароль'
assert password_strength('QAZWSXE') == 'Слишком слабый пароль'
assert password_strength('12345678') == 'Слабый пароль'
assert password_strength('qazwsxed') == 'Слабый пароль'
assert password_strength('QAZWSXED') == 'Слабый пароль'
assert password_strength('1234qazw') == 'Хороший пароль'
assert password_strength('1234QAZW') == 'Хороший пароль'
assert password_strength('QAZwsxed') == 'Хороший пароль'
assert password_strength('123QAZws') == 'Очень хороший пароль'
assert password_strength('123wsxRFV') == 'Очень хороший пароль'
print("Все тесты пройдены")
Результат выполнения:
Все тесты пройдены
Если мы выполним этот код и он завершится без ошибок, значит функция работает так, как мы задумали.
Теперь, если мы меняем функцию, нам не нужно проверять всё вручную. Мы просто запускаем код заново и смотрим, завершится ли он без ошибок.
Давайте посмотрим, что будет, если один из тестов не пройдёт. Для примера изменим ожидаемый результат у одного теста:
assert password_strength('QAZwsxed') == 'Очень хороший пароль'
Результат выполнения:
Traceback (most recent call last):
File "program.py", line 29, in <module>
assert password_strength('QAZwsxed') == 'Очень хороший пароль'
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
AssertionError
Сообщение сразу показывает, какой именно тест не прошёл.
Эта функция учебная и не учитывает специальные символы: пароль !!!!!!!! она посчитает “Хорошим”. Это хороший повод дописать тест, увидеть, как он упадёт, и доработать функцию.
assert служит для проверок логики программы, которые определяет разработчик, а не для перехвата ошибок, связанных с внешним миром (ввод пользователя, отсутствие файла, недоступность сети). Для таких случаев используйте try и raise.
На практике для серьёзного тестирования используют специальные библиотеки, например unittest (встроена в Python) или pytest. Но под капотом в них тоже используются проверки, похожие на assert.
Оператор with (менеджер контекста)
Как программисты, мы работаем с внешними ресурсами: файлами, базами данных, сетевыми соединениями, сессиями на сайтах. Во всех этих случаях нужно подключиться к ресурсу, поработать с ним и обязательно отключиться. Это можно делать самостоятельно, а можно использовать менеджер контекста — оператор with.
Например, файл нужно закрывать, когда мы закончили с ним работать. Но между открытием и закрытием файла может возникнуть ошибка, и строка с close() просто не выполнится. Оператор with решает эту проблему: он закрывает файл в любом случае, даже если внутри блока произошло исключение. Про работу с файлами я писал здесь
, там тоже описан оператор with.
Сначала создадим файл example.txt с тремя строками:
Первая строка из файла
Вторая строка из файла
Третья строка из файла
Теперь прочитаем из него две строки:
with open('example.txt', 'r', encoding='utf-8') as file:
print(file.readline().strip())
print(file.readline().strip())
print("Файл закрыт?", file.closed)
print("Файл закрыт?", file.closed)
Результат выполнения:
Первая строка из файла
Вторая строка из файла
Файл закрыт? False
Файл закрыт? True
В коде выше мы нигде не вызываем close(), но как только выполнение выходит из блока with, файл закрывается автоматически.
Теперь проверим, что файл закроется, даже если внутри блока возникнет исключение:
try:
with open('example.txt', 'r', encoding='utf-8') as file:
print(file.readline().strip())
raise OSError("Что-то сломалось")
except OSError as e:
print("Перехвачено исключение:", e)
print("Файл закрыт?", file.closed)
Результат выполнения:
Первая строка из файла
Перехвачено исключение: Что-то сломалось
Файл закрыт? True
Исключение произошло внутри блока, но файл всё равно закрыт.
Подавление исключений через suppress
Если нужно просто проигнорировать конкретное исключение, можно использовать готовый менеджер контекста suppress из модуля contextlib:
from contextlib import suppress
import os
with suppress(FileNotFoundError):
os.remove('no_such_file.txt')
print("Дошли до конца")
Результат выполнения:
Дошли до конца
Это короче, чем писать try ... except FileNotFoundError: pass. Но используйте это осторожно и только для исключений, про которые точно знаете, что их можно игнорировать.
Итог
Мы познакомились с исключениями в Python 3: научились читать сообщения об ошибках (traceback), создавать исключения с помощью оператора raise и обрабатывать их с помощью try, except, else и finally.
Узнали, как устроена иерархия исключений, почему не стоит использовать пустой except, и как создавать собственные типы исключений.
Также научились проводить простые тесты с помощью оператора assert и использовать менеджер контекста with, чтобы ресурсы всегда освобождались корректно.
Если понравилась статья, подпишись на мой канал в VK или Telegram .