Как отлавливать ошибки python

Обработка исключений

При выполнении заданий к главам вы, скорее всего, нередко сталкивались с возникновением различных ошибок. В этой главе мы изучим подход, который позволяет обрабатывать ошибки после их возникновения.

Напишем программу, которая будет считать обратные значения для целых чисел из заданного диапазона и выводить их в одну строку с разделителем ‘;’. Один из вариантов кода для решения этой задачи выглядит так:

print(";".join(str(1 / x) for x in range(int(input()), int(input()) + 1)))

Программа получилась в одну строчку за счёт использования списочных выражений. Однако при вводе диапазона чисел, включающего в себя 0 (например, от -1 до 1), программа выдаст следующую ошибку:

ZeroDivisionError: division by zero

В программе произошла ошибка «деление на ноль». Такая ошибка, возникающая при выполнении программы и останавливающая её работу, называется исключением.

Попробуем в нашей программе избавиться от возникновения исключения деления на ноль. Пусть при попадании 0 в диапазон чисел обработка не производится и выводится сообщение «Диапазон чисел содержит 0». Для этого нужно проверить до списочного выражения наличие нуля в диапазоне:

interval = range(int(input()), int(input()) + 1)
if 0 in interval:
    print("Диапазон чисел содержит 0.")
else:
    print(";".join(str(1 / x) for x in interval))

Теперь для диапазона, включающего в себя 0, например от -2 до 2, исключения ZeroDivisionError не возникнет. Однако при вводе строки, которую невозможно преобразовать в целое число (например, «a»), будет вызвано другое исключение:

ValueError: invalid literal for int() with base 10: 'a'

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

start = input()
end = input()
# Метод lstrip("-"), удаляющий символы "-" в начале строки, нужен для учёта
# отрицательных чисел, иначе isdigit() вернёт для них False
if not (start.lstrip("-").isdigit() and end.lstrip("-").isdigit()):
    print("
    ввести два числа.")
else:
    interval = range(int(start), int(end) + 1)
    if 0 in interval:
        print("Диапазон чисел содержит 0.")
    else:
        print(";".join(str(1 / x) for x in interval))

Теперь наша программа работает без ошибок и при вводе строк, которые нельзя преобразовать в целое число.

Подход, который был нами применён для предотвращения ошибок, называется Look Before You Leap (LBYL), или «Посмотри перед прыжком». В программе, реализующей такой подход, проверяются возможные условия возникновения ошибок до исполнения основного кода.

Подход LBYL имеет недостатки. Программу из примера стало сложнее читать из-за вложенного условного оператора. Проверка условия, что строка может быть преобразована в число, выглядит даже сложнее, чем списочное выражение. Вложенный условный оператор не решает поставленную задачу, а только лишь проверяет входные данные на корректность. Легко заметить, что решение основной задачи заняло меньше времени, чем составление условий проверки корректности входных данных.

Существует другой подход для работы с ошибками: Easier to Ask Forgiveness than Permission (EAFP), или «Проще попросить прощения, чем разрешения». В этом подходе сначала исполняется код, а в случае возникновения ошибок происходит их обработка. Подход EAFP реализован в Python в виде обработки исключений.

Исключения в Python являются классами ошибок. В Python есть много стандартных исключений. Они имеют определённую иерархию за счёт механизма наследования классов. В документации Python версии 3.10.8 приводится следующее дерево иерархии стандартных исключений:

BaseException
 +-- SystemExit
 +-- KeyboardInterrupt
 +-- GeneratorExit
 +-- Exception
      +-- StopIteration
      +-- StopAsyncIteration
      +-- ArithmeticError
      |    +-- FloatingPointError
      |    +-- OverflowError
      |    +-- ZeroDivisionError
      +-- AssertionError
      +-- AttributeError
      +-- BufferError
      +-- EOFError
      +-- ImportError
      |    +-- ModuleNotFoundError
      +-- LookupError
      |    +-- IndexError
      |    +-- KeyError
      +-- MemoryError
      +-- NameError
      |    +-- UnboundLocalError
      +-- OSError
      |    +-- BlockingIOError
      |    +-- ChildProcessError
      |    +-- ConnectionError
      |    |    +-- BrokenPipeError
      |    |    +-- ConnectionAbortedError
      |    |    +-- ConnectionRefusedError
      |    |    +-- ConnectionResetError
      |    +-- FileExistsError
      |    +-- FileNotFoundError
      |    +-- InterruptedError
      |    +-- IsADirectoryError
      |    +-- NotADirectoryError
      |    +-- PermissionError
      |    +-- ProcessLookupError
      |    +-- TimeoutError
      +-- ReferenceError
      +-- RuntimeError
      |    +-- NotImplementedError
      |    +-- RecursionError
      +-- SyntaxError
      |    +-- IndentationError
      |         +-- TabError
      +-- SystemError
      +-- TypeError
      +-- ValueError
      |    +-- UnicodeError
      |         +-- UnicodeDecodeError
      |         +-- UnicodeEncodeError
      |         +-- UnicodeTranslateError
      +-- Warning
           +-- DeprecationWarning
           +-- PendingDeprecationWarning
           +-- RuntimeWarning
           +-- SyntaxWarning
           +-- UserWarning
           +-- FutureWarning
           +-- ImportWarning
           +-- UnicodeWarning
           +-- BytesWarning
           +-- EncodingWarning
           +-- ResourceWarning

Для обработки исключения в Python используется следующий синтаксис:

try:
    <код , который может вызвать исключения при выполнении>
except <классисключения_1>:
    <код обработки исключения>
except <классисключения_2>:
    <код обработки исключения>
...
else:
    <код выполняется, если не вызвано исключение в блоке try>
finally:
    <код , который выполняется всегда>

Блок try содержит код, в котором нужно обработать исключения, если они возникнут.
При возникновении исключения интерпретатор последовательно проверяет, в каком из блоков except обрабатывается это исключение.
Исключение обрабатывается в первом блоке except, обрабатывающем класс этого исключения или базовый класс возникшего исключения.
Необходимо учитывать иерархию исключений для определения порядка их обработки в блоках except. Начинать обработку исключений следует с более узких классов исключений. Если начать с более широкого класса исключения, например Exception, то всегда при возникновении исключения будет срабатывать первый блок except.
Сравните два следующих примера. В первом порядок обработки исключений указан от производных классов к базовым, а во втором — наоборот.

Первый пример:

try:
    print(1 / int(input()))
except ZeroDivisionError:
    print("Ошибка деления на ноль.")
except ValueError:
    print("Невозможно преобразовать строку в число.")
except Exception:
    print("Неизвестная ошибка.")

При вводе значений «0» и «a» получим ожидаемый, соответствующий возникающим исключениям вывод:

Невозможно преобразовать строку в число.

и

Ошибка деления на ноль.

Второй пример:

try:
    print(1 / int(input()))
except Exception:
    print("Неизвестная ошибка.")
except ZeroDivisionError:
    print("Ошибка деления на ноль.")
except ValueError:
    print("Невозможно преобразовать строку в число.")

При вводе значений «0» и «a» получим в обоих случаях неинформативный вывод:

Неизвестная ошибка.

Необязательный блок else выполняет код в случае, если в блоке try не вызвано исключение. Добавим блок else в пример для вывода сообщения об успешном выполнении операции:

try:
    print(1 / int(input()))
except ZeroDivisionError:
    print("Ошибка деления на ноль.")
except ValueError:
    print("Невозможно преобразовать строку в число.")
except Exception:
    print("Неизвестная ошибка.")
else:
    print("Операция выполнена успешно.")

Теперь при вводе корректного значения, например «5», вывод программы будет следующим:

2.0
Операция выполнена успешно.

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

try:
    print(1 / int(input()))
except ZeroDivisionError:
    print("Ошибка деления на ноль.")
except ValueError:
    print("Невозможно преобразовать строку в число.")
except Exception:
    print("Неизвестная ошибка.")
else:
    print("Операция выполнена успешно.")
finally:
    print("Программа завершена.")

Перепишем код, созданный с применением подхода LBYL, для первого примера из этой главы с использованием обработки исключений:

try:
    print(";".join(str(1 / x) for x in range(int(input()), int(input()) + 1)))
except ZeroDivisionError:
    print("Диапазон чисел содержит 0.")
except ValueError:
    print("Необходимо ввести два числа.")

Теперь наша программа читается намного легче. При этом создание кода для обработки исключений не заняло много времени и не потребовало проверки сложных условий.

Исключения можно принудительно вызывать с помощью оператора raise. Этот оператор имеет следующий синтаксис:

raise <класс исключения>(параметры)

В качестве параметра можно, например, передать строку с сообщением об ошибке.

Создание собственных исключений

В Python можно создавать свои собственные исключения. Синтаксис создания исключения такой же, как и у создания класса. При создании исключения его необходимо наследовать от какого-либо стандартного класса-исключения.

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

• NumbersError — базовый класс исключения;
• EvenError — исключение, которое вызывается при наличии хотя бы одного чётного числа;
• NegativeError — исключение, которое вызывается при наличии хотя бы одного отрицательного числа.

class NumbersError(Exception):
    pass


class EvenError(NumbersError):
    pass


class NegativeError(NumbersError):
    pass


def no_even(numbers):
    if all(x % 2 != 0 for x in numbers):
        return True
    raise EvenError("В списке не должно быть чётных чисел")


def no_negative(numbers):
    if all(x >= 0 for x in numbers):
        return True
    raise NegativeError("В списке не должно быть отрицательных чисел")


def main():
    print("Введите числа в одну строку через пробел:")
    try:
        numbers = [int(x) for x in input().split()]
        if no_negative(numbers) and no_even(numbers):
            print(f"Сумма чисел равна: {sum(numbers)}.")
    except NumbersError as e:  # обращение к исключению как к объекту
        print(f"Произошла ошибка: {e}.")
    except Exception as e:
        print(f"Произошла непредвиденная ошибка: {e}.")

        
if __name__ == "__main__":
    main()

Модули

Обратите внимание: в программе основной код выделен в функцию main. А код вне функций содержит только условный оператор и вызов функции main при выполнении условия __name__ == "__main__". Это условие проверяет, запущен ли файл как самостоятельная программа или импортирован как модуль.

Любая программа, написанная на языке программирования Python, может быть импортирована как модуль в другую программу. В идеологии Python импортировать модуль — значит полностью его выполнить. Если основной код модуля содержит вызовы функций, ввод или вывод данных без использования указанного условия __name__ == "__main__", то произойдёт полноценный запуск программы. А это не всегда удобно, если из модуля нужна только отдельная функция или какой-либо класс.

При изучении модуля itertools мы говорили о том, как импортировать модуль в программу. Покажем ещё раз два способа импорта на примере собственного модуля.

Для импорта модуля из файла, например example_module.py, нужно указать его имя, если он находится в той же папке, что и импортирующая его программа:

import example_module

Если требуется отдельный компонент модуля, например функция или класс, то импорт можно осуществить так:

from example_module import some_function, ExampleClass

Обратите внимание: при втором способе импортированные объекты попадают в пространство имён новой программы. Это означает, что они будут объектами новой программы и в программе не должно быть других объектов с такими же именами.

Рассмотрим написанное выше на примере. Пусть имеется программа module_hello.py, в которой находится функция hello(name), возвращающая строку приветствия пользователя по имени. В самой программе кроме функции присутствует вызов этой функции и печать результата её работы. Импортируем из модуля module_hello.py функцию hello(name) в другую программу program.py и также используем для вывода приветствия пользователя.

Код программы module_hello.py:

def hello(name):
    return f"Привет, {name}!"


print(hello(input("Введите своё имя: ")))

Код программы program.py:

from module_hello import hello

print(hello(input("Добрый день. Введите имя: ")))

При выполнении program.py нас ожидает неожиданное действие. Программа сначала запросит имя пользователя, а затем сделает это ещё раз, но с приветствием из program.py.

Введите своё имя: Андрей
Привет, Андрей!
Добрый день. Введите имя: Андрей
Привет, Андрей!

Наша ошибка заключается в том, что программа module_hello.py выполняется полностью, включая основной код с вызовом функции и выводом результата. Исправим программу module_hello.py, добавив проверку, запущена программа или импортирована как модуль:

def hello(name):
    return f"Привет, {name}!"


if __name__ == "__main__":
    print(hello(input("Введите своё имя: ")))

Теперь при импорте модуля module_hello.py код в теле условного оператора выполняться не будет. А основной код этой программы выполнится только при запуске файла как отдельной программы.
Для большего удобства обычно в теле указанного условного оператора вызывают функцию main(), а основной код программы оформляют уже внутри этой функции.
Тогда наш модуль можно переписать так:

def hello(name):
    return f"Привет, {name}!"


def main():
    print(hello(input("Введите своё имя: ")))


if __name__ == "__main__":
    main()

Обратите внимание: при импорте модуля мы можем с помощью символа * указать, что необходимо импортировать все объекты. Например, так:

from some_module import *

Однако делать так крайне не рекомендуется, потому что все объекты модуля добавляются в пространство имён нашей программы, что может приводить к конфликтам.

Исключения (exceptions) — ещё один тип данных в python. Исключения необходимы для того, чтобы сообщать программисту об ошибках.

Самый простейший пример исключения — деление на ноль:

>>> 100 / 0
Traceback (most recent call last):
  File "", line 1, in
    100 / 0
ZeroDivisionError: division by zero

Разберём это сообщение подробнее: интерпретатор нам сообщает о том, что он поймал исключение и напечатал информацию (Traceback (most recent call last)).

Далее имя файла (File «»). Имя пустое, потому что мы находимся в интерактивном режиме, строка в файле (line 1);

Выражение, в котором произошла ошибка (100 / 0).

Название исключения (ZeroDivisionError) и краткое описание исключения (division by zero).

Разумеется, возможны и другие исключения:

>>> 2 + '1'
Traceback (most recent call last):
  File "", line 1, in
    2 + '1'
TypeError: unsupported operand type(s) for +: 'int' and 'str'

>>> int('qwerty')
Traceback (most recent call last):
  File "", line 1, in
    int('qwerty')
ValueError: invalid literal for int() with base 10: 'qwerty'

В этих двух примерах генерируются исключения TypeError и ValueError соответственно. Подсказки дают нам полную информацию о том, где порождено исключение, и с чем оно связано.

Рассмотрим иерархию встроенных в python исключений, хотя иногда вам могут встретиться и другие, так как программисты могут создавать собственные исключения. Данный список актуален для python 3.3, в более ранних версиях есть незначительные изменения.

• BaseException — базовое исключение, от которого берут начало все остальные.
  • SystemExit — исключение, порождаемое функцией sys.exit при выходе из программы.
  • KeyboardInterrupt — порождается при прерывании программы пользователем (обычно сочетанием клавиш Ctrl+C).
  • GeneratorExit — порождается при вызове метода close объекта generator.
  • Exception — а вот тут уже заканчиваются полностью системные исключения (которые лучше не трогать) и начинаются обыкновенные, с которыми можно работать.
    • StopIteration — порождается встроенной функцией next, если в итераторе больше нет элементов.
    • ArithmeticError — арифметическая ошибка.
      • FloatingPointError — порождается при неудачном выполнении операции с плавающей запятой. На практике встречается нечасто.
      • OverflowError — возникает, когда результат арифметической операции слишком велик для представления. Не появляется при обычной работе с целыми числами (так как python поддерживает длинные числа), но может возникать в некоторых других случаях.
      • ZeroDivisionError — деление на ноль.
    • AssertionError — выражение в функции assert ложно.
    • AttributeError — объект не имеет данного атрибута (значения или метода).
    • BufferError — операция, связанная с буфером, не может быть выполнена.
    • EOFError — функция наткнулась на конец файла и не смогла прочитать то, что хотела.
    • ImportError — не удалось импортирование модуля или его атрибута.
    • LookupError — некорректный индекс или ключ.
      • IndexError — индекс не входит в диапазон элементов.
      • KeyError — несуществующий ключ (в словаре, множестве или другом объекте).
    • MemoryError — недостаточно памяти.
    • NameError — не найдено переменной с таким именем.
      • UnboundLocalError — сделана ссылка на локальную переменную в функции, но переменная не определена ранее.
    • OSError — ошибка, связанная с системой.
      • BlockingIOError
      • ChildProcessError — неудача при операции с дочерним процессом.
      • ConnectionError — базовый класс для исключений, связанных с подключениями.
        • BrokenPipeError
        • ConnectionAbortedError
        • ConnectionRefusedError
        • ConnectionResetError
      • FileExistsError — попытка создания файла или директории, которая уже существует.
      • FileNotFoundError — файл или директория не существует.
      • InterruptedError — системный вызов прерван входящим сигналом.
      • IsADirectoryError — ожидался файл, но это директория.
      • NotADirectoryError — ожидалась директория, но это файл.
      • PermissionError — не хватает прав доступа.
      • ProcessLookupError — указанного процесса не существует.
      • TimeoutError — закончилось время ожидания.
    • ReferenceError — попытка доступа к атрибуту со слабой ссылкой.
    • RuntimeError — возникает, когда исключение не попадает ни под одну из других категорий.
    • NotImplementedError — возникает, когда абстрактные методы класса требуют переопределения в дочерних классах.
    • SyntaxError — синтаксическая ошибка.
      • IndentationError — неправильные отступы.
        • TabError — смешивание в отступах табуляции и пробелов.
    • SystemError — внутренняя ошибка.
    • TypeError — операция применена к объекту несоответствующего типа.
    • ValueError — функция получает аргумент правильного типа, но некорректного значения.
    • UnicodeError — ошибка, связанная с кодированием / раскодированием unicode в строках.
      • UnicodeEncodeError — исключение, связанное с кодированием unicode.
      • UnicodeDecodeError — исключение, связанное с декодированием unicode.
      • UnicodeTranslateError — исключение, связанное с переводом unicode.
    • Warning — предупреждение.

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

Первый пример применения этой конструкции:

>>> try:
...     k = 1 / 0
... except ZeroDivisionError:
...     k = 0
...
>>> print(k)
0

В блоке try мы выполняем инструкцию, которая может породить исключение, а в блоке except мы перехватываем их. При этом перехватываются как само исключение, так и его потомки. Например, перехватывая ArithmeticError, мы также перехватываем FloatingPointError, OverflowError и ZeroDivisionError.

>>> try:
...     k = 1 / 0
... except ArithmeticError:
...     k = 0
...
>>> print(k)
0

Также возможна инструкция except без аргументов, которая перехватывает вообще всё (и прерывание с клавиатуры, и системный выход и т. д.). Поэтому в такой форме инструкция except практически не используется, а используется except Exception. Однако чаще всего перехватывают исключения по одному, для упрощения отладки (вдруг вы ещё другую ошибку сделаете, а except её перехватит).

Ещё две инструкции, относящиеся к нашей проблеме, это finally и else. Finally выполняет блок инструкций в любом случае, было ли исключение, или нет (применима, когда нужно непременно что-то сделать, к примеру, закрыть файл). Инструкция else выполняется в том случае, если исключения не было.

>>> f = open('1.txt')
>>> ints = []
>>> try:
...     for line in f:
...         ints.append(int(line))
... except ValueError:
...     print('Это не число. Выходим.')
... except Exception:
...     print('Это что ещё такое?')
... else:
...     print('Всё хорошо.')
... finally:
...     f.close()
...     print('Я закрыл файл.')
...     # Именно в таком порядке: try, группа except, затем else, и только потом finally.
...
Это не число. Выходим.
Я закрыл файл.

Error in Python can be of two types i.e. Syntax errors and Exceptions. Errors are the problems in a program due to which the program will stop the execution. On the other hand, exceptions are raised when some internal events occur which changes the normal flow of the program.
Note: For more information, refer to Errors and Exceptions in Python
Some of the common Exception Errors are : 
 

• IOError: if the file can’t be opened
• KeyboardInterrupt: when an unrequired key is pressed by the user
• ValueError: when the built-in function receives a wrong argument
• EOFError: if End-Of-File is hit without reading any data
• ImportError: if it is unable to find the module

Try Except in Python

Try and Except statement is used to handle these errors within our code in Python. The try block is used to check some code for errors i.e the code inside the try block will execute when there is no error in the program. Whereas the code inside the except block will execute whenever the program encounters some error in the preceding try block.
 

Syntax: 

try:
    # Some Code
except:
    # Executed if error in the
    # try block

How try() works? 
 

• First, the try clause is executed i.e. the code between try.
• If there is no exception, then only the try clause will run, except clause is finished.
• If any exception occurs, the try clause will be skipped and except clause will run.
• If any exception occurs, but the except clause within the code doesn’t handle it, it is passed on to the outer try statements. If the exception is left unhandled, then the execution stops.
• A try statement can have more than one except clause

Code 1: No exception, so the try clause will run. 
 

Auxiliary Space: O(1)

Output : 
 

Yeah ! Your answer is : 1

Code 1: There is an exception so only except clause will run. 
 

Output : 
 

Sorry ! You are dividing by zero

 Code 2:  The other way of writing except statement, is shown below and in this way, it only accepts exceptions that you’re meant to catch or you can check which error is occurring.

Output:

The error is:  unsupported operand type(s) for //: 'int' and 'str'
The error is:  integer division or modulo by zero

Else Clause

In Python, you can also use the else clause on the try-except block which must be present after all the except clauses. The code enters the else block only if the try clause does not raise an exception.
 

Syntax:

try:
    # Some Code
except:
    # Executed if error in the
    # try block
else:
    # execute if no exception

Code:

Output:

-5.0
a/b result in 0

Finally Keyword in Python

Python provides a keyword finally, which is always executed after the try and except blocks. The final block always executes after the normal termination of the try block or after the try block terminates due to some exceptions.
 

Syntax:

try:
    # Some Code
except:
    # Executed if error in the
    # try block
else:
    # execute if no exception
finally:
    # Some code .....(always executed)

Code:

Output:

Can't divide by zero
This is always executed

Related Articles: 
 

• Output Questions
• Exception Handling in Python
• User-Defined Exceptions

This article is contributed by Mohit Gupta_OMG 😀. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
 

Last Updated :
13 Apr, 2023

Like Article

Save Article

() translation by (you can also view the original English article)

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

Исключения отличаются от синтаксических ошибок. Они возникают во время выполнения программы, когда происходит что-то неожиданное. Например, допустим, вы просите пользователя ввести число для выполнения деления.  Теперь, если пользователь вводит строку вместо числа, а вы пытаетесь разделить число на указанные данные, программа выведет TypeError.

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

1

keep_asking = True

2

3

while keep_asking:

4

    x = int(input("Enter a number: "))

5

    print("Dividing 50 by", x,"will give you :", 50/x)

Пока вы вводите значение в виде целого числа, программа будет работать правильно. Однако, как только вы введёте строку или даже десятичное число, вы получите исключение ValueError.

Из этого урока вы узнаете, как правильно обрабатывать и создавать исключения в Python.

Некоторые общие исключения

Вот некоторые основные исключения, которые могут возникнуть при написании программ. Вы можете прочитать о многих других встроенных исключениях на официальном сайте.

• NameError: это исключение возникает, когда программа не может найти локальное или глобальное имя. Имя, которое не удалось найти, включено в сообщение об ошибке.
• TypeError: это исключение возникает, когда функция передается объекту несоответствующего типа в качестве аргумента. Более подробная информация о неправильном типе содержится в сообщении об ошибке.
• ValueError: это исключение возникает, когда аргумент функции имеет правильный тип, но недопустимое значение.
• NotImplementedError: это исключение возникает, когда объект должен поддерживать операцию, но он ещё не реализован. Вы не должны использовать эту ошибку, если данная функция не предназначена для поддержки типа входящего аргумента. В таких ситуациях более целесообразно подбрасывать исключение TypeError.
• ZeroDivisionError: это исключение возникает, когда вы предоставляете второй аргумент для операции деления по модулю равный ноль.
• FileNotFoundError: это исключение возникает, когда файл или каталог, запрошенные программой, не существуют.

Так же, как и названия перечисленные выше, у большинства исключений понятные имена.

Обработка исключения

Код в начале статьи просил пользователей ввести целое число. Если пользователь не предоставлял целое число, программа прекращала работу и вызвала исключение по ошибке значения. В этом разделе мы напишем некоторый код, чтобы сообщить пользователю, что то, что он ввёл не является допустимым целым значением.

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

1

keep_asking = True

2

3

while keep_asking:

4

    try:

5

        x = int(input("Please enter a number: "))

6

        print("Dividing 50 by", x,"will give you :", 50/x)

7

    except ValueError:

8

        print("The input was not an integer. Please try again...")

Здесь происходит так, что программа пытается выполнить код внутри блока try. Если исключение не возникло, программа пропускает предложение except и остальная часть кода выполняется нормально. Если возникает исключение, программа пропускает оставшийся код внутри блока try, а тип исключения сопоставляется с именем исключения после ключевого слова except. В случае совпадения, сначала выполняется код под except, а, затем, после try, остальная часть кода выполняется нормально.

Когда вы вводите целое число, программа дает окончательный результат деления. Когда предоставляется нецелое значение, программа печатает сообщение с просьбой снова ввести целое число. Обратите внимание, что на этот раз программа не прерывается, когда вы предоставляете какие-либо недопустимые данные.

У вас может быть несколько except, для обработки разных исключений. Имейте в виду, что эти обработчики будут иметь дело только с исключениями, которые произошли в соответствующем блоке try. Исключения, возникающие в других обработчиках исключений обрабатываться не будут.

Вы также можете обрабатывать несколько исключений с помощью отдельного блока except, передавая эти исключения как tuple.

1

except (ZeroDivisionError, ValueError, TypeError):

2

    print("Something has gone wrong..")

3

    # code to deal with the exception

Наконец, вы также можете оставить название исключения после ключевого слова except. Обычно это не рекомендуется, так как теперь код будет захватывать все исключения и обрабатывать их таким же образом. Это не оптимальный вариант, так как исключение TypeError будет обрабатываться так же, как если бы вы обработали исключение ZeroDivisionError. При обработке исключений лучше быть как можно более конкретным и отлавливать только то, что вы можете обработать.

Одно из возможных способов использования всех исключений — правильно распечатать ошибку с исключением на экране, например, вот так:

1

import math

2

import sys

3

4

try:

5

    result = math.factorial(2.4)

6

except:

7

    print("Something Unexpected has happened.",sys.exc_info()[0])

8

else:

9

    print("The factorial is", result)

Использование else

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

В нашем случае мы могли бы переместить строку, которая напечатает результат нашего деления внутрь блока else.

1

keep_asking = True

2

3

while keep_asking:

4

    try:

5

        x = int(input("Please enter a number: "))

6

    except ValueError:

7

        print("The input was not a valid integer. Please try again...")

8

    else:

9

        print("Dividing 50 by", x,"will give you :", 50/x)

Очистка с помощью finally

Допустим, вы написали код в блоке try, который должен выполнять задачу, используя большой объем ресурсов. Важно вернуть эти ресурсы, когда вы закончите их использовать. Достичь это можно, используя finally.

Код внутри finally всегда выполняется независимо от того, вызвал ли блок try исключение. Вы можете проверить это, выполнив следующий код:

1

keep_asking = True

2

3

while keep_asking:

4

    try:

5

        x = int(input("Please enter a number: "))

6

    except ValueError:

7

        print("The input was not a valid integer. Please try again...")

8

    else:

9

        print("Dividing 50 by", x,"will give you :", 50/x)

10

    finally:

11

        print("Already did everything necessary.")

Если какое-либо из описанных вами except не обрабатывает вызванное исключение, то такое же исключение снова возникнет после выполнения кода в блоке finally.

Более сложный пример

В этом разделе мы напишем программу для обработки нескольких исключений. Как и в предыдущих примерах, мы выполним некоторые математические операции. Однако на этот раз мы возьмем данные из списка.

Следующий код проверяет два исключения: TypeError и ValueError. Блок else используется для вывода факториала. Вы можете видеть на выходе, что этот код выполняется только тогда, когда исключение не выбрасывается.

1

import math

2

3

number_list = [10,-5,1.2,'apple']

4

5

for number in number_list:

6

    try:

7

        number_factorial = math.factorial(number)

8

    except TypeError:

9

        print("Factorial is not supported for given input type.")

10

    except ValueError:

11

        print("Factorial only accepts positive integer values.", number," is not a positive integer.")

12

    else:

13

        print("The factorial of",number,"is", number_factorial)

14

    finally:

15

        print("Release any resources in use.")

Вышеприведенный код выводит следующий результат:

1

The factorial of 10 is 3628800

2

Releasing any resources in use.

3

4

Factorial only accepts positive integer values. -5  is not a positive integer.

5

Releasing any resources in use.

6

7

Factorial only accepts positive integer values. 1.2  is not a positive integer.

8

Releasing any resources in use.

9

10

Factorial is not supported for given input type.

11

Releasing any resources in use.

Ещё одна вещь, заслуживающая внимания, заключается в том, что код внутри finally выполняется для каждого элемента в списке.

Заключительные мысли

Надеюсь, этот урок поможет вам понять обработку исключений в Python. Кроме того, не стесняйтесь посмотреть, что у нас есть на продажу и для изучения на рынке, и не стесняйтесь задавать любые вопросы и предоставлять ценную обратную связь, используя приведенный ниже канал.

Правильное использование исключений может быть очень полезно в ситуациях, когда выход из программы после получения неожиданного ввода не является корректным. Если у вас есть вопросы, связанные с обработкой исключений в Python, пожалуйста, дайте мне знать в комментариях.