Как определять собственные классы исключений в python

Базовые классы¶

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

exception

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

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

(tb)

Этот метод задает tb в качестве нового трейсбэк для исключения и
возвращает объект исключения. Это обычно — используемый в обработке исключений
код как это:

try
    ...
except SomeException
    tb = sys.exc_info()[2
    raise OtherException(...).with_traceback(tb)

exception

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

exception

Базовый класс для встроенных исключений, которые возникают для различных арифметических
ошибок: , ,
.

exception

Поднимается при невозможности выполнения
операции, связанной с .

Python Exception Handling Best Practices

• Always try to handle the exception in the code to avoid abnormal termination of the program.
• When creating a custom exception class, suffix its name with “Error”.
• If the except clauses have the same code, try to catch multiple exceptions in a single except block.
• Use finally block to close heavy resources and remove heavy objects.
• Use else block to log successful execution of the code, send notifications, etc.
• Avoid bare except clause as much as possible. If you don’t know about the exceptions, then only use it.
• Create module-specific exception classes for specific scenarios.
• You can catch exceptions in an except block and then raise another exception that is more meaningful.
• Always raise exceptions with meaningful messages.
• Avoid nested try-except blocks because it reduces the readability of the code.

8.8. Predefined Clean-up Actions¶

Some objects define standard clean-up actions to be undertaken when the object
is no longer needed, regardless of whether or not the operation using the object
succeeded or failed. Look at the following example, which tries to open a file
and print its contents to the screen.

for line in open("myfile.txt"):
    print(line, end="")

The problem with this code is that it leaves the file open for an indeterminate
amount of time after this part of the code has finished executing.
This is not an issue in simple scripts, but can be a problem for larger
applications. The statement allows objects like files to be
used in a way that ensures they are always cleaned up promptly and correctly.

with open("myfile.txt") as f
    for line in f
        print(line, end="")

After the statement is executed, the file f is always closed, even if a
problem was encountered while processing the lines. Objects which, like files,
provide predefined clean-up actions will indicate this in their documentation.

Some Built-In Exception Classes

Some of the built-in exception classes in Python are:

• ArithmeticError – this is the base class for arithmetic errors.
• AssertionError – raised when an assertion fails.
• AttributeError – when the attribute is not found.
• BufferError
• EOFError – reading after end of file
• ImportError – when the imported module is not found.
• LookupError – base exception for lookup errors.
• MemoryError – when out of memory occurs
• NameError – when a name is not found globally.
• OSError – base class for I/O errors
• ReferenceError
• RuntimeError
• StopIteration, StopAsyncIteration
• SyntaxError – invalid syntax
• SystemError – internal error in the Python Interpreter.
• TypeError – invalid argument type
• ValueError – invalid argument value

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

Вы уже сталкивались со множеством исключений. Ниже изложен список основных встроенных исключений (определение в документации к Пайтону):

• Exception – то, на чем фактически строятся все остальные ошибки;
• AttributeError – возникает, когда ссылка атрибута или присвоение не могут быть выполнены;
• IOError – возникает в том случае, когда операция I/O (такая как оператор вывода, встроенная функция open() или метод объекта-файла) не может быть выполнена, по связанной с I/O причине: «файл не найден», или «диск заполнен», иными словами.
• ImportError – возникает, когда оператор import не может найти определение модуля, или когда оператор не может найти имя файла, который должен быть импортирован;
• IndexError – возникает, когда индекс последовательности находится вне допустимого диапазона;
• KeyError – возникает, когда ключ сопоставления (dictionary key) не найден в наборе существующих ключей;
• KeyboardInterrupt – возникает, когда пользователь нажимает клавишу прерывания(обычно Delete или Ctrl+C);
• NameError – возникает, когда локальное или глобальное имя не найдено;
• OSError – возникает, когда функция получает связанную с системой ошибку;
• SyntaxError — возникает, когда синтаксическая ошибка встречается синтаксическим анализатором;
• TypeError – возникает, когда операция или функция применяется к объекту несоответствующего типа. Связанное значение представляет собой строку, в которой приводятся подробные сведения о несоответствии типов;
• ValueError – возникает, когда встроенная операция или функция получают аргумент, тип которого правильный, но неправильно значение, и ситуация не может описано более точно, как при возникновении IndexError;
• ZeroDivisionError – возникает, когда второй аргумент операции division или modulo равен нулю;

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

How to Handle Exceptions in Python?

Let’s look at an example where we need exception handling.

def divide(x, y):
    print(f'{x}/{y} is {x / y}')


divide(10, 2)
divide(10, 0)
divide(10, 4)

If we run the above program, we get the following output.

10/2 is 5.0
Traceback (most recent call last):
  File "/Users/pankaj/Documents/PycharmProjects/PythonTutorialPro/hello-world/exception_handling.py", line 6, in <module>
    divide(10, 0)
  File "/Users/pankaj/Documents/PycharmProjects/PythonTutorialPro/hello-world/exception_handling.py", line 2, in divide
    print(f'{x}/{y} is {x / y}')
ZeroDivisionError: division by zero

The second call to the divide() function raised ZeroDivisionError exception and the program terminated.

We never got the output of the third call to divide() method because we didn’t do exception handling in our code.

Let’s rewrite the divide() method with proper exception handling. If someone tries to divide by 0, we will catch the exception and print an error message. This way the program will not terminate prematurely and the output will make more sense.

def divide(x, y):
    try:
        print(f'{x}/{y} is {x / y}')
    except ZeroDivisionError as e:
        print(e)


divide(10, 2)
divide(10, 0)
divide(10, 4)

Output:

10/2 is 5.0
division by zero
10/4 is 2.5

Python Exception Handling

Метод read_very_eager¶

Или использовать еще один метод для чтения read_very_eager.
При использовании метода read_very_eager, можно отправить несколько
команд, а затем считать весь доступный вывод:

In : telnet.write(b'sh arp\n')

In : telnet.write(b'sh clock\n')

In : telnet.write(b'sh ip int br\n')

In : all_result = telnet.read_very_eager().decode('utf-8')

In : print(all_result)
sh arp
Protocol  Address          Age (min)  Hardware Addr   Type   Interface
Internet  10.30.0.1               -   aabb.cc00.6530  ARPA   Ethernet0/3.300
Internet  10.100.0.1              -   aabb.cc00.6530  ARPA   Ethernet0/3.100
Internet  10.200.0.1              -   aabb.cc00.6530  ARPA   Ethernet0/3.200
Internet  19.1.1.1                -   aabb.cc00.6520  ARPA   Ethernet0/2
Internet  192.168.100.1           -   aabb.cc00.6500  ARPA   Ethernet0/0
Internet  192.168.100.2         124   aabb.cc00.6600  ARPA   Ethernet0/0
Internet  192.168.100.3         143   aabb.cc00.6700  ARPA   Ethernet0/0
Internet  192.168.100.100       160   aabb.cc80.c900  ARPA   Ethernet0/0
Internet  192.168.200.1           -   0203.e800.6510  ARPA   Ethernet0/1
Internet  192.168.200.100        13   0800.27ac.16db  ARPA   Ethernet0/1
Internet  192.168.230.1           -   aabb.cc00.6530  ARPA   Ethernet0/3
R1>sh clock
*19:18:57.980 UTC Fri Nov 3 2017
R1>sh ip int br
Interface                  IP-Address      OK? Method Status                Protocol
Ethernet0/0                192.168.100.1   YES NVRAM  up                    up
Ethernet0/1                192.168.200.1   YES NVRAM  up                    up
Ethernet0/2                19.1.1.1        YES NVRAM  up                    up
Ethernet0/3                192.168.230.1   YES NVRAM  up                    up
Ethernet0/3.100            10.100.0.1      YES NVRAM  up                    up
Ethernet0/3.200            10.200.0.1      YES NVRAM  up                    up
Ethernet0/3.300            10.30.0.1       YES NVRAM  up                    up
R1>

Предупреждение

Перед методом read_very_eager всегда надо ставить time.sleep(n).

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

Exceptions in Python

Python has many built-in exceptions that are raised when your program encounters an error (something in the program goes wrong).

When these exceptions occur, the Python interpreter stops the current process and passes it to the calling process until it is handled. If not handled, the program will crash.

For example, let us consider a program where we have a function that calls function , which in turn calls function . If an exception occurs in function but is not handled in , the exception passes to and then to .

If never handled, an error message is displayed and our program comes to a sudden unexpected halt.

8.6. User-defined Exceptions¶

Programs may name their own exceptions by creating a new exception class (see
for more about Python classes). Exceptions should typically
be derived from the class, either directly or indirectly.

Exception classes can be defined which do anything any other class can do, but
are usually kept simple, often only offering a number of attributes that allow
information about the error to be extracted by handlers for the exception. When
creating a module that can raise several distinct errors, a common practice is
to create a base class for exceptions defined by that module, and subclass that
to create specific exception classes for different error conditions:

class Error(Exception):
    """Base class for exceptions in this module."""
    pass

class InputError(Error):
    """Exception raised for errors in the input.

    Attributes:
        expression -- input expression in which the error occurred
        message -- explanation of the error
    """

    def __init__(self, expression, message):
        self.expression = expression
        self.message = message

class TransitionError(Error):
    """Raised when an operation attempts a state transition that's not
    allowed.

    Attributes:
        previous -- state at beginning of transition
        next -- attempted new state
        message -- explanation of why the specific transition is not allowed
    """

    def __init__(self, previous, next, message):
        self.previous = previous
        self.next = next
        self.message = message

Most exceptions are defined with names that end in “Error”, similar to the
naming of the standard exceptions.

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

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

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

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

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

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

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

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

8.5. Exception Chaining¶

The statement allows an optional which enables
chaining exceptions. For example:

# exc must be exception instance or None.
raise RuntimeError from exc

This can be useful when you are transforming exceptions. For example:

>>> def func():
...     raise IOError
...
>>> try
...     func()
... except IOError as exc
...     raise RuntimeError('Failed to open database') from exc
...
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
  File "<stdin>", line 2, in func
OSError

The above exception was the direct cause of the following exception:

Traceback (most recent call last):
  File "<stdin>", line 4, in <module>
RuntimeError: Failed to open database

Exception chaining happens automatically when an exception is raised inside an
or section. Exception chaining can be
disabled by using idiom:

>>> try
...     open('database.sqlite')
... except OSError
...     raise RuntimeError from None
...
Traceback (most recent call last):
  File "<stdin>", line 4, in <module>
RuntimeError

Argument of an Exception

An exception can have an argument, which is a value that gives additional information about the problem. The contents of the argument vary by exception. You capture an exception’s argument by supplying a variable in the except clause as follows −

try:
   You do your operations here
   ......................
except ExceptionType as Argument:
   You can print value of Argument here...

If you write the code to handle a single exception, you can have a variable follow the name of the exception in the except statement. If you are trapping multiple exceptions, you can have a variable follow the tuple of the exception.

This variable receives the value of the exception mostly containing the cause of the exception. The variable can receive a single value or multiple values in the form of a tuple. This tuple usually contains the error string, the error number, and an error location.

Example

Following is an example for a single exception −

#!/usr/bin/python3

# Define a function here.
def temp_convert(var):
   try:
      return int(var)
   except ValueError as Argument:
      print ("The argument does not contain numbers\n", Argument)

# Call above function here.
temp_convert("xyz")

This produces the following result −

The argument does not contain numbers
invalid literal for int() with base 10: 'xyz'

Summing Up

After seeing the difference between syntax errors and exceptions, you learned about various ways to raise, catch, and handle exceptions in Python. In this article, you saw the following options:

• allows you to throw an exception at any time.
• enables you to verify if a certain condition is met and throw an exception if it isn’t.
• In the clause, all statements are executed until an exception is encountered.
• is used to catch and handle the exception(s) that are encountered in the try clause.
• lets you code sections that should run only when no exceptions are encountered in the try clause.
• enables you to execute sections of code that should always run, with or without any previously encountered exceptions.

Free PDF Download: Python 3 Cheat Sheet

Warnings¶

The following exceptions are used as warning categories; see the
documentation for more details.

exception

Base class for warning categories.

exception

Base class for warnings generated by user code.

exception

Base class for warnings about deprecated features when those warnings are
intended for other Python developers.

exception

Base class for warnings about features which are obsolete and
expected to be deprecated in the future, but are not deprecated
at the moment.

This class is rarely used as emitting a warning about a possible
upcoming deprecation is unusual, and
is preferred for already active deprecations.

exception

Base class for warnings about dubious syntax.

exception

Base class for warnings about dubious runtime behavior.

exception

Base class for warnings about deprecated features when those warnings are
intended for end users of applications that are written in Python.

exception

Base class for warnings about probable mistakes in module imports.

exception

Base class for warnings related to Unicode.

exception

Base class for warnings related to and .

Python Exception Handling: Error vs. Exception

What is Error?

The error is something that goes wrong in the program, e.g., like a syntactical error.

It occurs at compile time. Let’s see an example.

if a<5
File "<interactive input>", line 1
    if a < 5
           ^
SyntaxError: invalid syntax

What is Exception?

The errors also occur at runtime, and we know them as exceptions. An exception is an event which occurs during the execution of a program and disrupts the normal flow of the program’s instructions.

In general, when a Python script encounters an error situation that it can’t cope with, it raises an exception.

When a Python script raises an exception, it creates an exception object.

Usually, the script handles the exception immediately. If it doesn’t do so, then the program will terminate and print a traceback to the error along with its whereabouts.

>>> 1 / 0
Traceback (most recent call last):
 File "<string>", line 301, in run code
 File "<interactive input>", line 1, in <module>
ZeroDivisionError: division by zero

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

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

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

Давайте введем тот же набор данных что и посмотрим что будет

Ввод строки вместо числа

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

Проверка с корректным вводом.

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

Как лучше выбирать элементы из списка?

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

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

# Выбираем первый элемент списка
oneZooAnimal = biggerZoo
# Выводим на экран переменную `oneZooAnimal`
print(oneZooAnimal)

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

Как получить последний элемент списка?

Ответ на этот вопрос является дополнением к объяснению в предыдущем разделе.

Попробуйте ввести отрицательное значение, например,  или , в оператор индекса, чтобы получить последние элементы нашего списка !

# Вставляем -1 
monkeys = biggerZoo
print(monkeys)
# А теперь -2
zebra = biggerZoo
print(zebra)

Не правда ли, не слишком сложно?

Что означает ошибка «Index Out Of Range»?

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

Лучший способ понять эту ошибку — попробовать ее получить самостоятельно.

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

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

Срезы в списках

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

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

# Используем нотацию срезов
someZooAnimals = biggerZoo
# Выводим на экран то, что мы выбрали
print(someZooAnimals)
# Теперь поменяем местами 2 и двоеточие
otherZooAnimals = biggerZoo
# Выводим на экран полученный результат
print(otherZooAnimals)

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

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

В общем, подводя итоги:

# элементы берутся от start до end (но элемент под номером end не входит в диапазон!)
a
# элементы берутся начиная со start и до конца
a    
# элементы берутся с начала до end (но элемент под номером end не входит в диапазон!)
a

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

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

# Начиная со start, не доходя до end, с шагом step
a

Так что же по сути дает значение шага?

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

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

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

Как случайным образом выбрать элемент из списка?

Для этого мы используем пакет .

# Импортируем функцию `choice` из библиотеки `random` 
from random import choice
# Создадим список из первых четырех букв алфавита
list = 
# Выведем на экран случайный элемент списка
print(choice(list))

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

# Импортируем функцию `randrange` из библиотеки `random`
from random import randrange
# Создадим список из первых четырех букв алфавита
randomLetters = 
# Выбираем случайный индекс нашего списка
randomIndex = randrange(0,len(randomLetters))
# Выводим случайный элемент на экран
print(randomLetters)

Совет: обратите внимание на библиотеку , она может вам пригодиться во многих случаях при программировании на Python

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

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

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

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

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

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

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

Handling Multiple Exceptions with Except

We can define multiple exceptions with the same except clause. It means that if the Python interpreter finds a matching exception, then it’ll execute the code written under the except clause.

In short, when we define except clause in this way, we expect the same piece of code to throw different exceptions. Also, we want to take the same action in each case.

Please refer to the below example.

Example

try:
   You do your operations here;
   ......................
except(Exception1]]):
   If there is any exception from the given exception list,
   then execute this block.
   ......................
else:
   If there is no exception then execute this block

Когда использовать условие else

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

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

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

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

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

Как обрабатывать исключения?

Обработка исключений в Пайтон – это очень просто. Потратим немного времени и напишем несколько примеров, которые их вызовут. Мы начнем с одной из самых элементарных проблем: деление на ноль.

Python

1 / 0

Traceback (most recent call last):
File «<string>», line 1, in <fragment>
ZeroDivisionError: integer division or modulo by zero

1 2 3 4 5

1 Traceback(most recent call last) File»<string>»,line1,in<fragment> ZeroDivisionErrorinteger division ormodulo by zero

Python

try:
1 / 0
except ZeroDivisionError:
print(«You cannot divide by zero!»)

1 2 3 4

try 1 exceptZeroDivisionError print(«You cannot divide by zero!»)

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

How to handle Exceptions with Try-Finally?

What is Try-Finally Statement?

We can also enable Python exception handling with the help of try-finally statement.

With try block, we also have the option to define the “finally” block. This clause allows defining statements that we want to execute, no matters whether the try block has raised an exception or not.

This feature usually comes in the picture while releasing external resources.

Here is the coding snippet for help.

try:
   You do your operations here;
   ......................
   Due to any exception, this may be skipped.
finally:
   This would always be executed.
   ......................

Examples

One critical point is that we can either define an “except” or a “finally” clause with every try block. You can’t club these together. Also, you shouldn’t use the “else” clause along with a “finally” clause.

Let’s take an example to get more clarity.

try:
    fob = open('test', 'w')
    fob.write("It's my test file to verify try-finally in exception handling!!"
              )
    print 'try block executed'
finally:
    fob.close()
    print 'finally block executed'

If the exception doesn’t occur, then you’ll see the following output.

>>try block executed
>>finally block executed

Suppose we open the file in the READ mode and then try to perform a write operation on it. In such a situation, below code will help to handle the exception.

try:
    fob = open('test', 'r')
    try:
        fob.write("It's my test file to verify try-finally in exception handling!!"
                  )
        print 'try block executed'
    finally:
        fob.close()
        print 'finally block executed to close the file'
except IOError:
    print "Error: can\'t find file or read data"

In this case, the interpreter will raise an exception, and the following output will get displayed.

>>finally block executed to close the file
>>Error: can\'t find file or read data

When some code causes an exception in a try block, the execution immediately passes to the “finally” block. After all the statements in the “finally” block gets executed, the exception resumes to the “except” block for execution. But there must present a next higher layer of the “try-except” statement.

5.1. Base classes¶

The following exceptions are used mostly as base classes for other exceptions.

exception

The base class for all built-in exceptions. It is not meant to be directly
inherited by user-defined classes (for that, use ). If
is called on an instance of this class, the representation of
the argument(s) to the instance are returned, or the empty string when
there were no arguments.

The tuple of arguments given to the exception constructor. Some built-in
exceptions (like ) expect a certain number of arguments and
assign a special meaning to the elements of this tuple, while others are
usually called only with a single string giving an error message.

(tb)

This method sets tb as the new traceback for the exception and returns
the exception object. It is usually used in exception handling code like
this:

try
    ...
except SomeException
    tb = sys.exc_info()[2
    raise OtherException(...).with_traceback(tb)

exception

All built-in, non-system-exiting exceptions are derived from this class. All
user-defined exceptions should also be derived from this class.

exception

The base class for those built-in exceptions that are raised for various
arithmetic errors: , ,
.

exception

Raised when a related operation cannot be
performed.

Лучшие практики вывода исключений

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

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

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')