Как продолжить выполнение программы после except 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 особенно полезны, если программа работает с вводом пользователя, ведь никогда нельзя знать, что он может ввести.

Python Tutorial: Using Try/Except Blocks for Error Handling

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 , который ее обработает.

#28. Введение в обработку исключений. Блоки try / except | ООП Python

Отдельную инструкцию нельзя разместить между блоками 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 “”, line 2, in 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 «», line 2, in print(1/0) ZeroDivisionError: division by zero During handling of the above exception, another exception occurred: Traceback (most recent call last): File «», line 4, in print(2/0) ZeroDivisionError: division by zero

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

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

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

raise ZeroDivisionError
Traceback (most recent call last): File «», line 1, in raise ZeroDivisionError ZeroDivisionError

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

a,b=int(input()),int(input()) # вводим 1 затем 0 if b==0: raise ZeroDivisionError
Traceback (most recent call last): File «», line 3, in 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 “”, line 1, in raise KeyError KeyError

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

Можно использовать ключевое слово raise и не указывая, какое исключение вызвать.

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

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

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

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

raise ValueError(«Несоответствующее значение»)
Traceback (most recent call last): File «», line 1, in raise ValueError(«Несоответствующее значение») ValueError: Несоответствующее значение

6. assert в Python

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

assert(True) # код работает дальше

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

assert(1==0)
Traceback (most recent call last): File “”, line 1, in 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 “”, line 5, in assert 1+2==4 AssertionError

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

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

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

assert False,»Это проблема»
Traceback (most recent call last): File “”, line 1, in assert False,”Это проблема” AssertionError: Это проблема

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

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

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

class MyError(Exception): print(«Это проблема») raise MyError(«ошибка MyError»)
Traceback (most recent call last): File “”, line 1, in raise MyError(“ошибка MyError”) MyError: ошибка MyError

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

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

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

Источник: pythonru.com

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

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

• Что такое обработка исключений?
• Разница между оператором if и обработкой исключений.
• Использование разделов else и finally блока try-except для организации правильного обращения с ошибками.
• Определение пользовательских исключений.
• Рекомендации по обработке исключений.

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

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

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

Различия между оператором if и обработкой исключений

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

Оператор if — это базовый строительный элемент структурного программирования. Этот оператор проверяет условие и выполняет различные блоки кода, основываясь на том, истинно проверяемое условие или ложно. Вот пример:

temperature = int(input(«Please enter temperature in Fahrenheit: «)) if temperature > 100: print(«Hot weather alert! Temperature exceeded 100°F.») elif temperature >= 70: print(«Warm day ahead, enjoy sunny skies.») else: print(«Bundle up for chilly temperatures.»)

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

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

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

# Определение функции, которая пытается поделить число на ноль def divide(x, y): result = x / y return result # Вызов функции divide с передачей ей x=5 и y=0 result = divide(5, 0) print(f»Result of dividing by : «)
Traceback (most recent call last): File «», line 8, in ZeroDivisionError: division by zero attempted

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

Вышеописанное исключение можно обработать, обернув вызов функции divide в блок try-except :

# Определение функции, которая пытается поделить число на ноль def divide(x, y): result = x / y return result # Вызов функции divide с передачей ей x=5 и y=0 try: result = divide(5, 0) print(f»Result of dividing by : «) except ZeroDivisionError: print(«Cannot divide by zero.»)
Cannot divide by zero.

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

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

Использование разделов else и finally блока try-except для организации правильного обращения с ошибками

При работе с исключениями в Python рекомендуется включать в состав блоков try-except и раздел else , и раздел finally . Раздел else позволяет программисту настроить действия, производимые в том случае, если при выполнении кода, который защищают от проблем, не было вызвано исключений. А раздел finally позволяет обеспечить обязательное выполнение неких заключительных операций, вроде освобождения ресурсов, независимо от факта возникновения исключений (вот и вот — полезные материалы об этом).

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

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

try: # Открытие файла в режиме чтения file = open(«file.txt», «r») print(«Successful opened the file») except FileNotFoundError: # Обработка ошибки, возникающей в том случае, если файл не найден print(«File Not Found Error: No such file or directory») exit() except PermissionError: # Обработка ошибок, связанных с разрешением на доступ к файлу print(«Permission Denied Error: Access is denied») else: # Всё хорошо — сделать что-то с данными, прочитанными из файла content = file.read().decode(‘utf-8’) processed_data = process_content(content) # Прибираемся после себя даже в том случае, если выше возникло исключение finally: file.close()

В этом примере мы сначала пытаемся открыть файл file.txt для чтения (в подобной ситуации можно использовать выражение with , которое гарантирует правильное автоматическое закрытие объекта файла после завершения работы). Если в процессе выполнения операций файлового ввода/вывода возникают ошибки FileNotFoundError или PermissionError — выполняются соответствующие разделы except . Здесь, ради простоты, мы лишь выводим на экран сообщения об ошибках и выходим из программы в том случае, если файл не найден.

В противном случае, если в блоке try исключений не возникло, мы продолжаем работу, обрабатывая содержимое файла в ветви else . И наконец — выполняется «уборка» — файл закрывается независимо от возникновения исключения. Это обеспечивает блок finally (подробности смотрите здесь).

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

Определение пользовательских исключений

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

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

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

class InvalidEmailAddress(ValueError): def __init__(self, message): super().__init__(message) self.msgfmt = message

Это исключение является наследником ValueError . Его конструктор принимает необязательный аргумент message (по умолчанию он устанавливается в значение invalid email address ).

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

def send_email(address): if isinstance(address, str) == False: raise InvalidEmailAddress(«Invalid email address») # Отправка электронного письма

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

>>> send_email(None) Traceback (most recent call last): File «», line 1, in File «/path/to/project/main.py», line 8, in send_email raise InvalidEmailAddress(«Invalid email address») InvalidEmailAddress: Invalid email address

Рекомендации по обработке исключений

Вот несколько рекомендаций, относящихся к обработке ошибок в Python:

1. Проектируйте код в расчёте на возможное возникновение ошибок. Заранее планируйте устройство кода с учётом возможных сбоев и проектируйте программы так, чтобы они могли бы достойно обрабатывать эти сбои. Это означает — предугадывать возможные пограничные случаи и реализовывать подходящие обработчики ошибок.
2. Используйте содержательные сообщения об ошибках. Сделайте так, чтобы программа выводила бы, на экран, или в файл журнала, подробные сообщения об ошибках, которые помогут пользователям понять — что и почему пошло не так. Старайтесь не применять обобщённые сообщения об ошибках, наподобие Error occurred или Something bad happened . Вместо этого подумайте об удобстве пользователя и покажите сообщение, в котором будет дан совет по решению проблемы или будет приведена ссылка на документацию. Постарайтесь соблюсти баланс между выводом подробных сообщений и перегрузкой пользовательского интерфейса избыточными данными.
3. Минимизируйте побочные эффекты. Постарайтесь свести к минимуму последствия сбойных операций, изолируя проблемные разделы кода посредством конструкции try-finally или try с использованием with . Сделайте так, чтобы после выполнения кода, было ли оно удачным или нет, обязательно выполнялись бы «очистительные» операции.
4. Тщательно тестируйте код. Обеспечьте корректное поведение обработчиков ошибок в различных сценариях использования программы, подвергнув код всеобъемлющему тестированию.
5. Регулярно выполняйте рефакторинг кода. Выполняйте рефакторинг фрагментов кода, подверженных ошибкам, чтобы улучшить их надёжность и производительность. Постарайтесь, чтобы ваша кодовая база была бы устроена по модульному принципу, чтобы её отдельные части слабо зависели бы друг от друга. Это позволяет независимым частям код самостоятельно эволюционировать, не оказывая негативного воздействия на другие его части.
6. Логируйте важные события. Следите за интересными событиями своего приложения, записывая сведения о них в файл журнала или выводя в консоль. Это поможет вам выявлять проблемы на ранних стадиях их возникновения, не тратя время на длительный анализ большого количества неструктурированных логов.

Итоги

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

О, а приходите к нам работать?

Обработка/перехват исключений try/except в Python.

Можно писать программы, которые обрабатывают выбранные исключения. Посмотрите на следующий пример, который запрашивает ввод у пользователя до тех пор, пока не будет введено правильное целое число, но позволяет пользователю прерывать программу, используя Ctrl-C или что-либо поддерживаемое операционной системой. Обратите внимание, что сгенерированное пользователем прерывание сигнализируется возбуждением исключения KeyboardInterrupt .

while True: try: x = int(input(«Пожалуйста, введите целое число: «)) break except ValueError: print(«Это не целое число. Попробуйте снова. «)

Оператор try/except работает следующим образом:

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

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

except (RuntimeError, TypeError, NameError): pass

Класс в инструкции except совместим с исключением, если это тот же самый класс или его базовый класс, но не наоборот. Инструкция except , перечисляющая производный класс, не совместима с базовым классом. Например, следующий код будет печатать B , C , D в таком порядке:

class B(Exception): pass class C(B): pass class D(C): pass for cls in [B, C, D]: try: raise cls() except D: print(‘D’) except C: print(‘C’) except B: print(‘B’)

Обратите внимание, что если бы инструкции except были отменены (с первым исключением B), то вывелось бы B , B , B — срабатывает первое совпадающее предложение except .

Последняя инструкция except может опустить имя исключения. Используйте это с крайней осторожностью, таким образом можно легко замаскировать реальную ошибку программирования! Здесь можно использовать sys.exc_info() или модуль traceback для вывода сообщения об ошибке или ее сохранения для дельнейшего анализа, а затем повторно вызвать исключение при помощи оператора raise , что позволяет вызывающей стороне также обработать исключение:

import traceback try: f = open(‘myfile.txt’) s = f.readline() i = int(s.strip()) except OSError as err: print(«OS error: «.format(err)) except ValueError: print(«Не удалось преобразовать данные в целое число.») except: print(«Непредвиденная ошибка. «) # сохраняем исключение для дальнейшего анализа. with open(‘trace.txt’, ‘a’) as fp: traceback.print_exc(file=fp) # повторный вызов исключения, если это необходимо. raise

В примере выше, сведения об ошибке сохраняются в файл trace.txt с использованием встроенной функции open() . Лучшей практикой сохранения исключений для дальнейшего анализа в подобных ситуациях является применение модуля logging .

Конструкция try/except может содержать необязательную инструкцию else , которая при наличии должна следовать за всеми инструкциями except . Блок кода в инструкции else будет выполнен в том случае, если код в инструкции try не вызывает исключения. Например:

for arg in sys.argv[1:]: try: f = open(arg, ‘r’) except OSError: print(‘не удается открыть’, arg) else: print(arg, ‘имеет’, len(f.readlines()), ‘строк’) f.close()

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

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

Инструкция except может указывать переменную после имени исключения. Переменная привязывается к экземпляру исключения с аргументами, хранящимися в экземпляре instance.args . Для удобства, экземпляр исключения определяет __str__() , так что аргументы могут быть напечатаны непосредственно без необходимости ссылаться instance.args . Кроме того, можно создать экземпляр исключения прежде, чем вызвать его и добавить любые атрибуты к нему по желанию.

try: raise Exception(‘spam’, ‘eggs’) except Exception as inst: # экземпляр исключения print(type(inst)) # аргументы, хранящиеся внутри print(inst.args) # __str__ позволяет печатать args напрямую, но может # быть переопределен в подклассах исключений print(inst) # распаковка аргументов x, y = inst.args print(‘x =’, x) print(‘y =’, y) # # (‘spam’, ‘eggs’) # (‘spam’, ‘eggs’) # x = spam # y = eggs

Если исключение имеет аргументы, они печатаются как последняя часть («деталь») сообщения для необработанных исключений.

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

def this_fails(): x = 1/0 try: this_fails() except ZeroDivisionError as err: print(‘Handling run-time error:’, err) #Handling run-time error: division by zero

• ОБЗОРНАЯ СТРАНИЦА РАЗДЕЛА
• Обработка/перехват исключений try/except.
• Инструкция finally, очистка внешних ресурсов.
• Тонкости работы конструкции try/except/else/finally.
• Создание пользовательского класса исключения.
• Обработка группы исключений, оператор except*.
• Эффективная обработка исключений.
• Инструкция raise, принудительный вызов исключений.
• Отладочные утверждение assert.
• Улучшения сообщений об ошибках 3.10.
• Улучшения сообщений об ошибках 3.11.

Источник: docs-python.ru