Модель исключений Python — Основы 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 :
    
except :
    
.
 
 ..
else:
    
finally:
    код>код>код>классисключения_2>код>классисключения_1>код>

Блок 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 *

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

Работа с исключениями try/except/else/finally — Python для сетевых инженеров

Toggle table of contents sidebar

try/except

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

Как правило, Python довольно понятно реагирует на подобные ошибки, и их можно исправить.

Тем не менее, даже если код синтаксически написан правильно, могут возникать ошибки. В Python эти ошибки называются исключения (exceptions).

Примеры исключений:

In [1]: 2/0
-----------------------------------------------------
ZeroDivisionError: division by zero
In [2]: 'test' + 2
-----------------------------------------------------
TypeError: must be str, not int

В данном случае возникло два исключения: ZeroDivisionError и TypeError.

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

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

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

Примечание

Когда в программе возникает исключение, она сразу завершает работу.

Для работы с исключениями используется конструкция try/except:

In [3]: try:
   ...:     2/0
   ...: except ZeroDivisionError:
   ...:     print("You can't divide by zero")
   ...:
You can't divide by zero

Конструкция try работает таким образом:

  • сначала выполняются выражения, которые записаны в блоке try

  • если при выполнения блока try не возникло никаких исключений, блок except пропускается, и выполняется дальнейший код

  • если во время выполнения блока try в каком-то месте возникло исключение, оставшаяся часть блока try пропускается

    • если в блоке except указано исключение, которое возникло, выполняется код в блоке except

    • если исключение, которое возникло, не указано в блоке except, выполнение программы прерывается и выдается ошибка

Обратите внимание, что строка Cool! в блоке try не выводится:

In [4]: try:
   . ..:     print("Let's divide some numbers")
   ...:     2/0
   ...:     print('Cool!')
   ...: except ZeroDivisionError:
   ...:     print("You can't divide by zero")
   ...:
Let's divide some numbers
You can't divide by zero

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

Например, скрипт divide.py делит два числа введенных пользователем:

# -*- coding: utf-8 -*-
try:
    a = input("Введите первое число: ")
    b = input("Введите второе число: ")
    print("Результат: ", int(a)/int(b))
except ValueError:
    print("Пожалуйста, вводите только числа")
except ZeroDivisionError:
    print("На ноль делить нельзя")

Примеры выполнения скрипта:

$ python divide.py
Введите первое число: 3
Введите второе число: 1
Результат:  3
$ python divide.py
Введите первое число: 5
Введите второе число: 0
На ноль делить нельзя
$ python divide.py
Введите первое число: qewr
Введите второе число: 3
Пожалуйста, вводите только числа

В данном случае исключение ValueError возникает, когда пользователь ввел строку вместо числа, во время перевода строки в число.

Исключение ZeroDivisionError возникает в случае, если второе число было равным 0.

Если нет необходимости выводить различные сообщения на ошибки ValueError и ZeroDivisionError, можно сделать так (файл divide_ver2.py):

# -*- coding: utf-8 -*-
try:
    a = input("Введите первое число: ")
    b = input("Введите второе число: ")
    print("Результат: ", int(a)/int(b))
except (ValueError, ZeroDivisionError):
    print("Что-то пошло не так...")

Проверка:

$ python divide_ver2.py
Введите первое число: wer
Введите второе число: 4
Что-то пошло не так...
$ python divide_ver2.py
Введите первое число: 5
Введите второе число: 0
Что-то пошло не так...

Примечание

В блоке except можно не указывать конкретное исключение или исключения. В таком случае будут перехватываться все исключения.

Это делать не рекомендуется!

try/except/else

В конструкции try/except есть опциональный блок else. Он выполняется в том случае, если не было исключения.

Например, если необходимо выполнять в дальнейшем какие-то операции с данными, которые ввел пользователь, можно записать их в блоке else (файл divide_ver3.py):

# -*- coding: utf-8 -*-
try:
    a = input("Введите первое число: ")
    b = input("Введите второе число: ")
    result = int(a)/int(b)
except (ValueError, ZeroDivisionError):
    print("Что-то пошло не так...")
else:
    print("Результат в квадрате: ", result**2)

Пример выполнения:

$ python divide_ver3.py
Введите первое число: 10
Введите второе число: 2
Результат в квадрате:  25
$ python divide_ver3.py
Введите первое число: werq
Введите второе число: 3
Что-то пошло не так...

try/except/finally

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

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

Файл divide_ver4. py с блоком finally:

# -*- coding: utf-8 -*-
try:
    a = input("Введите первое число: ")
    b = input("Введите второе число: ")
    result = int(a)/int(b)
except (ValueError, ZeroDivisionError):
    print("Что-то пошло не так...")
else:
    print("Результат в квадрате: ", result**2)
finally:
    print("Вот и сказочке конец, а кто слушал - молодец.")

Проверка:

$ python divide_ver4.py
Введите первое число: 10
Введите второе число: 2
Результат в квадрате:  25
Вот и сказочке конец, а кто слушал - молодец.
$ python divide_ver4.py
Введите первое число: qwerewr
Введите второе число: 3
Что-то пошло не так...
Вот и сказочке конец, а кто слушал - молодец.
$ python divide_ver4.py
Введите первое число: 4
Введите второе число: 0
Что-то пошло не так...
Вот и сказочке конец, а кто слушал - молодец.

Когда использовать исключения

Как правило, один и тот же код можно написать и с использованием исключений, и без них.

Например, этот вариант кода:

while True:
    a = input("Введите число: ")
    b = input("Введите второе число: ")
    try:
        result = int(a)/int(b)
    except ValueError:
        print("Поддерживаются только числа")
    except ZeroDivisionError:
        print("На ноль делить нельзя")
    else:
        print(result)
        break

Можно переписать таким образом без try/except (файл try_except_divide. py):

while True:
    a = input("Введите число: ")
    b = input("Введите второе число: ")
    if a.isdigit() and b.isdigit():
        if int(b) == 0:
            print("На ноль делить нельзя")
        else:
            print(int(a)/int(b))
            break
    else:
        print("Поддерживаются только числа")

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

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

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

raise

Иногда в коде надо сгенерировать исключение, это можно сделать так:

raise ValueError("При выполнении команды возникла ошибка")

Встроенные исключения

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

Например, TypeError обычно генерируется когда ожидался один тип данных, а передали другой

In [1]: "a" + 3
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-1-5aa8a24e3e06> in <module>
----> 1 "a" + 3
TypeError: can only concatenate str (not "int") to str

ValueError когда значение не соответствует ожидаемому:

In [2]: int("a")
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-2-d9136db7b558> in <module>
----> 1 int("a")
ValueError: invalid literal for int() with base 10: 'a'

Python Попробуйте, кроме

❮ Предыдущий Далее ❯

Блок try позволяет протестировать блок кода ошибок.

Блок кроме позволяет справиться с ошибкой.

Блок else позволяет выполнить код, когда нет ошибки.

Блок finally позволяет выполнять код независимо от результата блоков try- и exclude.

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

Когда возникает ошибка или исключение, как мы его называем, Python обычно останавливается и генерировать сообщение об ошибке.

Эти исключения можно обработать с помощью оператора try :

Пример

Блок try создаст исключение, потому что x не определено:

try:
 print(x)
кроме:
  print(«Произошло исключение»)

Попробуйте самостоятельно »

Поскольку блок try вызывает ошибку, блок exclude будет казнен.

Без блока try программа вылетит и выдаст ошибку:

Пример

Этот оператор вызовет ошибку, потому что x не определено:

print(x)

Попробуйте сами »

Множество исключений

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

Пример

Печатать одно сообщение, если блок try вызывает NameError и другое для других ошибок:

попробуйте:
  print(x)
кроме NameError:
  print(«Переменная x не определен»)
кроме:
  print(«Что-то еще пошло неправильно»)

Попробуйте сами »

Else

Вы можете использовать ключевое слово else для определения блок кода, который должен быть выполнен, если ошибок не возникло:

Пример

В этом примере блок try не генерировать любую ошибку:

попробовать:
 print(«Привет»)
кроме:
 print(«Что-то пошло неправильно»)
else:
  print(«Все пошло не так»)

Попробуйте сами »

finally

Блок finally , если он указан, будет выполнен независимо от того, блокирует ли попытка выдает ошибку или нет.

Пример

try:
  print(x)
кроме:
  print(«Что-то пошло неправильно»)
finally:
  print(«Попытка исключения завершена»)

Попробуйте сами »

Это может быть полезно для закрытия объектов и очистки ресурсов:

Пример

Попытаться открыть и записать в файл, недоступный для записи:

try:
 f = open(«demofile.txt»)
 try:
f.write(«Lorum Ipsum»)
  кроме:
print(«Что-то пошло не так при записи в файл»)
  finally:
f.close()
кроме:
  print(«Что-то пошло не так при открытии файл»)

Попробуйте сами »

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

Инициировать исключение

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

Чтобы сгенерировать (или вызвать) исключение, используйте ключевое слово raise .

Пример

Выдать ошибку и остановить программу, если x меньше 0:

x = -1

, если x < 0:
  поднять Exception(«Извините, ниже нет чисел нуля»)

Попробуйте сами »

Ключевое слово поднять используется для повышения исключение.

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

Пример

Вызов TypeError, если x не является целым числом:

x = «hello»

если не type(x) is int:
 raise TypeError(«Только разрешены целые числа»)

Попробуйте сами »

❮ Предыдущая Следующий ❯


ВЫБОР ЦВЕТА

Лучшие учебники
Учебное пособие по HTML
Учебное пособие по CSS
Учебное пособие по JavaScript
Как учебное пособие
SQL Tuperial
Python Tutorial
W3. CSS Учебник
Учебник по началу
Учебник PHP
Java Tutorial
C ++ Учебник
JQUERY Учебник

TOP. HTML Reference

CSS Reference
JavaScript Reference
SQL Reference
Python Reference
W3.CSS Reference
Bootstrap Reference
PHP Reference
HTML Colors
Java Reference
Angular Reference
jQuery Reference

Лучшие примеры
Примеры HTML
Примеры CSS
Примеры JavaScript
Примеры инструкций
Примеры SQL
Примеры Python
Примеры W3.CSS
Примеры Bootstrap
Примеры PHP
Примеры Java
Примеры XML
Примеры jQuery

ФОРУМ | О

W3Schools оптимизирован для обучения и обучения. Примеры могут быть упрощены для улучшения чтения и обучения. Учебники, ссылки и примеры постоянно пересматриваются, чтобы избежать ошибок, но мы не можем гарантировать полную правильность всего содержания. Используя W3Schools, вы соглашаетесь прочитать и принять наши условия использования, куки-файлы и политика конфиденциальности.

Copyright 1999-2023 Refsnes Data. Все права защищены.
W3Schools использует W3.CSS.

Python Try Except — GeeksforGeeks

Ошибка в Python может быть двух типов: синтаксические ошибки и исключения. Ошибки — это проблемы в программе, из-за которых программа останавливает выполнение. С другой стороны, исключения возникают, когда происходят некоторые внутренние события, которые изменяют нормальный ход программы.
Примечание: Дополнительные сведения см. в разделе Ошибки и исключения в Python 9.0039 Некоторые из распространенных ошибок исключения:

  • IOError: , если файл не может быть открыт
  • KeyboardInterrupt: , когда пользователь нажимает ненужную клавишу 9 0258
  • ValueError: , когда встроенная функция получает неправильный аргумент
  • EOFError: , если нажат конец файла без чтения каких-либо данных
  • ImportError: , если не удается найти модуль

 

Try Except in Python

Оператор Try and Except используется для обработки этих ошибок в нашем коде Python. Блок try используется для проверки некоторого кода на наличие ошибок, т. е. код внутри блока try будет выполняться, когда в программе нет ошибок. Принимая во внимание, что код внутри блока exclude будет выполняться всякий раз, когда программа сталкивается с какой-либо ошибкой в ​​предыдущем блоке try.
 

Синтаксис:  

 попробуйте:
    # Некоторый код
кроме:
    # Выполняется, если ошибка в
    # попробуйте блок

Как работает функция try()?  
 

  • Сначала выполняется предложение try , то есть код между try.
  • Если исключения нет, то будет выполняться только предложение try , за исключением предложения .
  • Если возникает какое-либо исключение, предложение try будет пропущено, и будет выполнено предложение , кроме .
  • Если возникает какое-либо исключение, но предложение , кроме в коде, не обрабатывает его, оно передается внешнему попробуйте утверждений. Если исключение остается необработанным, выполнение останавливается.
  • Оператор try может иметь более одного , кроме пункта .
     

    Python3

    def разделить(x, y):

         90 006 попытка :

            

             результат = x / / y

    9000 6          print ( "Да! Ваш ответ:" , результат)

         кроме ZeroDivisionError:

             print ( "Извините! Вы делите на ноль" )

     

    разделить( 3 , 2 )

    Вспомогательное пространство: 9024 8 O(1)

    Вывод: 

     Да! Ваш ответ: 1

    Код 1: Существует исключение, поэтому будет работать только пункт , кроме пункта .
     

    Python3

    def разделить(x, y):

         90 006 попробуй :

            

             результат = x 900 07 / / y

             print ( "Да! Ваш ответ :" 900 07 , результат)

         кроме ZeroDivisionError:

             print ( "Извините! Вы делите на ноль" )

     

    разделить( 3 , 0 )

    Результат: 

     Извините! Вы делите на ноль

      Код 2:   Другой способ записи оператора , кроме , показан ниже, и таким образом он принимает только исключения, которые вы должны перехватывать, или вы можете проверить, какая ошибка возникает.

    Python3

    9 0421

    def разделить(x, y):

         попробовать : 9000 3

            

             результат = x / / 90 007 y

             print ( "Да ! Ваш ответ :" , результат)

    90 043      кроме Исключение как e:

           

             print ( "Ошибка: " , д)

     

             

    разделить( 3 , "GFG" )

    разделить( 3 , 0 )

    Вывод: 

     Ошибка: неподдерживаемый тип(ы) операнда для //: 'int ' и 'ул'
Ошибка: целочисленное деление или по модулю на ноль

     

    Предложение Else

    В Python вы также можете использовать предложение else в блоке try-except, которое должно присутствовать после всех предложений исключения. Код входит в блок else только в том случае, если предложение try не вызывает исключения.
     

    Синтаксис: 

     попытка:
    # Некоторый код
кроме:
    # Выполняется, если ошибка в
    # пробный блок
еще:
    # выполнить, если нет исключений

    Код:

    Python3

       

    def AbyB(a , b):

         попытка :

             c = ((a + b) / / (a - b))

         кроме ZeroDivisionError: 9 0007

             print ( "a/b результат 0" )

         еще :

             печать (c)

       

    AbyB( 2. 0 , 3.0 )

    AbyB( 3.0 , 3.0 )

    Выход: 9 0248

     -5,0
a/b результат 0

     

    Ключевое слово finally в Python

    Python предоставляет ключевое слово finally, которое всегда выполняется после блоков try и exclude. Последний блок всегда выполняется после нормального завершения блока попытки или после завершения блока попытки из-за некоторых исключений.
     

    Синтаксис: 

     попытка:
    # Некоторый код
кроме:
    # Выполняется, если ошибка в
    # пробный блок
еще:
    # выполнить, если нет исключения
окончательно:
    # Какой-то код.....(всегда выполняется)

    Код:

    Python3

         

    попытка : 9 0003

         k = 5 / / 0

    900 06      print (k)

         

    кроме ZeroDivisionError:   

         9 0007 печать ( "На ноль делить нельзя" )

             

    наконец :

    900 06     

        

         print ( 'Это всегда выполняется' ) 

    Вывод: 

     Нельзя делить на ноль
Выполняется всегда

    Статьи по теме:  
     

    • Вопросы вывода
    • Обработка исключений в Python
    • Пользовательские исключения

    Эта статья предоставлена ​​ Mohit Gupta_OMG 😀 .

    No related posts.