Error division by zero python

ZeroDivisionError occurs when a number is divided by a zero. In Mathematics, when a number is divided by a zero, the result is an infinite number. It is impossible to write an Infinite number physically. Python interpreter throws “ZeroDivisionError: division by zero” error if the result is infinite number.

You can divide a number by another number. The division operation divides a number into equal parts or groups. Dividing a number into zero pieces or zero groups is meaning less. In mathematics, dividing a number by zero is undefined.

If a number is divided by zero, the result wil be infinite number. Python can not handle the infinite number because the infinite number is difficult to write in concrete form. In this case, Python throws “ZeroDivisionError: division by zero”. The error would be thrown as like below.

Traceback (most recent call last):
  File "/Users/python/Desktop/test.py", line 3, in <module>
    c=a/b;
ZeroDivisionError: integer division or modulo by zero
[Finished in 0.1s with exit code 1]

Different Variation of the error

In different contexts the Zero Division Error-division by zero is thrown in various forms in python. The numerous variations of ZeroDivisionError are given below.

ZeroDivisionError: integer division or modulo by zero
ZeroDivisionError: long division or modulo by zero
ZeroDivisionError: float division by zero
ZeroDivisionError: complex division by zero
ZeroDivisionError: division by zero

Root Cause

The zero division error is due to either a number being divided by zero, or a number being modulo by zero. The denominator of the division operation should be a non zero numeric value. If the demonimator is zero then ZeroDivisionError will be thrown by python interpreter.

Dividing a number into zero pieces or zero groups does not make sense. The result is infinite number not representable in python. Therefore, python throws “ZeroDivisionError: integer division or modulo by zero”. This error occurs for all numbers such as integer, long, float and complex number

How to reproduce this issue

A number must be divided by an another non zero number. Python interpreter will throw ZeroDivisionError if you create a simple program with a number divided by zero. If the division denominator is set to zero, then this error will occur.

The example code below shows how this issue can be reproduced.

a = 8
b = 0
c = a / b
print c

Output

Traceback (most recent call last):
  File "C:UsersUserDesktoppython.py", line 3, in <module>
    c = a / b
ZeroDivisionError: division by zero

Traceback (most recent call last):
  File "/Users/python/Desktop/test.py", line 3, in <module>
    c = a / b
ZeroDivisionError: integer division or modulo by zero
[Finished in 0.0s with exit code 1]

Solution 1

Python can not divide a number by zero. Before doing a division or modulo operation, the denominator must be verified for nonzero. The code below shows how to handle a denominator when it is zero.

a = 8
b = 0
c = ( a / b ) if b != 0 else 0
print c

Output

0

Solution 2

If the program is not sure of the denominator value, the denominator value may be zero in some rare cases. In this case, handle the ZeroDivisionError when it occurs. The example below shows how to handle the exception of ZeroDivisionError in the code.

try:
	a = 8
	b = 0
	c = a / b
except ZeroDivisionError:
	c = 0
print c

Output

0

Solution 3

In the program, if the denominator is zero, the output of the division operation can be set to zero. Mathematically, this may not be correct. Setting zero for the division operation will solve this issue in real-time calculation. The following code shows how to set the zero for the division operation.

a = 8
b = 0
if b == 0:
	c = 0
else:
	c = a / b
print c

Output

0

To solve ZeroDivisionError: division by zero, use the try-except statement. The try block lets you test a block of code for errors. The except block enables you to handle the error.

ZeroDivisionError is a built-in Python exception thrown when a number is divided by 0. As a common mathematics rule, a number divided by 0 is infinity. Therefore, this error may cause even when a number is modulo by 0. The ZeroDivisionError can be handled by exception handlers.

We can put the block of code that can cause an error into the try block and test the code. For example, in the exception block name, the exception is ZeroDivisionError the exception will be executed if the number is divided by zero.

Example

a = int(input("enter the value for a: "))
b = int(input("enter the value for b: "))

c = a / b
print(c)

Output

enter the value for a: 10
enter the value for b: 0

Traceback (most recent call last):
File "/Users/krunallathiya/Desktop/Code/R/data.py", line 4, in <module>
c = a / b
ZeroDivisionError: division by zero

In this example, let us consider the value for variable a = 10 and the value for b = 0. When the program gets executed, the error is raised. The error raised is called the ZeroDivisionError.

If the value of b is given as 2, the program would have executed successfully. Even when the value of a is 0, the program works fine and prints 0 as output.

But if we pass b = 0, it creates an error. Only during division operation is performed is this error raised.

Solve ZeroDivisionError: division by zero using if

Use the if statement to solve the ZeroDivisionError in Python. You can check the value of the denominator using the if statement if you divide a number by a denominator value. If the denominator value is zero, we execute the else statement; otherwise, it will execute the if statement.

a = int(input("enter the value for a: "))
b = int(input("enter the value for b: "))

if(b > 0):
   c = a / b
   print(c)
else:
   print("The value of b should be greater than 0")

Output

enter the value for a: 10
enter the value for b: 0

The value of b should be greater than 0

Use try-except to solve ZeroDivisionError

The try-except approach can be used to handle the exception. The ZeroDivisionError occurs when we divide numbers and find the denominator 0.

Using the try-except approach, we are putting division code inside the try block, and if it finds an exception, then except block will be executed.

a = int(input("enter the value for a: "))
b = int(input("enter the value for b: "))

try:
  c = a / b
except ZeroDivisionError:
  print("The value of b should not be equal to 0 please change the value for b")
  c = 0
print(c)

Output

enter the value for a: 10
enter the value for b: 0

The value of b should not be equal to 0 please change the value for b
0

If you encounter ZeroDivisionError in Python, it suggests that there is a number dividing by zero or the denominator’s value is zero. To handle this exception, use the try-except block and handle the exception, and you can set the output as 0, which is optional.

That’s it for this tutorial.

See also

Only size-1 arrays can be converted to Python scalars

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

Прежде чем переходить к обсуждению того, почему обработка исключений так важна, и рассматривать встроенные в 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 их обрабатывает.

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

Исключения (Exceptions) Python

Исключения (exceptions) — ещё один тип данных в python. Исключения необходимы для того, чтобы сообщать программисту об ошибках.
Самый простой пример исключения — деление на ноль. Если попробовать запустить такую программу

z = 100 / 0

она завершится с ошибкой

Traceback (most recent call last):
  File "", line 1, in 
ZeroDivisionError: division by zero

ZeroDivisionError — это название исключения, а division by zero — его краткое описание. Также Python сообщит
номер строки, где это исключение возникло.

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

z = 2 + '1'

произойдет
исключение TypeError

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

В этом примере генерируется исключение TypeError. Подсказки дают нам полную информацию о том, где порождено исключение, и с чем оно связано.

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

• BaseException — базовое исключение, от которого берут начало все остальные.

  • SystemExit — исключение, порождаемое функцией sys.exit при выходе из программы.
  • KeyboardInterrupt — порождается при прерывании программы пользователем (обычно сочетанием клавиш Ctrl+C).
  • GeneratorExit — порождается при вызове метода close объекта generator.
  • Exception — а вот тут уже заканчиваются полностью системные исключения (их лучше не трогать) и начинаются обыкновенные, с которыми можно работать.
    • StopIteration — порождается встроенной функцией next, если в итераторе больше нет элементов.
    • ArithmeticError — арифметическая ошибка.
      • FloatingPointError — порождается при неудачном выполнении операции с плавающей запятой. На практике встречается нечасто.
      • OverflowError — возникает, когда результат арифметической операции слишком велик для представления. Не появляется при обычной работе с целыми числами (так как python поддерживает длинные числа), но может возникать в некоторых других случаях.
      • ZeroDivisionError — деление на ноль.
    • AssertionError — выражение в функции assert ложно.
    • AttributeError — объект не имеет данного атрибута (значения или метода).
    • BufferError — операция, связанная с буфером, не может быть выполнена.
    • EOFError — функция наткнулась на конец файла и не смогла прочитать то, что хотела.
    • ImportError — не удалось импортирование модуля или его атрибута.
    • 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 — возникает, когда абстрактные методы класса требуют переопределения в дочерних классах.
    • SyntaxError — синтаксическая ошибка.
      • IndentationError — неправильные отступы.
        • TabError — смешивание в отступах табуляции и пробелов.
    • SystemError — внутренняя ошибка.
    • TypeError — операция применена к объекту несоответствующего типа.
    • ValueError — функция получает аргумент правильного типа, но некорректного значения.
    • UnicodeError — ошибка, связанная с кодированием / раскодированием unicode в строках.
      • UnicodeEncodeError — исключение, связанное с кодированием unicode.
      • UnicodeDecodeError — исключение, связанное с декодированием unicode.
      • UnicodeTranslateError — исключение, связанное с переводом unicode.

• Warning — Базовый класс для исключений-предупреждений.
  Данное семейство исключений представляет собой различные категории предупреждений.

  • BYTESWARNING — Предупреждения, связанные с возможными проблемами при работе с байтами.
    Данная категория предупреждений используется в случаях возможных ошибок при работе с бйтами (bytes и bytearray).
  • DeprecationWarning — Категория предупреждений о функциональности нежелательной к использованию.
    Эту категорию обычно используют для указания на то, что некая часть функциональности морально устарела (возможно ей на смену пришла более совершенная) и не рекомендуется к использованию.
  • FUTUREWARNING — Категория, описывающая предупреждения об изменениях в будущем.
    Предупреждения данной категории призваны оповещать о грядущих [семантических] изменениях.
    Пример предупреждения о грядущих изменениях из numpy:
    FutureWarning: comparison to ‘None‘ will result in an elementwise object comparison in the future.
  • IMPORTWARNING — предупреждение о вероятной ошибке при импорте модуля.
    Предупреждения данной категории могут использоваться, например, в случаях внесения изменений в систему импорта при помощи перехватчиков (хуков).
  • PendingDeprecationWarning — Категория предупреждений о функциональности, которая вскоре должна стать нежелательной к использованию.
  • ResourceWarning — Предупреждения, связанные с возможными проблемами при работе с ресурсами.
    Примером использования данной категории предупреждений можут служить указание на необходимость закрытия сокета, что необходимо для высвобождения ресурсов.
  • RuntimeWarning — Предупреждение о сомнительном поведении во время исполнения.
    Категория может быть использована для обозначения сомнительного поведения приложения, например, если код выявил вероятные погрешности в вычислениях.
  • SyntaxWarning — Предупреждение об использовании сомнительных синтаксических конструкций.
    Категория используется в случаях, когда замечены вероятные синтаксические ошибки.
  • UnicodeWarning — Предупреждения, связанные с возможными проблемами при работе с Юникод.
  • USERWARNING — Класс для пользовательских предупреждений.
    Может использоваться пользователями в качестве базового класса для создания собственных иерархий предупреждений.

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

Первый пример применения этой конструкции:

try:
    k = 1 / 0
except ZeroDivisionError:
    k = 0
print(k)

0

В блоке try мы выполняем инструкцию, которая может породить исключение, а в блоке except мы перехватываем их. При этом перехватываются как само исключение, так и его потомки. Например, перехватывая ArithmeticError, мы также перехватываем FloatingPointError, OverflowError и ZeroDivisionError.

try:
    k = 1 / 0
except ArithmeticError:
    k = 0
print(k)

0

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

Ещё две инструкции, относящиеся к нашей проблеме, это finally и else. Finally выполняет блок инструкций в любом случае, было ли исключение, или нет (применима, когда нужно непременно что‑то сделать, к примеру, закрыть файл). Инструкция else выполняется в том случае, если исключения не было.

f = open('1.txt')
ints = []
try:
    for line in f:
        ints.append(int(line))
except ValueError:
    print('Это не число. Выходим.')
except Exception:
    print('Это что ещё такое?')
else:
    print('Всё хорошо.')
finally:
    f.close()
    print('Я закрыл файл.')
    # Именно в таком порядке: try, группа except, затем else, и только потом finally.

Это не число. Выходим.
Я закрыл файл.

Иногда, во время работы программы случаются непредвиденные ситуации. Например, попытка поделить число на ноль или чтение несуществующего файла вызовут ошибку и остановят выполнение программы. Такие ситуации в программировании называют исключительными ситуациями, а ошибки — исключениями (exception). Для разных ситуаций есть свои типы исключений:

2 / 0  # ZeroDivisionError: division by zero

open('non_existing_file.txt')  # FileNotFoundError: No such file or directory

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

# Файл example.py

def average(numbers):
    return sum(numbers) / len(numbers)
    
average([1, 2, 3])  # Вернёт 2
average([])  # Сделает ба-бах!

Выйдет такая ошибка:

Traceback (most recent call last):        # 6
  File "example.py", line 5, in <module>  # 5
    average([])                           # 4
  File "example.py", line 2, in average   # 3
    return sum(numbers) / len(numbers)    # 2
ZeroDivisionError: division by zero       # 1

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

Важно: трейсбек читают снизу вверх. Именно поэтому мы расставили такую нумерацию строчек в примере.

Давайте разберём каждую строчку в примере выше:

1) ZeroDivisionError: division by zero — тип исключения и сообщение с причиной ошибки. Если перевести на русский, сразу понятно: ОшибкаДеленияНаНоль: вы поделили на ноль.

2) return sum(numbers) / len(numbers) — строка, на которой произошла ошибка.

3) File "example.py", line 2, in average — где эту строку искать. В файле example.py, на второй строке, в функции average.

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

6) Начало трейсбэка

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

Как перехватить ошибку

Если возникшее исключение — часть плана или вы хотите обработать его особенном образом, то на такой случай в Python существует конструкция try-except:

filepath = user.get_avatar_filepath()
try:
    avatar = Image.open(filepath)
except FileNotFoundError:
    avatar = default_avatar

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

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

Код, в котором не указан тип ошибки выглядит так:

filepath = user.get_avatar_filepath()
try:
    avatar = use_avatar(filepath)
except:
    avatar = default_avatar

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

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

Что ещё почитать

• Где обработать исключение