КАК ПОЛУЧИТЬ КОД ОШИБКИ PYTHON

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

One has pretty much control on which information from the traceback to be displayed/logged when catching exceptions.

with open(“not_existing_file.txt”, ‘r’) as text:
pass

If you look at the documentation for the built-in errors, you’ll see that most Exception classes assign their first argument as a message attribute. Not all of them do though.

I think the proper way of handling this is to identify the specific Exception subclasses you want to catch, and then catch only those instead of everything with an except Exception, then utilize whatever attributes that specific subclass defines however you want.

If you must print something, I think that printing the caught Exception itself is most likely to do what you want, whether it has a message attribute or not.

You could also check for the message attribute if you wanted, like this, but I wouldn’t really suggest it as it just seems messy:

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


КАК ПОЛУЧИТЬ КОД ОШИБКИ PYTHON

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

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

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

Ошибки могут быть разных видов:

Разберем их по очереди.

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

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

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

ab # вводим 1 затем 0
b
ZeroDivisionError

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

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

ab

b
ZeroDivisionError

“Деление на 0”
“Будет ли это напечатано?”

1
0
Деление на 0
Будет ли это напечатано?

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

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

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

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

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

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

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

a
b
a b

Есть разные типы исключений в Python и их тип выводится в сообщении: вверху примеры TypeError и ZeroDivisionError. Обе строки в сообщениях об ошибке представляют собой имена встроенных исключений Python.

Оставшаяся часть строки с ошибкой предлагает подробности о причине ошибки на основе ее типа.

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

Print/Log the full traceback

As others already mentioned, you can catch the whole traceback by using the traceback module:

import traceback
try:
with open(“not_existing_file.txt”, ‘r’) as text:
pass
except Exception as exception:
traceback.print_exc()

You can achieve the same by using logging:

try:
with open(“not_existing_file.txt”, ‘r’) as text:
pass
except Exception as exception:
logger.error(exception, exc_info=True)

Эта ошибка связана со стеком и происходит при вызове функций. Как и предполагает название, ошибка рекурсии возникает, когда внутри друг друга исполняется много методов (один из которых — с бесконечной рекурсией), но это ограничено размером стека.

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

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

Getting Useful Information from an Exception

So, I’ve got something like:

You know- you can put a print d in there, and that works. But is there a better, more interesting way to get at that information that people know of?

You can do something like:

, , =
:
. += (,)

Note that not all exceptions subclass Exception (though almost all do), so this might not catch some exceptions; also, exceptions aren’t required to have an .args attribute (though it will if the exception subclasses Exception and doesn’t override __init__ without calling its superclass), so the code as written might fail But in practice it almost never does (and if it does, you should fix the non-conformant exception!)

(Note that this is also the argument behind Java’s checked exceptions — now it is explicit that an exception can be thrown — except that RuntimeException can still be thrown anywhere. -jJ)

I don’t quite get this argument. In a random piece of source code, there is no way to tell whether or not it will fail just by inspection. If you look at:

x = 1
result = myfunction(x)

you can’t tell whether or not myfunction will fail at runtime just by inspection, so why should it matter whether it fails by crashing at runtime or fails by raising an exception?

Читайте также:  Код ошибки p0037 тойота авенсис

(Crashing is bad. By explicitly declaring the exception, you warn people that they may want to handle it. Java does this awkwardly. C doesn’t have a good way to do it at all, because the error returns are still in-band for regular returns. In python, passthrough exceptions aren’t marked, but error conditions stand out where they are created, and they don’t usually mimic valid returns. -jJ)

Joel’s argument that raising exceptions is just a goto in disguise is partly correct. But so are for loops, while loops, functions and methods! Like those other constructs, exceptions are gotos tamed and put to work for you, instead of wild and dangerous. You can’t jump *anywhere*, only highly constrained places.

Joel also writes:

“They create too many possible exit points for a function. To write correct code, you really have to think about every possible code path through your function. Every time you call a function that can raise an exception and don’t catch it on the spot, you create opportunities for surprise bugs caused by functions that terminated abruptly, leaving data in an inconsistent state, or other code paths that you didn’t think about.”

(Even now, a fairly high percentage of the bugs found in CPython’s C code are memory leaks caused by premature exits — exactly what Joel warned about. It isn’t such a problem with python code, because the language is supposed to take care of fixing accounting-type invariants for you. -jJ)

This is a better argument for *careful* use of exceptions, not an argument to avoid them. Or better still, it is an argument for writing code which doesn’t has side-effects and implements data transactions. That’s a good idea regardless of whether you use exceptions or not. (In python, “transactions” are small enough that it is usually difficult to interrupt an operation inside one without writing C code. Вы *можете* сделать это, скажем, с помощью рекурсивных генераторов, но это сложно.)

защита myfunc(x=Нет):
результат = “”
если x равен Нет:
result = “Аргумент не указан”
Элиф х == 0:
результат = “Ноль”
элиф 0 < х <= 3:
resutl = "x находится между 0 и 3"
еще:
result = "x больше 3"
вернуть результат

Нет смысла откладывать возврат значения, как это делает myfunc, просто ради того, чтобы иметь единственную точку выхода. «Иметь единственную точку выхода» — хорошая эвристика для многих функций, но для данной — бессмысленная приработка. (На самом деле это увеличивает, а не уменьшает вероятность ошибки. Если вы посмотрите внимательно, в myfunc выше есть такая ошибка в предложении «0 < x <= 3».)

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

Наконец, позвольте мне возразить против одного из комментариев Джоэла:

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

Возможно, это справедливо и для C++. Я не знаю языка и не хотел бы гадать. Но это не относится к Python.

(Разница в том, что Python в первую очередь снижает вероятность ошибки и делает создание исключения простым способом «вернуть значение ошибки». Это определенно более чистый способ передать значение ошибки, которое был сгенерирован чем-то, что вы назвали.)

Вот как Джоэл мог бы написать функцию, будучи программистом на языке C:

защита joels_function(args):
ошибка_результат = 0
хороший_результат = Нет
процесс(аргументы)
если error_condition():
error_result = -1 # флаг ошибки
elif Different_error_conditon():
error_result = -2
еще:
more_processing()
если else_error_conditon():
error_result = -3
do_more_work()
Good_result = “Успех!”
если error_result != 0:
возврат (Ложь, error_result)
еще:
возврат (Правда, хороший_результат)

, а затем вызовите его с помощью:

Вот как бы я написал это на Python:

def my_function(args):
процесс(аргументы)
если error_condition():
поднять SomeError(“Произошла ошибка”)
elif Different_error_conditon():
поднять SomeError(“Произошла другая ошибка”)
more_processing()
если else_error_conditon():
поднять SomeError(“Произошла еще одна ошибка”)
do_more_work()
вернуть «Успех!»

и вызовите его с помощью:

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

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

(Извините, но если бы вы действительно много программировали на C++, вы бы знали, что между этими двумя языками нет большой разницы, когда дело касается исключений, по крайней мере, если вы не программируете C++ на старом языке. в стиле C с разбросанными повсюду операторами new и delete. По сути, вы отвергаете аргумент Джоэла. Весь этот раздел немного слаб, возможно, было бы лучше просто заявить: «Не злоупотребляйте исключениями, поскольку это может привести к трудно обрабатываемым ошибкам». -проверь код спагетти» и покончим с этим

См. также: Итальянский перевод на сайте ManutenereLeEccezioni.

Чтобы написать о.

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

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

Ошибка включения с клавиатуры (KeyboardInterrupt)

Исключение KeyboardInterrupt возникает при остановке программы с помощью комбинации Ctrl + C или Ctrl + Z в командной строке или ядре в Jupyter Notebook. Иногда это происходит неумышленно и подобная обработка поможет избежать подобной ситуации.

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

вход
‘Нажмите Ctrl+C и прервите ядро:’
КлавиатураПрерывание

‘Исключений не произошло’

Читайте также:  Код ошибки 80070422 брандмауэр

.()

( % )

Однако изначально было:

.()
:
( % () )

Кто-то заметил, что «кроме исключения» перехватывается больше, чем просто «кроме исключения как e».

Почему это так? В чем разница?– ЛевКимбро

На данный момент (версия <= 2.4) исключение не обязательно должно быть унаследовано от Exception. Таким образом, простое «кроме:» перехватывает все исключения, а не только системные. Строковые исключения — это один из примеров исключений, которые не наследуются от Exception. — МайкРовнер

Я считаю, что начиная с версии 2.7 исключения по-прежнему не обязательно наследуются от Exception или даже от BaseException. Однако, начиная с Python 3, исключения должны быть подклассом BaseException. — СлонДжим

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

(,) = (,)

“=”
:
делить на ноль

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

(,) = (,)

“=”
:
=

См. также

В этой вики: WriteExceptionClasses, TracebackModule.

Общие (не относящиеся к Python) идеи об исключениях см. в разделе ExceptionPatterns.

Однако в некоторых ситуациях лучше всего отловить все ошибки.

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

В подобных ситуациях вы можете написать что-то вроде этого:

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

Другой случай — когда вы хотите что-то сделать в случае сбоя кода:

()

()

()

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

Блоки попробовать/исключить

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

я
я

“Деление на 0”
“Исключение было обработано”

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

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

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

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

Несколько, кроме Python

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

а б

аб
“Это не будет напечатано”

ТипОшибка
«Вы восстановили значения несовместимых типов»
ZeroDivisionError
«Деление на 0»

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

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

а б

аб

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

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

Несколько исключений в одном, кроме

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

Общий, кроме после всех блоков, кроме

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

NameError
“sum не существует”
ZeroDivisionError
“Вы не можете разделить на 0”

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

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

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

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

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

a
b
c a b

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

Assert в Python

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

# код работает дальше

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

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

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

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

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

You might not be interested in the whole traceback, but only in the most important information, such as Exception name and Exception message, use:

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

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

Exception

MyError

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

Ошибки памяти чаще всего связаны с оперативной памятью компьютера и относятся к структуре данных под названием “Куча” (heap). Если есть крупные объекты (или) ссылки на подобные, то с большой долей вероятности возникнет ошибка OutofMemory. Она может появиться по нескольким причинам:

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

Читайте также:  Unarc dll вернул код ошибки 11 как исправить windows 10

Но поскольку Python использует архитектуру управления памятью из языка C (функция malloc()), не факт, что все процессы восстановятся — в некоторых случаях MemoryError приведет к остановке. Следовательно, обрабатывать такие ошибки не рекомендуется, и это не считается хорошей практикой.

Finding Specific Exception Names

Standard exceptions that can be raised are detailed at:

Look to class documentation to find out what exceptions a given class can raise.

Рассмотрим некоторые базовые ошибки в программировании.

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

Когда делитель (второй аргумент операции деления) или знаменатель равны нулю, тогда результатом будет ошибка деления на ноль.

a
a
ZeroDivisionError

“Успех, нет ошибок!”

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

math
mathexp
OverflowError

“Успех, нет ошибок!”

Когда инструкция утверждения не верна, вызывается ошибка утверждения.

Рассмотрим пример. Предположим, есть две переменные: a и b. Их нужно сравнить. Чтобы проверить, равны ли они, необходимо использовать ключевое слово assert, что приведет к вызову исключения Assertion в том случае, если выражение будет ложным.

a
b
a b
AssertionError

“Успех, нет ошибок!”

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

obj
a
a

obj Attributes
objattribute
AttributeError

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

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

Здесь есть два вида исключений:

Ошибка ключа

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

a
a
LookupError

“Успех, нет ошибок!”

Ошибка индекса

Если пытаться получить доступ к индексу (последовательности) списка, которого не существует в этом списке или находится вне его диапазона, будет вызвана ошибка индекса (IndexError: list index out of range python).

a
a
LookupError
“Исключение IndexError, индекс списка вне диапазона.”

“Успех, нет ошибок!”

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

Ошибка имени возникает, когда локальное или глобальное имя не находится.

В следующем примере переменная ans не определена. Результатом будет ошибка NameError.

ans
NameError
“NameError: переменная ‘ans’ не определена”

“Успех, нет ошибок!”

Ошибка «NotImplementedError» Ошибка выполнения служит базовым классом для ошибки NotImplemented. Абстрактные методы определенного пользователем класса вызывают это исключение, когда производные методы перезаписывают оригинальный.

self
BaseClass self__init__
self
# функция ничего не делает
NotImplementedErrorself__class____name__

BaseClass

self
# действительно что-то делает
self__class____name__ ‘ что-то делает!’

SubClassdo_something
BaseClassdo_something

Ошибка типа вызывается при попытке объединить два несовместимых операнда или объекта.

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

a
b
c a b
TypeError

‘Успех, нет ошибок!’

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

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

ValueError
‘ValueError: не удалось преобразовать строку в float: ‘PythonRu”

‘Успех, нет ошибок!’

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

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

Это можно сделать, создав новый класс, который будет наследовать из класса Exception в Python.

Exception
self data
selfdata data
self
selfdata

Total_Marks “Введите общее количество баллов: ”

Num_of_Sections “Введите количество разделов: ”
Num_of_Sections
UnAcceptedValueError”Количество секций не может быть меньше 1″
UnAcceptedValueError e
edata

Введите общее количество баллов: 10
Введите количество разделов: 0
Полученная ошибка: Количество секций не может быть меньше 1

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

Недостатки обработки исключений в Python

У использования исключений есть свои побочные эффекты, как, например, то, что программы с блоками try-except работают медленнее, а количество кода возрастает.

Дальше пример, где модуль Python timeit используется для проверки времени исполнения 2 разных инструкций. В stmt1 для обработки ZeroDivisionError используется try-except, а в stmt2 — if. Затем они выполняются 10000 раз с переменной a=0. Суть в том, чтобы показать разницу во времени исполнения инструкций. Так, stmt1 с обработкой исключений занимает больше времени чем stmt2, который просто проверяет значение и не делает ничего, если условие не выполнено.

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

timeit
setup
stmt1 ”’try:
b=10/a
except ZeroDivisionError:
pass”’

stmt2 ”’if a!=0:
b=10/a”’

timeittimeitstmt1setupnumber
timeittimeitstmt2setupnumber

time= 0.003897680000136461
time= 0.0002797570000439009

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

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

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

Блок finally в Python

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

ValueError
“Это ошибка значения”

“Это будет напечатано в любом случае.”

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

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

ZeroDivisionError

“Ничего не происходит”

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

Выводы!

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

Обработка исключений — один из основных факторов, который делает код готовым к развертыванию. Это простая концепция, построенная всего на 4 блоках: try выискивает исключения, а except их обрабатывает.

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

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

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

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

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