Python exception runtime error

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

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

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

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

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

• Синтаксические
• Недостаточно памяти
• Ошибки рекурсии
• Исключения

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

Синтаксические ошибки (SyntaxError)

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

Рассмотрим на примере.

a = 8
b = 10
c = a b

File "", line 3
 c = a b
       ^
SyntaxError: invalid syntax

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

Недостаточно памяти (OutofMemoryError)

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

• Использование 32-битной архитектуры Python (максимальный объем выделенной памяти невысокий, между 2 и 4 ГБ);
• Загрузка файла большого размера;
• Запуск модели машинного обучения/глубокого обучения и много другое;

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

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

Ошибка рекурсии (RecursionError)

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

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

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

def recursion():
    return recursion()

recursion()

---------------------------------------------------------------------------

RecursionError                            Traceback (most recent call last)

 in 
----> 1 recursion()


 in recursion()
      1 def recursion():
----> 2     return recursion()


... last 1 frames repeated, from the frame below ...


 in recursion()
      1 def recursion():
----> 2     return recursion()


RecursionError: maximum recursion depth exceeded

Ошибка отступа (IndentationError)

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

Пример:

for i in range(10):
    print('Привет Мир!')

  File "", line 2
    print('Привет Мир!')
        ^
IndentationError: expected an indented block

Исключения

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

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

Ошибка типа (TypeError)

a = 2
b = 'PythonRu'
a + b

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

 in 
      1 a = 2
      2 b = 'PythonRu'
----> 3 a + b


TypeError: unsupported operand type(s) for +: 'int' and 'str'

Ошибка деления на ноль (ZeroDivisionError)

10 / 0

---------------------------------------------------------------------------

ZeroDivisionError                         Traceback (most recent call last)

 in 
----> 1 10 / 0


ZeroDivisionError: division by zero

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

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

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

Встроенные исключения

BaseException
 +-- SystemExit
 +-- KeyboardInterrupt
 +-- GeneratorExit
 +-- Exception
      +-- StopIteration
      +-- StopAsyncIteration
      +-- ArithmeticError
      |    +-- FloatingPointError
      |    +-- OverflowError
      |    +-- ZeroDivisionError
      +-- AssertionError
      +-- AttributeError
      +-- BufferError
      +-- EOFError
      +-- ImportError
      |    +-- ModuleNotFoundError
      +-- LookupError
      |    +-- IndexError
      |    +-- KeyError
      +-- MemoryError
      +-- NameError
      |    +-- UnboundLocalError
      +-- OSError
      |    +-- BlockingIOError
      |    +-- ChildProcessError
      |    +-- ConnectionError
      |    |    +-- BrokenPipeError
      |    |    +-- ConnectionAbortedError
      |    |    +-- ConnectionRefusedError
      |    |    +-- ConnectionResetError
      |    +-- FileExistsError
      |    +-- FileNotFoundError
      |    +-- InterruptedError
      |    +-- IsADirectoryError
      |    +-- NotADirectoryError
      |    +-- PermissionError
      |    +-- ProcessLookupError
      |    +-- TimeoutError
      +-- ReferenceError
      +-- RuntimeError
      |    +-- NotImplementedError
      |    +-- RecursionError
      +-- SyntaxError
      |    +-- IndentationError
      |         +-- TabError
      +-- SystemError
      +-- TypeError
      +-- ValueError
      |    +-- UnicodeError
      |         +-- UnicodeDecodeError
      |         +-- UnicodeEncodeError
      |         +-- UnicodeTranslateError
      +-- Warning
           +-- DeprecationWarning
           +-- PendingDeprecationWarning
           +-- RuntimeWarning
           +-- SyntaxWarning
           +-- UserWarning
           +-- FutureWarning
           +-- ImportWarning
           +-- UnicodeWarning
           +-- BytesWarning
           +-- ResourceWarning

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

• Try: он запускает блок кода, в котором ожидается ошибка.
• Except: здесь определяется тип исключения, который ожидается в блоке try (встроенный или созданный).
• Else: если исключений нет, тогда исполняется этот блок (его можно воспринимать как средство для запуска кода в том случае, если ожидается, что часть кода приведет к исключению).
• Finally: вне зависимости от того, будет ли исключение или нет, этот блок кода исполняется всегда.

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

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

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

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

try:
    inp = input()
    print('Нажмите Ctrl+C и прервите Kernel:')
except KeyboardInterrupt:
    print('Исключение KeyboardInterrupt')
else:
    print('Исключений не произошло')

Исключение KeyboardInterrupt

Стандартные ошибки (StandardError)

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

Арифметические ошибки (ArithmeticError)

• Ошибка деления на ноль (Zero Division);
• Ошибка переполнения (OverFlow);
• Ошибка плавающей точки (Floating Point);

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

Деление на ноль (ZeroDivisionError)

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

try:  
    a = 100 / 0
    print(a)
except ZeroDivisionError:  
    print("Исключение ZeroDivisionError." )
else:  
    print("Успех, нет ошибок!")

Исключение ZeroDivisionError.

Переполнение (OverflowError)

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

try:  
    import math
    print(math.exp(1000))
except OverflowError:  
    print("Исключение OverFlow.")
else:  
    print("Успех, нет ошибок!")

Исключение OverFlow.

Ошибка утверждения (AssertionError)

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

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

try:  
    a = 100
    b = "PythonRu"
    assert a == b
except AssertionError:  
    print("Исключение AssertionError.")
else:  
    print("Успех, нет ошибок!")

Исключение AssertionError.

Ошибка атрибута (AttributeError)

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

class Attributes(obj):
    a = 2
    print(a)

try:
    obj = Attributes()
    print(obj.attribute)
except AttributeError:
    print("Исключение AttributeError.")

2
Исключение AttributeError.

Ошибка импорта (ModuleNotFoundError)

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

import nibabel

---------------------------------------------------------------------------

ModuleNotFoundError                       Traceback (most recent call last)

 in 
----> 1 import nibabel


ModuleNotFoundError: No module named 'nibabel'

Ошибка поиска (LookupError)

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

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

• Ошибка индекса (IndexError);
• Ошибка ключа (KeyError);

Ошибка ключа

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

try:  
    a = {1:'a', 2:'b', 3:'c'}  
    print(a[4])  
except LookupError:  
    print("Исключение KeyError.")
else:  
    print("Успех, нет ошибок!")

Исключение KeyError.

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

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

try:
    a = ['a', 'b', 'c']  
    print(a[4])  
except LookupError:  
    print("Исключение IndexError, индекс списка вне диапазона.")
else:  
    print("Успех, нет ошибок!")

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

Ошибка памяти (MemoryError)

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

Ошибка имени (NameError)

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

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

try:
    print(ans)
except NameError:  
    print("NameError: переменная 'ans' не определена")
else:  
    print("Успех, нет ошибок!")

NameError: переменная 'ans' не определена

Ошибка выполнения (Runtime Error)

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

class BaseClass(object):
    """Опередляем класс"""
    def __init__(self):
        super(BaseClass, self).__init__()
    def do_something(self):
	# функция ничего не делает
        raise NotImplementedError(self.__class__.__name__ + '.do_something')

class SubClass(BaseClass):
    """Реализует функцию"""
    def do_something(self):
        # действительно что-то делает
        print(self.__class__.__name__ + ' что-то делает!')

SubClass().do_something()
BaseClass().do_something()

SubClass что-то делает!



---------------------------------------------------------------------------

NotImplementedError                       Traceback (most recent call last)

 in 
     14
     15 SubClass().do_something()
---> 16 BaseClass().do_something()


 in do_something(self)
      5     def do_something(self):
      6         # функция ничего не делает
----> 7         raise NotImplementedError(self.__class__.__name__ + '.do_something')
      8
      9 class SubClass(BaseClass):


NotImplementedError: BaseClass.do_something

Ошибка типа (TypeError)

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

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

try:
    a = 5
    b = "PythonRu"
    c = a + b
except TypeError:
    print('Исключение TypeError')
else:
    print('Успех, нет ошибок!')

Исключение TypeError

Ошибка значения (ValueError)

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

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

try:
    print(float('PythonRu'))
except ValueError:
    print('ValueError: не удалось преобразовать строку в float: 'PythonRu'')
else:
    print('Успех, нет ошибок!')

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

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

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

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

class UnAcceptedValueError(Exception):   
    def __init__(self, data):    
        self.data = data
    def __str__(self):
        return repr(self.data)

Total_Marks = int(input("Введите общее количество баллов: "))
try:
    Num_of_Sections = int(input("Введите количество разделов: "))
    if(Num_of_Sections < 1):
        raise UnAcceptedValueError("Количество секций не может быть меньше 1")
except UnAcceptedValueError as e:
    print("Полученная ошибка:", e.data)

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

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

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

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

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

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

import timeit
setup="a=0"
stmt1 = '''
try:
    b=10/a
except ZeroDivisionError:
    pass'''

stmt2 = '''
if a!=0:
    b=10/a'''

print("time=",timeit.timeit(stmt1,setup,number=10000))
print("time=",timeit.timeit(stmt2,setup,number=10000))

time= 0.003897680000136461
time= 0.0002797570000439009

Выводы!

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

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

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

1. Home
2. Python Tutorial
3. Exception Handling in Python

Last updated on September 22, 2020

Exception handling is a mechanism which allows us to handle errors gracefully while the program is running instead of abruptly ending the program execution.

Runtime Errors #

Runtime errors are the errors which happens while the program is running. Note is that runtime errors do not indicate there is a problem in the structure (or syntax) of the program. When runtime errors occurs Python interpreter perfectly understands your statement but it just can’t execute it. However, Syntax Errors occurs due to incorrect structure of the program. Both type of errors halts the execution of the program as soon as they are encountered and displays an error message (or traceback) explaining the probable cause of the problem.

The following are some examples of runtime errors.

Example 1: Division by a zero.

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

Try it now

Example 2: Adding string to an integer.

>>>
>>> 10 + "12"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'int' and 'str'
>>>

Try it now

Example 3: Trying to access element at invalid index.

>>>
>>> list1 = [11, 3, 99, 15]
>>>
>>> list1[10]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range
>>>

Try it now

Example 4: Opening a file in read mode which doesn’t exist.

>>>
>>> f = open("filedoesntexists.txt", "r")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
FileNotFoundError: [Errno 2] No such file or directory: 'filedoesntexists.txt'
>>>
>>>

Try it now

Again note that all the above statements are syntactically valid, the only problem is that when Python tries to execute them, they got into an invalid state.

An error which occur while the program is running is known as an exception. When this happens, we say Python has raised an exception or an exception is thrown. Whenever such errors happen, Python creates a special type of object which contains all the relevant information about the error just occurred. For example, it contains a line number at which the error occurred, error messages (remember it is called traceback) and so on. By default, these errors simply halts the execution of the program. Exception handling mechanism allows us to deal with such errors gracefully without halting the program.

try-except statement #

In Python, we use try-except statement for exception handling. Its syntax is as follows:

try:
    # try block
    # write code that might raise an exception here
    <statement_1>
    <statement_2>
except ExceptiomType:
    # except block
    # handle exception here
    <handler>

The code begins with the word try, which is a reserved keyword, followed by a colon (:). In the next line we have try block. The try block contains code that might raise an exception. After that, we have an except clause that starts with the word except, which is again a reserved keyword, followed by an exception type and a colon (:). In the next line, we have an except block. The except block contains code to handle the exception. As usual, code inside the try and except block must be properly indented, otherwise, you will get an error.

Here is how the try-except statement executes:

When an exception occurs in the try block, the execution of the rest of the statements in the try block is skipped. If the exception raised matches the exception type in the except clause, the corresponding handler is executed.

If the exception raised in the try block doesn’t matches with the exception type specified in the except clause the program halts with a traceback.

On the other hand, If no exception is raised in the try block, the except clause is skipped.

Let’s take an example:

python101/Chapter-19/exception_handling.py

try:
    num =  int(input("Enter a number: "))
    result = 10/num
    print("Result: ", result)    

except ZeroDivisionError:
    print("Exception Handler for ZeroDivisionError")
    print("We cant divide a number by 0")

Try it now

Run the program and enter 0.

First run output:

Enter a number: 0
Exception Handler for ZeroDivisionError
We cant divide a number by 0

In this example, the try block in line 3 raises a ZeroDivisionError. When an exception occurs Python looks for the except clause with the matching exception type. In this case, it finds one and runs the exception handler code in that block. Notice that because an exception is raised in line 3, the execution of reset of the statements in the try block is skipped.

Run the program again but this time enter a string instead of a number:

Second run output:

Enter a number: str
Traceback (most recent call last):
  File "exception_example.py", line 2, in <module>
    num = int(input("Enter a number: "))
ValueError: invalid literal for int() with base 10: 'str'

This time our program crashes with the ValueError exception. The problem is that the built-in int() only works with strings that contain numbers only, if you pass a string containing non-numeric character it will throw a ValueError exception.

>>>
>>> int("123")              // that's fine because string only contains numbers
123
>>>
>>> int("str")              // error can't converts characters to numbers
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: 'str'
>>>

As we have don’t have an except clause with the ValueError exception, our program crashes with ValueError exception.

Run the program again and this time enter an integer other than 0.

Third run output:

Enter a number: 4
Result:  2.5

Try it now

In this case, statements in the try block executes without throwing any exception, as a result, the except clause is skipped.

Handling Multiple Exceptions #

We can add as many except clause as we want to handle different types of exceptions. The general format of such a try-except statement is as follows:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

try:
    # try block
    # write code that might raise an exception here
    <statement_1>
    <statement_2>
except <ExceptiomType1>:
    # except block
    # handle ExceptiomType1 here
    <handler>
except <ExceptiomType2>:
    # except block
    # handle ExceptiomType2 here
    <handler>
except <ExceptiomType2>:
    # except block
    # handle ExceptiomType3 here
    <handler>
except:
    # handle any type of exception here
    <handler>

Here is how it works:

When an exception occurs, Python matches the exception raised against every except clause sequentially. If a match is found then the handler in the corresponding except clause is executed and rest of the except clauses are skipped.

In case the exception raised doesn’t matches any except clause before the last except clause (line 18), then the handler in the last except clause is executed. Note that the last except clause doesn’t have any exception type in front of it, as a result, it can catch any type of exception. Of course, this last except clause is entirely optional but we commonly use it as a last resort to catch the unexpected errors and thus prevent the program from crashing.

The following program demonstrates how to use multiple except clauses.

python101/Chapter-19/handling_muliple_types_of_exceptions.py

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

try:
    num1 = int(input("Enter a num1: "))
    num2 = int(input("Enter a num2: "))

    result = num1 / num2
    print("Result: ", result)

except ZeroDivisionError:
    print("nException Handler for ZeroDivisionError")
    print("We cant divide a number by 0")

except ValueError:
    print("nException Handler for ValueError")
    print("Invalid input: Only integers are allowed")

except:
    print("nSome unexpected error occurred")

Try it now

First run output:

Enter a num1: 10
Enter a num2: 0

Exception Handler for ZeroDivisionError
We cant divide a number by 0

Second run output:

Enter a num1: 100
Enter a num2: a13

Exception Handler for ValueError
Invalid input: Only integers are allowed

Third run output:

Enter a num1: 5000
Enter a num2: 2
Result:  2500

Here is another example program that asks the user to enter the filename and then prints the content of the file to the console.

python101/Chapter-19/exception_handling_while_reading_file.py

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

filename = input("Enter file name: ")

try:
    f = open(filename, "r")

    for line in f:
        print(line, end="")

    f.close()

except FileNotFoundError:
    print("File not found")

except PermissionError:
    print("You don't have the permission to read the file")

except:
    print("Unexpected error while reading the file")

Try it now

Run the program and specify a file that doesn’t exist.

First run output:

Enter file name: file_doesnt_exists.md
File not found

Run the program again and this time specify a file that you don’t have permission to read.

Second run output:

Enter file name: /etc/passwd
You don't have the permission to read the file

Run the program once more but this time specify a file that does exist and you have the permission to read it.

Third run output:

Enter file name: ../Chapter-18/readme.md
First Line
Second Line
Third Line
Fourth Line
Fifth Line

The else and finally clause #

A try-except statement can also have an optional else clause which only gets executed when no exception is raised. The general format of try-except statement with else clause is as follows:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

try:    
    <statement_1>
    <statement_2>
except <ExceptiomType1>:    
    <handler>
except <ExceptiomType2>:    
    <handler>
else:
    # else block only gets executed
    # when no exception is raised in the try block
    <statement>
    <statement>

Here is a rewrite of the above program using the else clause.

python101/Chapter-19/else_clause_demo.py

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

import os
filename = input("Enter file name: ")

try:
    f = open(filename, "r")

    for line in f:
        print(line, end="")

    f.close()

except FileNotFoundError:
    print("File not found")

except PermissionError:
    print("You don't have the permission to read the file")

except FileExistsError:
    print("You don't have the permission to read the file")

except:
    print("Unexpected error while reading the file")

else:
    print("Program ran without any problem")

Try it now

Run the program and enter a file that doesn’t exist.

First run output:

Enter file name: terraform.txt
File not found

Again run the program but this time enter a file that does exist and you have the permission to access it.

Second run output:

Enter file name: ../Chapter-18/readme.md
First Line
Second Line
Third Line
Fourth Line
Fifth Line
Program ran without any problem

As expected, the statement in the else clause is executed this time. The else clause is usually used to write code which we want to run after the code in the try block ran successfully.

Similarly, we can have a finally clause after all except clauses. The statements under the finally clause will always execute irrespective of whether the exception is raised or not. It’s general form is as follows:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

try:    
    <statement_1>
    <statement_2>
except <ExceptiomType1>:    
    <handler>
except <ExceptiomType2>:    
    <handler>
finally:
    # statements here will always
    # execute no matter what
    <statement>
    <statement>

The finally clause is commonly used to define clean up actions that must be performed under any circumstance. If the try-except statement has an else clause then the finally clause must appear after it.

The following program shows the finally clause in action.

python101/Chapter-19/finally_clause_demo.py

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

import os
filename = input("Enter file name: ")

try:
    f = open(filename, "r")

    for line in f:
        print(line, end="")

    f.close()

except FileNotFoundError:
    print("File not found")

except PermissionError:
    print("You don't have the permission to read the file")

except FileExistsError:
    print("You don't have the permission to read the file")

except:
    print("Unexpected error while reading the file")

else:
    print("nProgram ran without any problem")

finally:
    print("finally clause: This will always execute")

Try it now

First run output:

Enter file name: little.txt
File not found
finally clause: This will always execute

Second run output:

Enter file name: readme.md
First Line
Second Line
Third Line
Fourth Line
Fifth Line
Program ran without any problem
finally clause: This will always execute

Exceptions Propagation and Raising Exceptions #

In the earlier few sections, we have learned how to deal with exceptions using the try-except statement. In this section, we will discuss who throws an exception, how to create an exception and how they propagate.

An exception is simply an object raised by a function signaling that something unexpected has happened which the function itself can’t handle. A function raises exception by creating an exception object from an appropriate class and then throws the exception to the calling code using the raise keyword as follows:

raise SomeExceptionClas("Error message describing cause of the error")

We can raise exceptions from our own functions by creating an instance of RuntimeError() as follows:

raise RuntimeError("Someting went very wrong")

When an exception is raised inside a function and is not caught there, it is automatically propagated to the calling function (and any function up in the stack), until it is caught by try-except statement in some calling function. If the exception reaches the main module and still not handled, the program terminates with an error message.

Let’s take an example.

Suppose we are creating a function to calculate factorial of a number. As factorial is only valid for positive integers, passing data of any other type would render the function useless. We can prevent this by checking the type of argument and raising an exception if the argument is not a positive integer. Here is the complete code.

python101/Chapter-19/factorial.py

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

def factorial(n):
    if  not isinstance(n, int):
        raise RuntimeError("Argument must be int")

    if n < 0:
        raise RuntimeError("Argument must be >= 0")

    f = 1
    for i in range(n):
        f *= n
        n -= 1

    return f

try:
    print("Factorial of 4 is:", factorial(4))
    print("Factorial of 12 is:", factorial("12"))
except RuntimeError:
    print("Invalid Input")

Try it now

Output:

Factorial of 4 is: 24
Invalid Input

Notice that when the factorial() function is called with a string argument (line 17), a runtime exception is raised in line 3. As factorial() function is not handling the exception, the raised exception is propagated back to the main module where it is caught by the except clause in line 18.

Note that in the above example we have coded the try-except statement outside the factorial() function but we could have easily done the same inside the factorial() function as follows.

python101/Chapter-19/handling_exception_inside_factorial_func.py

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

def factorial(n):

    try:
        if not isinstance(n, int):
            raise RuntimeError("Argument must be int")

        if n < 0:
            raise RuntimeError("Argument must be >= 0")

        f = 1
        for i in range(n):
            f *= n
            n -= 1

        return f

    except RuntimeError:
        return  "Invalid Input"

print("Factorial of 4 is:", factorial(4))
print("Factorial of 12 is:", factorial("12"))

Try it now

Output:

Factorial of 4 is: 24
Factorial of 12 is: Invalid Input

However, this is not recommended. Generally, the called function throws an exception to the caller and it’s the duty of the calling code to handle the exception. This approach allows us to to handle exceptions in different ways, for example, in one case we show an error message to the user while in other we silently log the problem. If we were handling exceptions in the called function, then we would have to update the function every time a new behavior is required. In addition to that, all the functions in the Python standard library also conforms to this behavior. The library function only detects the problem and raises an exception and the client decide what it needs to be done to handle those errors.

Now Let’s see what happens when an exception is raised in a deeply nested function call. Recall that if an exception is raised inside the function and is not caught by the function itself, it is passed to its caller. This process repeats until it is caught by some calling function down in the stack. Consider the following example.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

def function3():
    try:

        ...
        raise SomeException()
    statement7
    except ExceptionType4:
        handler
    statement8


def function2():
    try:
        ...
        function3()
        statement5
    except ExceptionType3:
        handler
    statement6

def function1():
    try:
        ...
        function2()
        statement3
    except ExceptionType2:
        handler
    statement4

def main():
    try:
        ...
        function1()
        statement1
    except ExceptionType1:
        handler
     statement2
    
main()

The program execution starts by calling the main() function. The main() function then invokes function1(), function1() invokes function2(), finally function2() invokes function3(). Let’s assume function3() can raise different types of exceptions. Now consider the following cases.

1. If the exception is of type ExceptionType4, statement7 is skipped and the except clause in line 7 catches it. The execution of function3() proceeds as usual and statement8 is executed.

2. If exception is of type ExceptionType3, the execution of function3() is aborted (as there is no matching except clause to handle the raised exception) and the control is transferred to the caller i.e function2() where ExceptionType3 is handled by the except clause in line 17. The statement5 in function2() is skipped and statement6 is executed.

3. If the exception is of type ExceptionType2, function3() is aborted and the control is transferred to the function2(). As function2() doesn’t have any matching except clause to catch the exception, its execution is aborted and control transferred to the function1() where the exception is caught by the except clause in line 26. The statement3 in function1() is skipped and statement4 is executed.

4. If the exception is of type ExceptionType1, then control is transferred to the function main() (as function3(), function2() and function1() doesn’t have matching except clause to handle the exception) where the exception is handled by except clause in line 35. The statement1 in main() is skipped and statement2 is executed.

5. If the exception is of type ExceptionType0. As none of the available functions have the ability to handle this exception, the program terminates with an error message.

Accessing Exception Object #

Now we know how to handle exceptions as well throw them whenever needed. One thing we didn’t yet cover is how to access exception object thrown by the function. We can access exception object using the following form of except clause.

except ExceptionType as e

From now on, whenever except clause catches an exception of type ExceptionType it assigns the exception object to the variable e.

The following example demonstrates how to access an exception object:

python101/Chapter-19/accessing_exception_object.py

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

def factorial(n):
    if not isinstance(n, int):
        raise RuntimeError("Argument must be int")

    if n < 0:
        raise RuntimeError("Argument must be >= 0")

    f = 1
    for i in range(n):
        f *= n
        n -= 1

    return f


try:
    print("Factorial of 4 is:", factorial(4))
    print("Factorial of 12 is:", factorial("12"))

except RuntimeError as e:
    print("Error:", e)

Try it now

Output:

Factorial of 4 is: 24
Error: Argument must be int

Notice that the error message printed by exception object (line 21) is the same which we passed while creating creating RuntimeError object (line 3).

Creating Your Own Exceptions #

So far in this chapter we have been using built-it exception classes such as ZeroDivisionError, ValueError, TypeError, RuntimeError etc. Python also allows you to create new exception classes to cater you own specific needs. The BaseException class is the root of all exception classes in Python. The following figure shows exception class hierarchy in Python.

We can create our own exception class by deriving it from Exception built-in class. The following examples shows how to create a custom exception.

python101/Chapter-19/InvalidFactorialArgumentException.py

class InvalidFactorialArgumentException(Exception):
    def __init__(self, message):
        super().__init__()
        self.message = message

    def __str__(self):
        return self.message

python101/Chapter-19/factorialWithCustomException.py

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

from InvalidFactorialArgumentException import *

def factorial(n):
    if not isinstance(n, int):
        raise InvalidFactorialArgumentException("Argument must be int")

    if n < 0:
        raise InvalidFactorialArgumentException("Argument must be >= 0")

    f = 1
    for i in range(n):
        f *= n
        n -= 1

    return f


try:
    print("Factorial of 4 is:", factorial(4))
    print("Factorial of 12 is:", factorial("12"))

except InvalidFactorialArgumentException as e:
    print("Error:", e)

Try it now

Output:

Factorial of 4 is: 24
Error: Argument must be int

Example:
Internet Error
FileNotFound Error
Division Error
Value Error

try:
    Read data from Remote file locating at Landon
    
except FileNotFoundError:
       use a local file and continue rest of the program normally    

value=10
##missed colon(:) in the below line 
if value==10
   print("Hello")

##The output is:
 File "C:UsersUserAnaconda3libsite-packagesspyder_kernelscustomizespydercustomize.py", line 110, in execfile
    exec(compile(f.read(), filename, 'exec'), namespace)

  File "C:/Users/User/.spyder-py3/temp.py", line 2
    if value==10
            ^
SyntaxError: invalid syntax

Example 1:
print(10/0)
##The output is:
  File "C:/Users/User/.spyder-py3/temp.py", line 1, in <module>
    print(10/0)

ZeroDivisionError: division by zero

Example 2:
Info=int(input("Enter Number:"))
print(Info)
##The output is:
Enter Number:Ten
Traceback (most recent call last):

  File "<ipython-input-5-5ba32625e270>", line 1, in <module>
    runfile('C:/Users/User/.spyder-py3/temp.py', wdir='C:/Users/User/.spyder-py3')

  File "C:UsersUserAnaconda3libsite-packagesspyder_kernelscustomizespydercustomize.py", line 786, in runfile
    execfile(filename, namespace)

  File "C:UsersUserAnaconda3libsite-packagesspyder_kernelscustomizespydercustomize.py", line 110, in execfile
    exec(compile(f.read(), filename, 'exec'), namespace)

  File "C:/Users/User/.spyder-py3/temp.py", line 1, in <module>
    Info=int(input("Enter Number:"))

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

try:
 Risky Code
except YYY:
 Handling code/Alternative Code

print("statement-1")
print(10/0)
print("statement-3")
##The output is:

  File "C:/Users/User/.spyder-py3/temp.py", line 2, in <module>
    print(10/0)

ZeroDivisionError: division by zero

print("statement-1")
try:
    print(10/0)
except ZeroDivisionError:
    print(10/2)
print("statement-3")

try:
    print("statement-1")
    print(10/0)
    print("Statement-3")
    
except ZeroDivisionError:
    print("Statement-4")
print("statement-5")    

try:
    print("statement-1")
    print("statement-2")  #Risky Code
except NameOfTheError as ReferenceVariable: #as is the keyword we have to use compulsory
    print("Statement-3")
print("statement-4")    

try:
    print(10/0)
except ZeroDivisionError as msg:
    print("Exception Type:", type(msg))

try:
    print(10/0)
except ZeroDivisionError as msg:
    print("Exception Type:", type(msg))
    print("Exception Type:",msg.__class__) ##printing the corresponding class object

try:
    print(10/0)
except ZeroDivisionError as msg:
    print("Exception Type:", type(msg))
    print("Exception Type:",msg.__class__)
##Printing exception class name
    print("Exception Type:", msg.__class__.__name__) 

try:
    print(10/0)
except ZeroDivisionError as msg:
##Printing the description of exception
    print("Description of Exception:", msg)

try:
    first_value=int(input("Enter First Number:"))
    second_value=int(input("Enter Second Number:"))
    print("The Result:",first_value/second_value)
except BaseException as result:
    print("Exception Type:", type(result))
    print("Exception Type:", type.__class__)
    print("Exception Class Name:", result.__class__.__name__)
    print("Description of Exception:", result)    

try:
   print("statement-1")
except NameOfError:
  perform alternative operation
except NameOfError:
  use local file instead of remote file

try:
    value_one=int(input("Enter First Number:"))
    value_second=int(input("Enter Second Number:"))
    print("The Result:",value_one/value_second)
except ZeroDivisionError:
    print("Cannot Divide with Zero")
except ValueError:
    print("Please Provide int values only")    

try:
    print(20/0)
except ZeroDivisionError:    
    print("ZeroDivisionError")
except ArithmeticError:
    print("ArithmeticError")
    

try:
    print(20/0)
except ArithmeticError:
    print("ArithmeticError")
except ZeroDivisionError:    
    print("ZeroDivisionError")    
    

except(Exception1, Exception2,...):
except(Exception1, Exception2,...) as msg:

try:
    value_one=int(input("Enter First Number:"))
    value_second=int(input("Enter Second Number:"))
    print("The Result:",value_one/value_second)
except (ZeroDivisionError, ValueError) as msg:
    print("The Raised Exception:", msg.__class__.__name__)
    print("Description of Exception:", msg)   
    print("Please provide valid inputs only...")

except: 
          statements

try:
    value_one=int(input("Enter First Number:"))
    value_second=int(input("Enter Second Number:"))
    print("The Result:",value_one/value_second)
except ZeroDivisionError:
    print("ZeroDivisionError:cannot divide wih zero")
except:
    print("Default Except:please provide valid input only")

try:
    value_one=int(input("Enter First Number:"))
    value_second=int(input("Enter Second Number:"))
    print("The Result:",value_one/value_second)
except:
    print("Default Except:please provide valid input only")

try:
    Risky code:
except:
       Handling code
finally:
      Cleanup code

try:
    print("try")
except ZeroDivisionError:
    print("Except")
finally:
    print("finally")

try:
    print("try")
    print(10/0)
except ZeroDivisionError:
    print("Except")
finally:
    print("finally")

try:
    print("try")
    print(10/0)
except ValueError:
    print("Except")
finally:
    print("finally")

import os
try:
    print("try")
    os._exit(0)
except ValueError:
    print("except")
finally:
    print("finally")

The output is:
try

try:
    print(statement-1)
    print(statement-2)
    print(statement-3)
except:
    print(statement-4)
finally:
    print(statement-5)
print(statement-6)   

try:
    print("outer try block")
    try:
        print("Inner try block")
    except ZeroDivisionError:
        print("Inner except block")
    finally:
        print("Inner finally block")
except:
    print("outer except block")
finally:
    print("outer finally block")        

try:
    print("outer try block")
    try:
        print("Inner try block")
        print(10/0)
    except ZeroDivisionError:
        print("Inner except block")
    finally:
        print("Inner finally block")
except:
    print("outer except block")
finally:
    print("outer finally block")     

try:
    print("outer try block")
    try:
        print("Inner try block")
        print(10/0)
    except ValueError:
        print("Inner except block")
    finally:
        print("Inner finally block")
except:
    print("outer except block")
finally:
    print("outer finally block")   

try:
    print("outer try block")
    print(10/0)
    try:
        print("Inner try block")
        
    except ValueError:
        print("Inner except block")
    finally:
        print("Inner finally block")
except:
    print("outer except block")
finally:
    print("outer finally block")   

value=10
if value>10:
    print("value is greater than 10")
else:
    print("value is less than 10")

for info in range(10):
    print("The Current Item:",info)
else:
    print("congratulations, all item processed successfully")

for info in range(10):
    if info>5:
        break
    print("The Current Item:",info)
else:
    print("congratulations, all item processed successfully")

try:
    Risky code
except:
    Handling code
    will be executed if an exception inside try
else:
    will be executed if there is no exception inside try
finally:
    cleanup code
    will be executed whether exception raised or not raised and handled or not handled    

try:
   print("try")
except:
       print("Except")
else:
     print("Else")
finally:
      print("Finally")

try:
   print("try")
   print(10/0)
except:
       print("Except")
else:
     print("Else")
finally:
      print("Finally")

try:
   print("try")
else:
     print("Else")
finally:
      print("Finally")

file=None
try:
    file=open("info.txt","r")
except:
    print("Some problem while locating and opening the file")
else:
     print("File opened successfully")
     print("The data present in the file is:")
     print("#",*30)
     print(file.read())
finally:
    if file is not None:
        file.close()

File opened successfully
The data present in the file is:
#############################
Line-1 of abc.txt file
Line-2 of abc.txt file
Line-3 of abc.txt file
Line-4 of abc.txt file
Line-5 of abc.txt file

print(10/0)  #ZeroDivisionError

data=int("Ten") ##ValueError

InsufficientFundsException
InvalidPinException
TooYoungException
TooOldException

class NameofException(PredefinedException):
     def __init__(self,msg):
           self.msg=msg

class TooYongException(Exception):
      def __init__(self,msg):
            self.msg=msg

raise TooYoungException("Massage")

class TooYoungException(Exception):
    def __init__(self,msg):
        self.msg=msg
        
class TooOldException(Exception):
    def __init__(self,msg):
        self.msg=msg
        
age=int(input("Enter Age:"))
if age>17:
    raise TooYoungException("Please Wait some more time, definitely you will get chance to vote")
elif age>18:
   raise TooOldException("Now, you are eligible to vote")
else:
    print("As per the gov rules the age should 18 to participate in voting")        

0 results

Exceptions in Python

In this lesson, we will understand what is Exception Handling in Python Programming and how to implement it along with some examples.

What is Exception in Python?

An exception is a runtime error that only appears when we run a python program, and the process of eliminating runtime errors from a program is known as Exception Handling.

There are three types of errors that can arise in a python program, and they are:

• Compile Time Errors or Syntax Errors
• Logical Errors
• Runtime Errors

Compile Time Errors or Syntax Errors

Compile Time Errors occur when a program fails to compile because of the wrong syntax used in the program statement. The python compiler show this type of error along with the line number and description of the error.

Let’s see how a syntax error appeared in a program when we forgot to give a semicolon at the end of a for loop statement.

for i in range(1,6)
    print(i)

Traceback (most recent call last):
  File "D:examplesyntaxerror.py", line 1
    for i in range(1,6)
                      ^
SyntaxError: invalid syntax

Logical Errors

Logical Errors occur when a programmer implements the wrong logic in a program. As a result, the final output of the program becomes wrong. The python compiler and python virtual machine (PVM) can’t detect logical errors. It is the programmer’s responsibility to figure out and rectify this type of error in a program.

print('Enter 3 numbers')
a=int(input())
b=int(input())
c=int(input())
average = a+b+c/3
print('Average = %.2f' %(average))

Enter 3 numbers
12
31
17
Average = 48.666667

In the above example, the average of the three numbers is 48.666667, which is wrong because there is a logical error in calculating the average. They should be calculated as (a+b+c)/3, giving us the correct average of 20.

Runtime Errors

Runtime Errors occur when the PVM fails to execute the code after compilation. The python compiler can’t detect the runtime errors. It is only detected by the PVM while executing the code.

print('Enter 2 numbers')
a = int(input())
b = int(input())
c = a/b
print('Result = %f' %(c))

Enter 2 numbers
5
0
Traceback (most recent call last):
  File "D:examplelogicalerror.py", line 4, in 
    c = a/b
ZeroDivisionError: division by zero

In the above example, when we try to divide 5 by 0, the PVM gives a runtime error because 5 can’t be divided by 0.

x = [12, 36, 72, 37, 81]
print(x[3])
print(x[5])

37
Traceback (most recent call last):
  File "D:examplepro.py", line 3, in 
    print(x[5])
IndexError: list index out of range

In the above example, when we try to access index 5 in the list, it gives a runtime error because there is no such index available.

List of Built-in Exceptions in Python

Below we have given some of the important lists of built-in exceptions in python that are normally raised in a python program.

Exception Handling

We can handle exceptions in a python program using the following blocks.

• try block
• except block
• else block
• finally block

try block

In the try block, the programmer will write such statements that may cause exceptions in the program.

try:
    statement
    statement
    ...
    ...
    ...

except block

The programmer writes the except block, including the exception name to be handled in this block. Here programmer will display a detailed message to the user regarding the exception that has occurred in the program.

except exceptionname:
    message statement
    ...
    ...
    ...

else block

The else block is an optional block where the programmer writes statements that execute if there is no exception in the try block.

else:
    statement
    statement
    ...
    ...
    ...

finally block

The finally block is also an optional block where the programmer writes statements that are executed irrespective of whether an exception has occurred in the try block or not.

finally:
    statement
    statement
    ...
    ...
    ...

Let’s handle the exception when a number is divided by 0.

try:
    print('Enter 2 numbers')
    a = int(input())
    b = int(input())
    c = a/b
    print('Result = %f' %(c))

except ZeroDivisionError:
    print('A number can not be divide by 0')

Enter 2 numbers
5
0
A number can not be divide by 0

To print only the default message of an exception, we have to define the exception name with a new name using the keyword as. After that, we can use the alias name to print the default message of the exception. See the example given below.

try:
    print('Enter 2 numbers')
    a = int(input())
    b = int(input())
    c = a/b
    print('Result = %f' %(c))

except ZeroDivisionError as ex:
    print(ex)

Enter 2 numbers
24
0
division by zero

In the above program, we have defined ex as the new name of the exception ZeroDivisionError.

Let’s see an example of handling multiple exceptions using the multiple except blocks.

try:
    print('Enter 2 numbers')
    a = int(input())
    b = int(input())
    c = a/b
    print('Result = %f' %(c))

    data = [12, 84, 36, 91, 57]
    print(data)
    print('Enter index to print the value from the above list')
    i = int(input())
    print('The value at index %d = %d' %(i,data[i]))

except ZeroDivisionError:
    print('A number can not be divide by 0 Try again')

except IndexError:
    print('The index your are looking for does not exist in the list')

Enter 2 numbers
5
2
Result = 2.500000
[12, 84, 36, 91, 57]
Enter index to print the value from the above list
6
The index your are looking for does not exist in the list

In the above example, we have implemented two except blocks to handle two different types of exceptions that may occur within the try block.

Let’s see how to implement else block along with try and except blocks.

try:
    data = [12, 84, 36, 91, 57]
    print(data)
    print('Enter index to print the value from the above list')
    i = int(input())
    print('The value at index %d = %d' %(i,data[i]))

except IndexError:
    print('The index your are looking for does not exist in the list')

else:
    print('Program executed successfully')

[12, 84, 36, 91, 57]
Enter index to print the value from the above list
2
The value at index 2 = 36
Program executed successfully

In the above program, if no exception arises in the try block, then the codes written in the else block will execute.

Let’s see one more example of how to implement else and finally block along with try and except blocks.

try:
    print('Enter 2 numbers')
    a = int(input())
    b = int(input())
    c = a/b
    print('Result = %f' %(c))

except ZeroDivisionError:
    print('A number can not be divide by 0 Try again')

else:
    print('No exception arises')

finally:
    print('Program ends')

Enter 2 numbers
5
0
A number can not be divide by 0 Try again
Program ends

Enter 2 numbers
5
2
Result = 2.500000
No exception arises
Program ends

If an exception arises in the try block, then the except and finally, blocks will execute. If no exception arises in the try block, then both else and finally block will execute. See the output of the above program.

Raise an Exception in Python

We can manually raise an exception in python program using the raise keyword.

print('Enter a number between 1 to 7')
n = int(input())
if n<1 or n>7:
    raise Exception('Invalid Input')

Enter a number between 1 to 7
0
Traceback (most recent call last):
  File "D:exampleraiseexception.py", line 4, in 
    raise Exception('Invalid Input')
Exception: Invalid Input

User-Defined Exceptions

Sometimes a programmer may want a specific type of exception which is not available in the built-in exceptions list. In that case, the programmer can create a new user-defined exception class by inheriting the Exception class in it.

class RangeError(Exception):
    def __init__(self, msg):
        super().__init__(msg)

print('Enter a number in range 1 to 5')
n = int(input())

if n<1 or n>5:
    raise RangeError('Number not in range')

Enter a number in range 1 to 5
8
Traceback (most recent call last):
  File "D:examplecustomerror.py", line 9, in 
    raise RangeError('Number not in range')
RangeError: Number not in range

In the above example, we have created a new custom error class named RangeError by inheriting the Exception class. After that, inside the sub-class (RangeError) constructor, using the super() function, we initialized the base class (Exception) constructor with the msg argument.

At last, we have used the raise keyword to raise errors using our user-defined exception class RangeError.