Как работает try except python

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

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

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

string = "5" number = int(string) print(number)

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

string = "hello" number = int(string) print(number)

При выполнении этого скрипта будет выброшено исключение ValueError, так как строку «hello» нельзя преобразовать в число:

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

С одной стороны, здесь очевидно, что строка не представляет число, но мы можем иметь дело с вводом пользователя, который также может ввести не совсем то, что мы ожидаем:

string = input("Введите число: ") number = int(string) print(number)

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

try..except

Конструкция try..except имеет следующее формальное определение:

try: инструкции except [Тип_исключения]: инструкции

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

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

Рассмотрим обработку исключения на примере преобразовании строки в число:

try: number = int(input("Введите число: ")) print("Введенное число:", number) except: print("Преобразование прошло неудачно") print("Завершение программы")

Введите число: hello Преобразование прошло неудачно Завершение программы

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

Вводим правильное число:

Введите число: 22 Введенное число: 22 Завершение программы

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

Блок finally

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

try: number = int(input("Введите число: ")) print("Введенное число:", number) except: print("Преобразование прошло неудачно") finally: print("Блок try завершил выполнение") print("Завершение программы")

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

Что такое try except в Python?

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

Конструкция самих исключений очень проста. Вам необходимо сначала проверить что-то попробовать сделать, а потом поискать ошибку, если она будет найдена, то выведется ваш код (какая-либо надпись), иначе все сработает корректно и никаких ошибок не будет.

try: # Пробуем что-то сделать k = 1 / 0 # Деление на ноль except ArithmeticError: # Отслеживаем на арифметическую ошибку print ("Найдена ошибка") # Мы нашли ошибку k = 0 # Наша переменная теперь будет равна 0 print(k) # Просто выводим переменную

Обработка исключений Python — блок Try/Except, блок Finally

В этом материале речь пойдет о блоках 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 “”, 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.

Читать:

Как работает backend на python

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

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

Поймай меня, если сможешь: руководство по обработке исключений в 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. Это позволяет разработчикам создавать более надёжные и стабильные программы. Следуя индустриальным стандартам и рекомендациям по обработке исключений, разработчик может сократить время, необходимое на отладку кода, способен обеспечить написание качественных программ и сделать так, чтобы пользователям было бы приятно работать с этими программами.

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

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

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

Сейчас мы ищем плюсовиков, питонистов, дата-инженеров и мл-рисерчеров.