Python 3 try: Исключения в python. Конструкция try — except для обработки исключений

Содержание

Обработка исключений python — try/except и raise

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

В этом материале речь пойдет о блоках try/except, finally и raise. Вместе с тем будет рассмотрено, как создавать собственные исключения в Python.

2. Обработка исключений в Python

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

3. Блоки try/except

Если код может привести к исключению, его лучше заключить в блок try. Рассмотрим на примере.

try:
    for i in range(3):
        print(3/i)
except:
    print("Деление на 0")
    print("Исключение было обработано")

Программа вывела сообщение, потому что было обработано исключение.

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

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

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

a. Несколько except в Python

У одного блока try может быть несколько блоков except. Рассмотрим примеры с несколькими вариантами обработки.

a, b = 1, 0
try:
    print(a/b)
    print("Это не будет напечатано")
    print('10'+10)
except TypeError:
    print("Вы сложили значения несовместимых типов")
except ZeroDivisionError:
    print("Деление на 0")
Подписывайтесь на телеграм каналы

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

В первом примере первая инструкция приводит к ZeroDivisionError. Эта ошибка обрабатывается в блоке

except, но инструкции в try после первой не исполняются. Так происходит из-за того, что после первого исключения дальнейшие инструкции просто пропускаются. И если подходящий или общий блоки except не удается найти, исключение не обрабатывается. В таком случае оставшаяся часть программы не будет запущена. Но если обработать исключение, то код после блоков except и finally исполнится. Попробуем.

a, b = 1, 0
try:
   print(a/b)
except:
   print("Вы не можете разделить на 0")
print("Будет ли это напечатано?")

Рассмотрим вывод:

Вы не можете разделить на 0
Будет ли это напечатано?

b. Несколько исключений в одном except

Можно использовать один блок except для обработки нескольких исключений. Для этого используются скобки. Без них интерпретатор вернет синтаксическую ошибку.

try:
    print('10'+10)
    print(1/0)
except (TypeError,ZeroDivisionError):
    print("Неверный ввод")
Неверный ввод

c. Общий except после всех блоков except

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

try:
    print('1'+1)
    print(sum)
    print(1/0)
except NameError:
    print("sum не существует")
except ZeroDivisionError:
    print("Вы не можете разделить на 0")
except:
    print("Что-то пошло не так...")
Что-то пошло не так...

Здесь первая инструкция блока пытается осуществить операцию конкатенации строки python с числом. Это приводит к ошибке TypeError. Как только интерпретатор сталкивается с этой проблемой, он проверяет соответствующий блок

except, который ее обработает.

Отдельную инструкцию нельзя разместить между блоками try и except.

try:
    print("1")
print("2")
except:
    print("3")

Это приведет к синтаксической ошибке.

Но может быть только один общий или блок по умолчанию типа except. Следующий код вызовет ошибку «default 'except:' must be last»:

try:
    print(1/0)
except:
    raise
except:
    print("Исключение поймано")
finally:
    print("Хорошо")
print("Пока")

4. Блок finally в Python

После последнего блока except можно добавить блок finally. Он исполняет инструкции при любых условиях.

try:
    print(1/0)
except ValueError:
    print("Это ошибка значения")
finally:
    print("Это будет напечатано в любом случае.")
Это будет напечатано в любом случае.

Traceback (most recent call last):  
  File “<pyshell#113>”, line 2, in <module>  
    print(1/0)
ZeroDivisionError: division by zero

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

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

try:
    print(1/0)
except ZeroDivisionError:
    print(2/0)
finally:
    print("Ничего не происходит")
Ничего не происходит

Traceback (most recent call last):
  File "<pyshell#1>", line 2, in <module>
    print(1/0)
ZeroDivisionError: division by zero

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "<pyshell#1>", line 4, in <module>
    print(2/0)
ZeroDivisionError: division by zero

Как видите, код в блоке finally исполняется в любом случае.

5. Ключевое слово raise в Python

Иногда нужно будет разбираться с проблемами с помощью вызова исключения. Обычная инструкция print тут не сработает.

raise ZeroDivisionError
Traceback (most recent call last):
  File "<pyshell#2>", line 1, in <module>
    raise ZeroDivisionError
ZeroDivisionError

Разберемся на примере операции деления:

a,b=int(input()),int(input())  
if b==0:
    raise ZeroDivisionError
Traceback (most recent call last):
  File "<pyshell#2>", line 3, in <module>
    raise ZeroDivisionError
ZeroDivisionError

Здесь ввод пользователя в переменные a и b конвертируется в целые числа. Затем проверяется, равна ли b нулю. Если да, то вызывается ZeroDivisionError.

Что будет, если то же самое добавить в блоки try-except? Добавим следующее в код. Если запустить его, ввести 1 и 0, будет следующий вывод:

a,b=int(input()),int(input())
try:
    if b==0:
        raise ZeroDivisionError
except:
   print("Деление на 0")
print("Будет ли это напечатано?")
1
0
Деление на 0
Будет ли это напечатано?

Рассмотрим еще несколько примеров, прежде чем двигаться дальше:

raise KeyError
Traceback (most recent call last):
  File “<pyshell#180>”, line 1, in <module>
    raise KeyError
KeyError

a. Raise без определенного исключения в Python

Можно использовать ключевое слово raise и не указывая, какое исключение вызвать. Оно вызовет исключение, которое произошло. Поэтому его можно использовать только в блоке except.

try:
    print('1'+1)
except:
    raise
Traceback (most recent call last):
  File “<pyshell#152>”, line 2, in <module>
    print(‘1’+1)
TypeError: must be str, not int

b. Raise с аргументом в Python

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

raise ValueError("Несоответствующее значение")
Traceback (most recent call last):
  File "<pyshell#3>", line 1, in <module>
    raise ValueError("Несоответствующее значение")
ValueError: Несоответствующее значение

6. assert в Python

Утверждение (assert) — это санитарная проверка для вашего циничного, параноидального «Я». Оно принимает инструкцию в качестве аргумента и вызывает исключение Python, если возвращается значение False. В противном случае выполняет операцию No-operation (NOP).

assert(True)

Если бы инструкция была False?

assert(1==0)
Traceback (most recent call last):
  File “<pyshell#157>”, line 1, in <module>
    assert(1==0)
AssertionError

Возьмем другой пример:

try:
    print(1)
    assert 2+2==4
    print(2)
    assert 1+2==4
    print(3)
except:
    print("assert False.")
    raise
finally:
    print("Хорошо")
print("Пока")

Вывод следующий:

1
2
assert False.
Хорошо
Traceback (most recent call last):
  File “<pyshell#157>”, line 5, in <module>
    assert 1+2==4
AssertionError

Утверждения можно использовать для проверки валидности ввода и вывода в функции.

a. Второй аргумент для assert

Можно предоставить второй аргумент, чтобы дать дополнительную информацию о проблеме.

assert False,"Это проблема"
Traceback (most recent call last):
  File “<pyshell#173>”, line 1, in <module>
    assert False,”Это проблема”
AssertionError: Это проблема

7. Объявление собственных исключений Python

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

class MyError(Exception):
    print("Это проблема")

raise MyError("ошибка MyError")
Traceback (most recent call last):
  File “<pyshell#179>”, line 1, in <module>
    raise MyError(“ошибка MyError”)
MyError: ошибка MyError

Вот и все, что касается обработки исключений в Python.

8. Вывод: обработка исключений Python

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

Обработка исключений в Python 3 (try-except-else) — Перехват и вызов пользовательских

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

Что такое исключения?

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

На сегодняшний день принято выделять такие типы ошибок:

  • Синтаксические – возникают из-за синтаксических погрешностей кода;
  • Логические – проявляются вследствие логических неточностей в алгоритме;
  • Исключения – вызваны некорректными действиями пользователя или системы.

Синтаксические ошибки являются следствием несоблюдения общепринятых норм языка

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

print("Hello World!)

После попытки запуска выдастся текст ошибки:

  File "main.py", line 1
    print("Hello World!)
                       ^
SyntaxError: EOL while scanning string literal

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

def avg(a, b):
    return a + b / 2
print(avg(10, 20))

20

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

print(10 / 0)

После попытки запуска будет выведено:

Traceback (most recent call last):
File "main.py", line 1, in <module>
print(10 / 0)
ZeroDivisionError: division by zero

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

Перехват исключений

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

print("Program started")
print("Opening file...")
f = open("data.txt")
print("Program finished")

После запуск будет выведено:

Program started
Opening file...
Traceback (most recent call last):
  File "main.py", line 3, in <module>
    f = open("data.txt")
FileNotFoundError: [Errno 2] No such file or directory: 'data.txt'

Так как файла с таким именем на жестком диске не обнаружено, программа сгенерировала исключение FileNotFoundError, сообщающее о проблеме с вводом/выводом. Последняя строка кода, в которой обозначается завершение программы, не была отображена на экране. Это значит, что не все операции, предусмотренные алгоритмом, были выполнены из-за проявившегося исключения.

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

print("Program started")
try:
    print("Opening file...")
    f = open("data.txt")
except:
    print("File not found!")
print("Program finished")

Program started
Opening file...
File not found!
Program finished

Как видно из кода выше, блок try содержит опасный код, способный привести к ошибке (отсутствие нужного файла), а блок except включает в себя инструкции, которые следует выполнить в случае возникнувшей проблемы. Теперь если требуемый файл не был найден, программа не станет завершаться, о чем свидетельствует последний вывод функции print.

Несколько блоков except

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

print("Program started")
try:
    print("Opening file...")
    f = open("data.txt")
except FileNotFoundError:
    print("File not found!")
except Exception:
    print("Something gone wrong!")
print("Program finished")

Program started
Opening file...
File not found!
Program finished

Вложенные блоки и else

Блоки try-except могут быть вложенными для более гибкого управления исключениями. В следующем примере демонстрируется попытка открыть текстовый файл и записать в него некую строку. Для каждой цели используется отдельный блок try.

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

В данном случае – else сработает при успешной операции write. По умолчанию файл открывается на чтение в текстовом режиме. Поэтому при открытии файла будем использовать режим “w”. В этом режиме файл открывается на запись. Если файла не было – создается новый, если был – перезаписывается.

print("Program started")
try:
    print("Opening file...")
    f = open("data.txt", "w")
    try:
        print("Writing to file...")
        f.write("Hello World!")
    except Exception:
        print("Something gone wrong!")
    else:
        print("Success!")
except FileNotFoundError:
    print("File not found!")
print("Program finished")

Program started
Opening file...
Writing to file...
Success!
Program finished

finally

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

print("Program started")
try:
    print("Opening file...")
    f = open("data.txt", "w")
    try:
        print("Writing to file...")
        f.write("Hello World!")
    except Exception:
        print("Something gone wrong!")
    else:
        print("Success!")
    finally:
        print("Closing file...")
        f.close()
except FileNotFoundError:
    print("File not found!")
print("Program finished")

Program started
Opening file...
Writing to file...
Success!
Closing file...
Program finished

Иногда такой подход к работе с текстовыми файлами может показаться слишком сложным, так как код, который его реализует, выглядит громоздким. Специально для этого существует конструкция with/as, позволяющая автоматизировать некоторые методы, такие как закрытие файла у соответствующего объекта. Таким образом, сокращается длина написанного кода:

print("Program started")
try:
    print("Writing to file...")
    with open("data.txt", "w") as f:
        f.write("Hello World!")
except Exception:
    print("Something gone wrong!")
print("Program finished")

Program started
Writing to file...
Program finished

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

Управление исключениями

Python позволяет создавать пользовательские исключения. Так же рассмотрим логирование программы.

Пользовательские исключения

Как правило, исключения автоматически вызываются в нужных ситуациях, однако в Python присутствует возможность запускать их самостоятельно. Для этого применяется ключевое слово raise. Следом за ним необходимо создать новый объект типа Exception, который потом можно обработать при помощи привычных конструкций try-except, как в данном примере:

print("Program started")
try:
    raise Exception("User Exception!")
except Exception as e:
    print(str(e))
print("Program finished")

Program started
User Exception!
Program finished

Чтобы описать собственный тип исключения, нужно создать новый класс, унаследованный от базового типа Exception. Это позволит запускать особые виды исключений в ситуациях, когда поведение пользователя не соответствует алгоритму программы. В конструкторе Exception указываем текст исключения. После того, как оно сработало и было перехвачено, можно его получить с помощью str.

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

class NegativeAge(Exception):
    pass
print("Program started")
try:
    age = int(input("Enter your age: "))
    if age < 0:
        raise NegativeAge("Exception: Negative age!")
    print("Success!")
except NegativeAge as e:
    print(e)
print("Program finished")

Program started
Enter your age: -18
Exception: Negative age!
Program finished

Запись в лог

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

import logging
logging.basicConfig(level = logging.DEBUG)
logging.debug("Debug message!")
logging.info("Info message!")
logging.warning("Warning message!")
logging.error("Error message!")
logging.critical("Critical message!")

DEBUG:root:Debug message!
INFO:root:Info message!
WARNING:root:Warning message!
ERROR:root:Error message!
CRITICAL:root:Critical message!

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

С помощью logging на Python можно записывать в лог и исключения. Обычно лог пишется в файл, зададим его как log.txt. Уровень INFO указывает, что сообщения уровней ниже (в данном случае debug) не будут отражаться в логе. Python позволяет в try-except получить текст ошибки, который и запишем:

import logging
logging.basicConfig(filename="log.txt", level = logging.INFO)
try:
    print(10 / 0)
except Exception as e:
    logging.error(str(e))

В log .txt будет добавлена строка сообщения о типе сработавшего исключения “ERROR:root:division by zero”.

Иерархия исключений

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

  • SystemExit – возникает при выходе из программы с помощью sys.exit;
  • KeyboardInterrupt – указывает на прерывание программы пользователем;
  • GeneratorExit – появляется при вызове метода close для объекта generator;
  • Exception – представляет совокупность обычных несистемных исключений.

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

Название Характеристика
ArithmeticError Порождается арифметическими ошибками (операции с плавающей точкой, переполнение числовой переменной, деление на ноль)
AssertionError Возникает при ложном выражении в функции assert
AttributeError Появляется в случаях, когда нужный атрибут объекта отсутствует
BufferError Указывает на невозможность выполнения буферной операции
EOFError Проявляется, когда функция не смогла прочитать конец файла
ImportError Сообщает о неудачном импорте модуля либо атрибута
LookupError Информирует про недействительный индекс или ключ в массиве
MemoryError Возникает в ситуации, когда доступной памяти недостаточно
NameError Указывает на ошибку при поиске переменной с нужным именем
NotImplementedError Предупреждает о том, что абстрактные методы класса должны быть обязательно переопределены в классах-наследниках
OSError Включает в себя системные ошибки (отсутствие доступа к нужному файлу или директории, проблемы с поиском процессов)
ReferenceError Порождается попыткой доступа к атрибуту со слабой ссылкой
RuntimeError Сообщает об исключении, которое не классифицируется
StopIteration Возникает во время работы функции next при отсутствии элементов
SyntaxError Представляет собой совокупность синтаксических ошибок
SystemError Порождается внутренними ошибками системы
TypeError Указывает на то, что операция не может быть выполнена с объектом
UnicodeError Сообщает о неправильной кодировке символов в программе
ValueError Возникает при получении некорректного значения для переменной
Warning Обозначает предупреждение

Заключение

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

Как лучше всего использовать Try Except в Python

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

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

Зачем использовать конструкции Try-Except / Try-Except-else? С помощью Try-Except и Try-Except-Else вы можете избежать многих неизвестных проблем, которые могут возникнуть из вашего кода. Например, код Python, использующий стиль LBYL (Look before you leap), может привести к race условиям. Здесь может помочь try-except. Кроме того, существуют случаи, когда ваш код критически зависит от некоторой информации, которая может устареть до момента ее получения. Например, код, вызывающий вызовы os.path.exists или Queue.full, может завершиться ошибкой, поскольку эти функции могут возвращать данные, которые устаревают к тому времени, когда вы их используете. Более разумным выбором здесь было бы придерживаться в своем коде стиля try-except-else, чтобы более надежно управлять вышеуказанными случаями.

Вызов исключений также допустимо в Python. Это означает, что вы можете бросить или вызвать исключение, когда это необходимо. Вы можете сделать это, просто вызвав в вашем коде raise Exception(‘Test error!’). Возникнувшее исключение прекратит текущее выполнение как обычно и пойдет дальше в стек вызовов, пока не будет обработано

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

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

Python: советы по использованию Try-Except, Try-Except-Else и многое другое

1. Как обращаться с произвольным исключением

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

Это легко достижимо с помощью исключений Python. Проверьте код ниже. Во время тестирования вы можете поместить код внутри блока try как в следующем примере.

try:
    #your code
except Exception as ex:
    print(ex)
2. Поймать несколько исключений в одном блоке Except
except (Exception1, Exception2) as e:
    pass

Обратите внимание, что вы можете отделить исключения от переменной запятой, которая применима в Python 2.6 / 2.7. Но вы не можете сделать это в Python 3. Поэтому вы должны использовать ключевое слово as.

3. Обработка нескольких исключений одним блоком Except

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

try:
    file = open('input-file', 'open mode')
except (IOError, EOFError) as e:
    print("Testing multiple exceptions. {}".format(e.args[-1]))

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

try:
    file = open('input-file', 'open mode')
except EOFError as ex:
    print("Caught the EOF error.")
    raise ex
except IOError as e:
    print("Caught the I/O error.")
    raise ex

Последнее, но не менее важное, это использовать исключение без упоминания какого-либо атрибута исключения.

try:
    file = open('input-file', 'open mode')
except:
    raise

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

4. Повторный проброс исключений в Python

Возникшие когда-либо исключения продолжают перемещаться к вызывающим методам, пока не будут обработаны. Хотя вы можете добавить исключающее предложение, которое может просто вызывать raise без каких-либо аргументов. Это приведет к пересмотру исключения.

Смотрите приведенный ниже пример кода.

try:
    # Преднамеренно бросить исключение.
    raise Exception('I learn Python!')
except:
    print("Entered in except.")
    # Возобновить исключение.
    raise

Вывод:

Entered in except.
Traceback (most recent call last):
  File "python", line 3, in 
Exception: I learn Python!
5. Когда использовать Else

Используйте предложение else сразу после блока try-except. Предложение else будет получено, только если не сгенерировано исключение. Оператор else всегда должен предшествовать блокам except.

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

В примере ниже, вы можете увидеть бесконечный цикл while. Код запрашивает ввод данных пользователем, а затем анализирует его, используя встроенную функцию int(). Если пользователь вводит значение ноль, тогда блоком исключений будет достигнут успех. В противном случае код будет проходить через блок else.

while True:
    x = int(input())

    try:
        result = 1 / x
    except:
        print("Error case")
        exit(0)
    else:
        print("Pass case")
        exit(1)
6. Используйте Finally

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

Ошибка поймана в блоке try. После того, как код в блоке except будет выполнен, инструкции в блоке finally будут выполнены.

Обратите внимание, что блок finally будет ВСЕГДА работать, даже если вы вернулись раньше него.

Смотрите пример ниже.

try:
    x = 1 / 0
except:
    print("Error occurred")
finally:
    print("The [finally clause] is hit")

Вывод:

Error occurred
The [finally clause] is hit
7. Используйте ключевое слово As для отлова определенных типов исключений.

С помощью вы можете создать новый объект. В приведенном ниже примере мы создаем объект IOError и затем используем.

try:
    f = open("no-file")
except IOError as err:
    print("Error:", err)
    print("Code:", err.errno)

Результат:

('Error:', IOError(2, 'No such file or directory'))
('Code:', 2)
8. Лучшая практика для создания исключений

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

Плохой пример:

def bad_exception():
    try:
        raise ValueError('Intentional - do not want this to get caught')
        raise Exception('Exception to be handled')
    except Exception as error:
        print('Inside the except block: ' + repr(error))
        
bad_exception()

Результат:

Inside the except block: ValueError('Intentional - do not want this to get caught',)

Пример получше:

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

try:
    raise ValueError('Testing exceptions: The input is in incorrect order', 'one', 'two', 'four') 
except ValueError as err:
    print(err.args)

Результат:

('Testing exceptions: The input is in incorrect order', 'one', 'two', 'four')
9. Как пропустить ошибки и продолжить выполнение

В идеале, вы не должны этого делать. Но если вы все еще хотите это сделать, следуйте приведенному ниже коду, чтобы проверить правильный подход.

try:
    assert False
except AssertionError:
    pass
print('Welcome to Prometheus!!!')

Результат:

Welcome to Prometheus!!!

Теперь рассмотрим некоторые из наиболее распространенных исключений Python и их примеры.

Наиболее распространенные Exception Errors:

  • IOError — происходит при ошибках файловой системы, например, если файл не открывается.
  • ImportError — Если модуль Python не может быть загружен или не найден.
  • ValueError — происходит, если функция получает аргумент правильного типа, но не подходящего значения.
  • KeyboardInterrupt — когда пользователь вводит ключ прерывания (т.е. Control-C или Del в консоли)
  • EOFError — Возникает, если входные функции (input() / raw_input()) попадают в условие конца файла (EOF), но без чтения каких-либо данных.
Примеры наиболее распространенных исключений
except IOError:
print('Error occurred while opening the file.')

except ValueError:
print('Non-numeric input detected.')

except ImportError:
print('Unable to locate the module.')

except EOFError:
print('Identified EOF error.')

except KeyboardInterrupt:
print('Wrong keyboard input.')

except:
print('An error occurred.')

Резюме — Как лучше всего использовать Try-Except в Python

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

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

Python 3: обработка исключений: try, except, finally, else

На этом занятии мы с вами сделаем введение в очень важную тему – исключения. Помните, когда мы говорили о некоторых методах, например, удаление элемента из пустого списка:

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

также приведет к ошибке ZeroDivisionError. Или такие операции:

int("12abc") #ValueError
"2"+5 #TypeError

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

Давайте вначале предположим, что у нас имеется вот такая программа для вычисления деления двух целых чисел:

x = input("x: ")
y = input("y: ")
x = int(x)
y = int(y)
 
res = x/y
print(res)

Если мы будем вводить целые числа, то она работает корректно, но если ввести в качестве игрека ноль или не числовую величину, то возникнут соответствующие исключения. Так вот, в Python есть механизм для отслеживания (отлавливания) таких моментов в работе программы. Для этого критический по выполнению код следует поместить в блок try:

try:
    x = int(x)
    y = int(y)
 
    res = x/y
except ZeroDivisionError:
    res = "деление на ноль"
print(res)

А после него записать except и название исключения, которое требуется отследить. В данном случае мы отлавливаем деление на ноль, т.е. исключение с именем ZeroDivisionError. Давайте запустим эту программу и посмотрим как она теперь будет работать. Вводим 1 и 0, программа теперь не завершается аварийно и в консоли видим сообщение «деление на ноль».

Более подробно блок try except работает так. Сначала идет выполнение программы внутри блока try. Если все проходит в штатном режиме, то выполнение доходит до блока except и он пропускается, не выполняется. И далее уже вызывается функция print и печатается полученный результат. Если же в процессе выполнения программы блока try возникает какое-либо исключение (любое), то выполнение программы прерывается и управление передается блоку except с соответствующим именем исключения. Если нужное имя в блоке except отсутствует, то исключение переходит на более высокий уровень (в данном случае к среде выполнения Python). И в случае отсутствия обработчика исключение считается необработанным (unhandled exception) и программа завершается аварийно.

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

except (ZeroDivisionError, ValueError):
    res = "деление на ноль или нечисловое значение"

Или, для раздельной обработки, в разных блоках except:

except ZeroDivisionError:
    res = "деление на ноль"
except ValueError:
    res = "одно из введенных значений не число"

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

except ZeroDivisionError as z:
    res = z
except ValueError as v:
    res = v

То есть, после имени исключения (в действительности, это класс, но мы о них пока еще не говорили, поэтому будем воспринимать его просто как имя) ставится ключевое слово as и дальше переменная, которая будет ссылаться на класс ValueError, в котором хранится служебное сообщение о конкретной ошибке. Выводя его с помощью print, мы в консоли видим это сообщение.

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

else:
    print("Исключений не произошло")

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

Другим необязательным блоком является блок finally, который, наоборот, выполняется всегда после блока try, вне зависимости произошла ошибка или нет:

finally:
    print("Блок finally выполняется всегда")

Теперь, при запуске программы, мы всегда будем видеть это сообщение. И здесь часто возникает вопрос: зачем нужен этот блок, если он выполняется всегда после try? Мы с таким же успехом можем записать этот print сразу после этого блока и, вроде бы, все будет работать также? В действительности, нет. Смотрите, если мы, например, уберем блок except с исключением ValueError, запустим программу и введем нечисловые значения, то, конечно, возникнет необработанное исключение, но при этом, блок finally все равно выполнился! Этого не произошло бы, если просто записать print после try.

Или, вот такой пример:

def getValues():
    x = input("x: ")
    y = input("y: ")
    try:
        x = int(x)
        y = int(y)
        return x,y
    except ValueError as v:
        print(v)
        return 0,0
    finally:
        print("finally выполняется до return")
 
x,y = getValues()
print(x,y)

Мы создаем функцию для ввода двух целых чисел и в блоке finally выводим сообщение. Этим сообщением мы покажем, что этот блок будет выполняться до операторов return, присутствующих в функции.

Наконец, мы можем прописывать except без указания имени класса исключения:

x = input("x: ")
y = input("y: ")
try:
    x = int(x)
    y = int(y)
 
    res = x/y
except:
    print("Произошло исключение")
else:
    print("Исключений не произошло")
finally:
    print("Блок finally выполняется всегда")
 
print(res)

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

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

Задания для самоподготовки

1. Напишите программу ввода натуральных чисел через запятую и преобразования этой строки в список целых чисел. (Используйте здесь функцию map для преобразования элементов последовательности строк в последовательность чисел). Реализовать обработку возможных исключений при таком преобразовании.

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

3. Написать функцию-генератор (с использованием оператора yield) для удаления произвольного элемента из множества (с помощью метода pop()). Функция должна возвращать значение удаленного элемента. Реализовать обработку возможных исключений при ее работе.

Обработка исключительных ситуаций в Python

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

Возьмем в качестве примера следующий скрипт. Программа спрашивает у пользователя число и делит сто на это число:

a = float(input("Введите число "))
print(100 / a)

Если пользователь введет информацию, которую мы от него ожидаем, то все сработает как нужно.

Вот что произойдет просто потому, что мы не учли, что на ноль делить нельзя.

А вот что случится, если кто-то специально попытается поломать программу.

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

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

try:
    a = float(input("Введите число:"))
except ValueError:
    print ("Это не число!")

В данном примере программа пытается конвертировать информацию введенную пользователем в тип float, если же при этом возникнет ошибка класса ValueError, то выводится строка «This is not a valid number». В блоке except мы можем задать те классы ошибок на которые данный блок должен сработать, если мы не укажем ожидаемый класс ошибок, то блок будет реагировать на любую возникшую ошибку.

Блок try может содержать неограниченное количество блоков except:

try:
    a = float(input("Введите число: ")
    print (100 / a)
except ValueError:
    print ("Это не число")
except ZeroDivisionError:
    print ("На ноль делить нельзя")

Кроме того мы можем добавить пустой блок except, который будет срабатывать на непредвиденную выше ошибку. Пустой блок except всегда должен идти последним:

try:
    a = float(input("Введите число: ")
    print (100 / a)
except ValueError:
    print ("Это не число!")
except ZeroDivisionError:
    print ("На ноль делить нельзя!")
except:
    print ("Неожиданная ошибка.")

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

try:
    a = float(input("Введите число: ")
    print (100 / a)
except ValueError:
    print ("Это не число!")
except ZeroDivisionError:
    print ("На ноль делить нельзя!")
except:
    print ("Неожиданная ошибка.")
else:
    print ("Код выполнился без ошибок")

В результате, мы получим следующее.

Также у блока except есть еще один необязательный блок finally, который сработает независимо от того, выполнился код с ошибками или без:

try:
    a = float(input("Введите число: ")
    print (100 / a)
except ValueError:
    print ("Это не число!")
except ZeroDivisionError:
    print ("На ноль делить нельзя!")
except:
    print ("Неожиданная ошибка.")
else:
    print ("Код выполнился без ошибок")
finally:
    print ("Я выполняюсь в любом случае!")

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

Обработка исключений в Python с использованием инструкций try, except и finally

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

Исключения в Python

В языке Python существует множество встроенных исключений, которые вызываются, когда программа сталкивается с ошибкой (что-то в программе идет не так).

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

Например, пусть в нашей программе есть функция А, которая вызывает функцию В, которая в свою очередь вызывает функцию С. Если исключение возникнет в функции C, но не будет в этой функции обработано, то оно будет передано в функцию B и далее в функцию А.

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

Перехват исключений в Python

В Python исключения обрабатываются при помощи инструкции try.

Критическая операция, которая может вызвать исключение, помещается внутрь блока try. А код, при помощи которого это исключение будет обработано, — внутрь блока except.

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

# Для получения типа исключения импортируем модуль sys
import sys

randomList = ['a', 0, 2]

for entry in randomList:
    try:
        print("The entry is", entry)
        r = 1/int(entry)
        break
    except:
        print("Oops!", sys.exc_info()[0], "occurred.")
        print("Next entry.")
        print()
print("The reciprocal of", entry, "is", r)
Результат:
The entry is a
Oops! <class 'ValueError'> occurred.
Next entry.

The entry is 0
Oops! <class 'ZeroDivisionError'> occured.
Next entry.

The entry is 2
The reciprocal of 2 is 0.5

В данном примере мы, при помощи цикла for, производим итерацию списка randomList. Как мы ранее заметили, часть кода, в которой может произойти ошибка, помещена внутри блока try.

Если исключений не возникает, блок except пропускается, а программа продолжает выполнятся обычным образом (в данном примере так происходит с последним элементом списка). Но если исключение появляется, оно сразу обрабатывается в блоке except (в данном примере так происходит с первым и вторым элементом списка).

В нашем примере мы вывели на экран имя исключения при помощи функции exc_info(), которую импортировали из модуля sys. Можно заметить, что элемент a вызывает ValueError, а 0 вызывает ZeroDivisionError.

Так как все исключения в Python наследуются из базового класса Exception, мы можем переписать наш код следующим образом:

# Для получения типа исключения импортируем модуль sys
import sys

randomList = ['a', 0, 2]

for entry in randomList:
    try:
        print("The entry is", entry)
        r = 1/int(entry)
        break
    except Exception as e:
        print("Oops!", e.__class__, "occurred.")
        print("Next entry.")
        print()
print("The reciprocal of", entry, "is", r)

Результат выполнения этого кода будет точно таким же.

Перехват определенных исключений в Python

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

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

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

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

try:
   # do something
   pass

except ValueError:
   # handle ValueError exception
   pass

except (TypeError, ZeroDivisionError):
   # handle multiple exceptions
   # TypeError and ZeroDivisionError
   pass

except:
   # handle all other exceptions
   pass

Вызов исключений в Python

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

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

>>> raise KeyboardInterrupt
Traceback (most recent call last):
...
KeyboardInterrupt

>>> raise MemoryError("This is an argument")
Traceback (most recent call last):
...
MemoryError: This is an argument

>>> try:
...     a = int(input("Enter a positive integer: "))
...     if a <= 0:
...         raise ValueError("That is not a positive number!")
... except ValueError as ve:
...     print(ve)
...    
Enter a positive integer: -2
That is not a positive number!

Конструкция try с блоком else

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

Замечание: исключения, возникающие в самом блоке else, не будут обработаны в предшествующем ему блоке except.

Давайте рассмотрим следующий пример:

# программа для вывода на экран обратных значений четных чисел

try:
    num = int(input("Введите число: "))
    assert num % 2 == 0
except:
    print("Число нечетное!")
else:
    reciprocal = 1/num
    print(reciprocal)
Результат:

Если мы вводим нечетное число:

Введите число: 1
Число нечетное!

А если вводим четное, то обратное ему число вычисляется и выводится на экран.

Введите число: 4
0.25

Однако, если мы введем 0, то получим в результате ошибку ZeroDivisionError, так как код в блоке else не обрабатывается в предшествующем ему блоке except.

Введите число: 0
Traceback (most recent call last):
  File "<string>", line 7, in <module>
    reciprocal = 1/num
ZeroDivisionError: division by zero

Конструкция try…finally

Инструкция try может также иметь и необязательный блок finally. Этот блок кода будет выполнен в любом случае и обычно используется для освобождения внешних ресурсов.

Например, мы можем быть подключены через сеть к удаленному дата-центру, или работать с файлом или с GUI (Graphical User Interface — графический интерфейс пользователя).

Во всех таких случаях мы должны закрыть эти ресурсы вне зависимости от того, успешно завершилась наша программа или нет. Все эти действия (закрытие файла или GUI, отключение от сети) можно выполнять в блоке finally, чтобы гарантировать их исполнение.

Вот пример операций с файлом, который иллюстрирует это:

try:
   f = open("test.txt",encoding = 'utf-8')
   # perform file operations
finally:
   f.close()

Такая конструкция гарантирует нам, что файл будет закрыт в любом случае, какое бы исключение в работе кода не возникло.

Как использовать в Python Try-Except

Применение try-except — наиболее распространенный способ обработки ошибок. В этой статье мы познакомимся с лучшими практиками использования try-except в Python.

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

С помощью try-except и try-except-else можно избежать многих проблем, которые могут возникнуть. Например, код Python, использующий стиль LBYL (Look before you leap), может привести к зацикливанию условий. В подобном случае поможет try-except.

Также бывают случаи, когда правильность выполнения кода зависит от актуальности данных. Например, код, вызывающий os.path.exists или Queue.full, может завершиться неудачно. Эти функции могут возвращать данные, которые устаревают к моменту их использования. Поэтому лучше использовать try-except-else.

В Python можно выводить исключение каждый раз, когда это необходимо. Это можно сделать, вызвав из кода [raise Exception (‘Test error!’)]. После чего исключение остановит текущее выполнение и перейдет дальше по стеку вызовов до тех пор, пока исключение не будет обработано.

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

Обработка исключений — это искусство, которое помогает в написании надежного и качественного кода.

Как в Python лучше всего использовать Try-Except

Иногда может понадобиться способ для обработки и вывода сообщения об ошибке.Это можно сделать с помощью исключений Python. Во время тестирования вы можете разместить код внутри блока try.

try:
#вашкод
exceptExceptionas ex:
print(ex)

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

except(Exception1,Exception2)as e:
pass

Обратите внимание, что в Python 2.6 / 2.7 нужно отделить исключения от переменной запятой. Но этого нельзя делать в Python 3. Вместо этого необходимо использовать ключевое слово [as].

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

try:
file= open('input-file','open mode')
except(IOError,EOFError)as e:
print("Testing multiple exceptions. {}".format(e.args[-1]))

Следующий метод — обрабатывать каждое исключение в отдельном блоке except:

try:
file= open('input-file','open mode')
exceptEOFErroras ex:
print("Caught the EOF error.")
raise ex
exceptIOErroras e:
print("Caught the I/O error.")
raiseex

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

try:
file= open('input-file','open mode')
except:
# In case of any unhandled error, throw it away
raise

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

Однажды выведенные исключения продолжают обрабатываться в вызывающих их методах до тех пор, пока они не будут обработаны. Но можно добавить условие except, которое содержит только вызов [raise] без каких-либо аргументов. Это приведет к повторному исключению.

Смотрите приведенный ниже код.

try:
# Намеренноевыведениеисключения.
raiseException('I learn Python!')
except:
print("Entered in except.")
# Повторноевыведениеисключения.
raise

Вывод:

Enteredinexcept.
Traceback(most recent call last):
File"python", line 3,in<module>
Exception: I learn Python!

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

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

В приведенном ниже примере видно, что цикл while работает бесконечно. Код запрашивает значение у пользователя, а затем анализирует его с помощью встроенной функции [int()]. Если пользователь вводит нулевое значение, блок except будет заблокирован. В противном случае код будет проходить через блок else.

whileTrue:
# Введете с консоли целое число.
    x =int(input())

# Разделите 1 на x, чтобы протестировать ошибку
try:
result=1/ x
except:
print("Error case")
exit(0)
else:
print("Pass case")
exit(1)

Если есть код, который должен выполняться во всех случаях, разместите его внутри блока [finally]. Python всегда будет запускать эти инструкции. Это самый распространенный способ выполнения задач очистки. Вы также можете проверить это.

Ошибка перехватывается условием try. После того, как будет выполнен код в блоке except, выполняется инструкции в [finally].

Смотрите приведенный ниже код.

try:
# Намеренно выводим ошибку.
    x =1/0
except:
# УсловиеExcept:
print("Error occurred")
finally:
# УсловиеFinally:
print("The [finally clause] is hit")

Вывод:

Error occurred
The[finally clause]is hit

С помощью <identifier> можно создать объект исключения. В приведенном ниже примере мы создаем объект IOError, а затем используем его внутри условия.

try:
# Намеренно выводим ошибку.
    f = open("no-file")
exceptIOErroras err:
# Создаемэкземпляр IOError дляучета.
print("Error:", err)
print("Code:",err.errno)

Вывод:

('Error:',IOError(2,'No such file or directory'))
('Code:',2)

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

Не рекомендуется:

defbad_exception():
try:
raiseValueError('Intentional - do not want this to get caught')
raiseException('Exception to be handled')
exceptExceptionas error:
print('Inside the except block: '+repr(error))

bad_exception()

Вывод:

Inside the except block:ValueError('Intentional - do not want this to get caught',)

Рекомендуется:

В приведенном ниже примере перехватывается конкретный тип исключения, а не общий. Мы также используем параметр args для вывода некорректных аргументов, если они есть. Рассмотрим этот пример.

try:
raiseValueError('Testing exceptions: The input is in incorrect order','one','two','four')
exceptValueErroras err:
print(err.args)

Вывод:

('Testing exceptions: The input is in incorrect order','one','two','four')

Лучше не применять данную практику. Но если это нужно, то используйте следующий пример.

try:
assertFalse
exceptAssertionError:
pass
print('Welcome to Prometheus!!!')

Вывод:

Рассмотрим наиболее распространенные исключения в Python с примерами.

Распространенные ошибки исключений:

  • IOError–возникает, если файл не открывается.
  • ImportError — если модуль python не может быть загружен или размещен.
  • ValueError — возникает, если функция получает аргумент корректного типа, но с некорректным значением.
  • KeyboardInterrupt — когда пользователь прерывает выполнение кода нажатием на Delили Ctrl-C.
  • EOFError — когда функции input() / raw_input()достигают конца файла (EOF), но без чтения каких-либо данных.

Примеры распространенных исключений

exceptIOError:
print('Error occurred while opening the file.')

exceptValueError:
print('Non-numeric input detected.')

exceptImportError:
print('Unable to locate the module.')

exceptEOFError:
print('Identified EOF error.')

exceptKeyboardInterrupt:
print('Wrong keyboard input.')

except:
print('An error occurred.')

В процессе программирования ошибки неизбежны. Но их можно обработать, используя конструкции try-except или try-except-else, try-except-finally.

Данная публикация представляет собой перевод статьи «How To Best Use Try Except In Python – Especially For Beginners» , подготовленной дружной командой проекта Интернет-технологии.ру

телеграм канал. Подпишись, будет полезно!

8. Ошибки и исключения — документация Python 3.9.0

До сих пор сообщений об ошибках не было больше, чем было упомянуто, но если вы пытались из примеров, которые вы, вероятно, видели. Есть (как минимум) два различимые виды ошибок: синтаксических ошибок и исключений .

8.1. Ошибки синтаксиса

Синтаксические ошибки, также известные как ошибки синтаксического анализа, являются, пожалуй, наиболее распространенным видом жалоба, которую вы получите, пока изучаете Python:

 >>> while True print ('Привет, мир')
  Файл "", строка 1
    в то время как True print ('Привет, мир')
                   ^
SyntaxError: недопустимый синтаксис
 

Синтаксический анализатор повторяет ошибочную строку и отображает небольшую «стрелку», указывающую на самая ранняя точка в строке, где была обнаружена ошибка.Ошибка вызванный (или, по крайней мере, обнаруженный) токеном , предшествующим стрелке: в Например, ошибка обнаружена в функции print () , так как двоеточие ( ':' ) отсутствует перед ним. Имя файла и номер строки печатаются, поэтому вы знать, где искать, если ввод поступил из сценария.

8.2. Исключения

Даже если оператор или выражение синтаксически верны, это может вызвать ошибка при попытке его выполнения. Ошибки, обнаруженные во время выполнения называются исключения и не являются безоговорочно фатальными: вы скоро узнаете как обрабатывать их в программах на Python.Большинство исключений не обрабатываются программы, однако, и приводят к сообщениям об ошибках, как показано здесь:

 >>> 10 * (1/0)
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
ZeroDivisionError: деление на ноль
>>> 4 + спам * 3
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
NameError: имя 'spam' не определено
>>> '2' + 2
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
TypeError: невозможно неявно преобразовать объект int в str
 

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

.

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


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

Блок за исключением позволяет обработать ошибку.

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


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

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

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

Пример

Блок try сгенерирует исключение, поскольку x не определено:

попробуйте:
print (x)
except:
print («Произошло исключение»)

Попробуй сам »

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

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

Пример

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

печать (x)

Попробуй сам »

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

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

Пример

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

попробуйте:
print (x)
except NameError:
print («Variable x не определено «)
за исключением:
print (» Что-то еще пошло неправильно «)

Попробуй сам »

Остальное

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

Пример

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

попробуйте:
print («Привет»)
except:
print («Что-то пошло неправильно «)
else:
print (» Ничего не случилось «)

Попробуй сам »

Наконец

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

Пример

попробуйте:
print (x)
except:
print («Что-то пошло неправильно «)
наконец:
print (» Попытка, кроме «завершена»)

Попробуй сам »

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

Пример

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

попробуйте:
f = open («demofile.txt»)
f.write («Lorum Ipsum»)
за исключением:
print («Что-то пошло неправильно при записи в файл «)
наконец:
ф.закрыть ()

Попробуй сам »

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


Вызов исключения

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

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

Пример

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

x = -1

, если x <0:
вызывать исключение («К сожалению, ниже нет чисел ноль «)

Попробуй сам »

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

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

Пример

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

x = «hello»

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

Попробуй сам »

.

Обработка исключений Python Использование оператора try, except и finally

Исключения в Python

Python имеет множество встроенных исключений, которые возникают, когда ваша программа обнаруживает ошибку (что-то в программе идет не так).

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

Например, давайте рассмотрим программу, в которой у нас есть функция A , которая вызывает функцию B , которая, в свою очередь, вызывает функцию C .Если исключение возникает в функции C , но не обрабатывается в C , исключение переходит к B , а затем к A .

Если никогда не обрабатывать, отображается сообщение об ошибке, и наша программа неожиданно останавливается.


Перехват исключений в Python

В Python исключения можно обрабатывать с помощью оператора try .

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

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

  # import module sys, чтобы получить тип исключения
import sys

randomList = ['а', 0, 2]

для записи в randomList:
    пытаться:
        print ("Запись есть", запись)
        r = 1 / int (запись)
        сломать
    Кроме:
        print («Ой!», sys.exc_info () [0], «произошло.»)
        print ("Следующая запись.")
        Распечатать()
print ("Обратное от", entry, "is", r)  

Выход

  Запись
Ой!  произошел.
Следующая запись.

Запись 0
Ой!  произошел.
Следующая запись.

Запись 2
Обратное 2 равно 0,5  
.

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

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

Здесь мы печатаем имя исключения, используя функцию exc_info () внутри модуля sys . Мы видим, что a вызывает ValueError , а 0 вызывает ZeroDivisionError .

Поскольку каждое исключение в Python наследуется от базового класса Exception , мы также можем выполнить указанную выше задачу следующим образом:

  # import module sys, чтобы получить тип исключения
import sys

randomList = ['а', 0, 2]

для записи в randomList:
    пытаться:
        print ("Запись есть", запись)
        r = 1 / int (запись)
        сломать
    кроме исключения как e:
        print ("Ой!", e.__class__, "произошло".)
        print ("Следующая запись.")
        Распечатать()
print ("Обратное от", entry, "is", r)  

Эта программа имеет тот же вывод, что и вышеприведенная программа.


Перехват особых исключений в Python

В приведенном выше примере мы не упомянули никаких конкретных исключений в , кроме пункта .

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

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

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

  попробуйте:
   # сделай что-нибудь
   проходить

кроме ValueError:
   # обрабатывать исключение ValueError
   проходить

except (TypeError, ZeroDivisionError):
   # обрабатывать несколько исключений
   # TypeError и ZeroDivisionError
   проходить

Кроме:
   # обрабатывать все остальные исключения
   перевал  

Вызов исключений в Python

В программировании на Python при возникновении ошибок во время выполнения возникают исключения.Мы также можем вручную вызывать исключения, используя ключевое слово raise .

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

  >>> поднять KeyboardInterrupt
Отслеживание (последний вызов последний):
...
KeyboardInterrupt

>>> поднять MemoryError ("Это аргумент")
Отслеживание (последний вызов последний):
...
MemoryError: это аргумент

>>> попробуйте:
... a = int (input ("Введите положительное целое число:"))
...если a <= 0:
... поднять ValueError ("Это не положительное число!")
... кроме ValueError as ve:
... печать (ве)
...
Введите положительное целое число: -2
Это не положительное число!  

Python попробуйте с предложением else

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

Примечание : Исключения в разделе else не обрабатываются в предыдущих разделах except.

Давайте посмотрим на пример:

  # программа для вывода обратной величины четных чисел

пытаться:
    num = int (input ("Введите число:"))
    утверждать число% 2 == 0
Кроме:
    print («Не четное число!»)
еще:
    обратный = 1 / число
    печать (обратная)  

Выход

Если передать нечетное число:

  Введите число: 1
Не четное число!  

Если мы передаем четное число, вычисляется и отображается обратная величина.

  Введите число: 4
0,25  

Однако, если мы передадим 0, мы получим ZeroDivisionError в качестве блока кода внутри , иначе не обрабатывается предшествующим , за исключением .

  Введите число: 0
Отслеживание (последний вызов последний):
  Файл «<строка>», строка 7, в <модуле>
    обратный = 1 / число
ZeroDivisionError: деление на ноль  

Python попробуйте ... наконец

Оператор try в Python может иметь необязательное предложение finally .Этот пункт выполняется несмотря ни на что и обычно используется для освобождения внешних ресурсов.

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

Во всех этих обстоятельствах мы должны очистить ресурс до того, как программа остановится независимо от того, успешно она запущена или нет. Эти действия (закрытие файла, графический интерфейс или отключение от сети) выполняются в предложении finally , чтобы гарантировать выполнение.

Вот пример файловых операций, чтобы проиллюстрировать это.

  попробуйте:
   f = open ("test.txt", encoding = 'utf-8')
   # выполнять файловые операции
Ну наконец то:
   f.close ()  

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

.

Добавить комментарий

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

Theme: Overlay by Kaira Extra Text
Cape Town, South Africa