oop/exeption.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Обработка ошибок и исключений\n",
    "\n",
    "\n",
    "При программировании на Python мы можем столкнуться с двумя типами ошибок. Первый тип представляют **синтаксические ошибки** (`syntax error`). Они появляются в результате нарушения синтаксиса языка программирования при написании исходного кода. При наличии таких ошибок программа не может быть скомпилирована. При работе в какой-либо среде разработки, например, в `PyCharm`, `IDE` сама может отслеживать синтаксические ошибки и каким-либо образом их выделять.\n",
    "\n",
    "Второй тип ошибок представляют **ошибки выполнения** (`runtime error`). Они появляются в уже скомпилированной программе в процессе ее выполнения. Подобные ошибки еще называются исключениями. Например, в прошлых темах мы рассматривали преобразование строки в число:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "string = \"5\"\n",
    "number = int(string)\n",
    "print(number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Данный скрипт успешно скомпилируется и выполнится, так как строка \"5\" вполне может быть конвертирована в число. Однако возьмем другой пример:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "invalid literal for int() with base 10: 'hello'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[0;32mIn [2], line 2\u001b[0m\n\u001b[1;32m      1\u001b[0m string \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mhello\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m----> 2\u001b[0m number \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mint\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mstring\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m      3\u001b[0m \u001b[38;5;28mprint\u001b[39m(number)\n",
      "\u001b[0;31mValueError\u001b[0m: invalid literal for int() with base 10: 'hello'"
     ]
    }
   ],
   "source": [
    "string = \"hello\"\n",
    "number = int(string)\n",
    "print(number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "При выполнении этого скрипта будет выброшено исключение `ValueError`, так как строку `\"hello\"` нельзя преобразовать в число\n",
    "\n",
    "С одной стороны, здесь очевидно, что строка не представляет число, но мы можем иметь дело с вводом пользователя, который также может ввести не совсем то, что мы ожидаем:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "invalid literal for int() with base 10: 'a'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[0;32mIn [4], line 2\u001b[0m\n\u001b[1;32m      1\u001b[0m string \u001b[38;5;241m=\u001b[39m \u001b[38;5;28minput\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mВведите число: \u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m----> 2\u001b[0m number \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mint\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mstring\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m      3\u001b[0m \u001b[38;5;28mprint\u001b[39m(number)\n",
      "\u001b[0;31mValueError\u001b[0m: invalid literal for int() with base 10: 'a'"
     ]
    }
   ],
   "source": [
    "string = input(\"Введите число: \")\n",
    "number = int(string)\n",
    "print(number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "При возникновении исключения работа программы прерывается, и чтобы избежать подобного поведения и обрабатывать исключения в Python есть конструкция try..except.\n",
    "\n",
    "## try..except\n",
    "\n",
    "Конструкция try..except имеет следующее формальное определение:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    инструкции\n",
    "except [Тип_исключения]:\n",
    "    инструкции"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Весь основной код, в котором потенциально может возникнуть исключение, помещается после ключевого слова `try`. Если в этом коде генерируется исключение, то работа кода в блоке `try` прерывается, и выполнение переходит в блок `except`.\n",
    "\n",
    "После ключевого слова `except` опционально можно указать, какое исключение будет обрабатываться (например, `ValueError` или `KeyError`). После слова except на следующей стоке идут инструкции блока `except`, выполняемые при возникновении исключения.\n",
    "\n",
    "Рассмотрим обработку исключения на примере преобразовании строки в число:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Преобразование прошло неудачно\n",
      "Завершение программы\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    number = int(input(\"Введите число: \"))\n",
    "    print(\"Введенное число:\", number)\n",
    "except ValueError:\n",
    "    print(\"Преобразование прошло неудачно\")\n",
    "print(\"Завершение программы\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как видно из консольного вывода, при вводе строки вывод числа на консоль не происходит, а выполнение программы переходит к блоку except.\n",
    "\n",
    "Теперь все выполняется нормально, исключение не возникает, и соответственно блок except не выполняется."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Блок finally\n",
    "\n",
    "При обработке исключений также можно использовать необязательный блок `finally`. Отличительной особенностью этого блока является то, что он выполняется вне зависимости, было ли сгенерировано исключение:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Блок try завершил выполнение\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "invalid literal for int() with base 10: 'a'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[0;32mIn [7], line 2\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m----> 2\u001b[0m     number \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mint\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mВведите число: \u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m      3\u001b[0m     \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mВведенное число:\u001b[39m\u001b[38;5;124m\"\u001b[39m, number)\n\u001b[1;32m      4\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mZeroDivisionError\u001b[39;00m:\n",
      "\u001b[0;31mValueError\u001b[0m: invalid literal for int() with base 10: 'a'"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    number = int(input(\"Введите число: \"))\n",
    "    print(\"Введенное число:\", number)\n",
    "except ZeroDivisionError:\n",
    "    print(\"Преобразование прошло неудачно\")\n",
    "finally:\n",
    "    print(\"Блок try завершил выполнение\")\n",
    "print(\"Завершение программы\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как правило, блок `finally` применяется для освобождения используемых ресурсов, например, для закрытия файлов."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# except и обработка разных типов исключений\n",
    "\n",
    "## Встроенные типы исключений\n",
    "\n",
    "В примере выше обрабатывались сразу все исключения, которые могут возникнуть в коде. Однако мы можем конкретизировать тип обрабатываемого исключения, указав его после слова except:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    number = int(input(\"Введите число: \"))\n",
    "    print(\"Введенное число:\", number)\n",
    "except ValueError:\n",
    "    print(\"Преобразование прошло неудачно\")\n",
    "print(\"Завершение программы\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В данном случае блок `execpt` обрабатывает только исключения типа `ValueError`, которые могут возникнут при неудачном преобразовании строки в число.\n",
    "\n",
    "В Python есть следующие базовые типы исключений:\n",
    "\n",
    "- `BaseException`: базовый тип для всех встроенных исключений\n",
    "- `Exception`: базовый тип, который обычно применяется для создания своих типов исключений\n",
    "- `ArithmeticError`: базовый тип для исключений, связанных с арифметическими операциями (`OverflowError`, `ZeroDivisionError`, `FloatingPointError`).\n",
    "- `BufferError`: тип исключения, которое возникает при невозможности выполнить операцию с буффером\n",
    "- `LookupError`: базовый тип для исключений, которое возникают при обращении в коллекциях по некорректному ключу или индексу (например, `IndexError`, `KeyError`)\n",
    "\n",
    "От этих классов наследуются все конкретные типы исключений. В Python обладает довольно большим списком встроенных исключений. Весь этот список можно посмотреть в документации. Перечислю только некоторые наиболее часто встречающиеся:\n",
    "\n",
    "- `IndexError`: исключение возникает, если индекс при обращении к элементу коллекции находится вне допустимого диапазона\n",
    "- `KeyError`: возникает, если в словаре отсутствует ключ, по которому происходит обращение к элементу словаря.\n",
    "- `OverflowError`: возникает, если результат арифметической операции не может быть представлен текущим числовым типом (обычно типом float).\n",
    "- `RecursionError`: возникает, если превышена допустимая глубина рекурсии.\n",
    "- `TypeError`: возникает, если операция или функция применяется к значению недопустимого типа.\n",
    "- `ValueError`: возникает, если операция или функция получают объект корректного типа с некорректным значением.\n",
    "- `ZeroDivisionError`: возникает при делении на ноль.\n",
    "- `NotImplementedError`: тип исключения для указания, что какие-то методы класса не реализованы\n",
    "- `ModuleNotFoundError`: возникает при при невозможности найти модуль при его импорте директивой import\n",
    "- `OSError`: тип исключений, которые генерируются при возникновении ошибок системы (например, невозможно найти файл, память диска заполнена и т.д.)\n",
    "\n",
    "И если ситуация такова, что в программе могут быть сгенерированы различные типы исключений, то мы можем их обработать по отдельности, используя дополнительные выражения `except`. И при возникновении исключения Python будет искать нужный блок `except`, который обрабатывает данный тип исключения:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    number1 = int(input(\"Введите первое число: \"))\n",
    "    number2 = int(input(\"Введите второе число: \"))\n",
    "    print(\"Результат деления:\", number1/number2)\n",
    "except ValueError:\n",
    "    print(\"Преобразование прошло неудачно\")\n",
    "except ZeroDivisionError:\n",
    "    print(\"Попытка деления числа на ноль\")\n",
    "except BaseException:\n",
    "    print(\"Общее исключение\")\n",
    "print(\"Завершение программы\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если возникнет исключение в результате преобразования строки в число, то оно будет обработано блоком except `ValueError`. Если же второе число будет равно нулю, то есть будет деление на ноль, тогда возникнет исключение `ZeroDivisionError`, и оно будет обработано блоком except `ZeroDivisionError`.\n",
    "\n",
    "Тип BaseException представляет общее исключение, под которое попадают все исключительные ситуации. Поэтому в данном случае любое исключение, которое не представляет тип `ValueError` или `ZeroDivisionError`, будет обработано в блоке except BaseException:.\n",
    "\n",
    "Однако, если в программе возникает исключение типа, для которого нет соответствующего блока except, то программа не сможет найти соответствующий блок except и сгенерирует исключение. Например, в следующем случае:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    number1 = int(input(\"Введите первое число: \"))\n",
    "    number2 = int(input(\"Введите второе число: \"))\n",
    "    print(\"Результат деления:\", number1/number2)\n",
    "except ZeroDivisionError:\n",
    "    print(\"Попытка деления числа на ноль\")\n",
    "print(\"Завершение программы\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Здесь предусмотрена обработка деления на ноль с помощью блока except `ZeroDivisionError`. Однако если пользователь вместо числа введет некорвертиуремую в число в строку, то возникнет исключение типа `ValueError`, для которого нет соответствующего блока except. И поэтому программа аварийно завершит свое выполнение.\n",
    "\n",
    "Python позволяет в одном блоке `except` обрабатывать сразу несколько типов исключений. В этом случае все типы исключения передаются в скобках:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    number1 = int(input(\"Введите первое число: \"))\n",
    "    number2 = int(input(\"Введите второе число: \"))\n",
    "    print(\"Результат деления:\", number1/number2)\n",
    "except (ZeroDivisionError, ValueError):    #  обработка двух типов исключений - ZeroDivisionError и ValueError\n",
    "    print(\"Попытка деления числа на ноль или некорректный ввод\")\n",
    " \n",
    "print(\"Завершение программы\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Получение информации об исключении\n",
    "\n",
    "С помощью оператора `as` мы можем передать всю информацию об исключении в переменную, которую затем можно использовать в блоке `except`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    number = int(input(\"Введите число: \"))\n",
    "    print(\"Введенное число:\", number)\n",
    "except ValueError as e:\n",
    "    print(\"Сведения об исключении\", e)\n",
    "print(\"Завершение программы\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Генерация исключений и оператор raise\n",
    "\n",
    "Иногда возникает необходимость вручную сгенерировать то или иное исключение. Для этого применяется оператор raise. Например, сгенерируем исключение"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    number1 = int(input(\"Введите первое число: \"))\n",
    "    number2 = int(input(\"Введите второе число: \"))\n",
    "    if number2 == 0:\n",
    "        raise Exception(\"Второе число не должно быть равно 0\")\n",
    "    print(\"Результат деления двух чисел:\", number1/number2)\n",
    "except ValueError:\n",
    "    print(\"Введены некорректные данные\")\n",
    "except Exception as e:\n",
    "    print(e)\n",
    "print(\"Завершение программы\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Оператору `raise` передается объект `BaseException` - в данном случае объект `Exception`. В конструктор этого типа можно ему передать сообщение, которое затем можно вывести пользователю. В итоге, если `number2` будет равно 0, то сработает оператор `raise`, который сгенерирует исключение. В итоге управление программой перейдет к блоку `except`, который обрабатывает исключения типа `Exception`:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Создание своих типов исключений\n",
    "\n",
    "В языке Python мы не ограничены только встроенными типами исключений и можем, применяя наследование, при необходимости создавать свои типы исключений. Например, возьмем следующий класс `Person`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person:\n",
    "    def __init__(self, name, age):\n",
    "        self.__name = name  # устанавливаем имя\n",
    "        self.__age = age   # устанавливаем возраст\n",
    "\n",
    "    def display_info(self):\n",
    "        print(f\"Имя: {self.__name}  Возраст: {self.__age}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Здесь класс `Person` в конструкторе получает значения для имени и возраста и присваивает их приватным переменным `name` и `age`. Однако при создании объекта `Person` мы можем передать в конструктор некорректное с точки зрения логики значение - например, отрицательное число. Одним из способов решения данной ситуации представляет генерация исключения при передаче некорректных значений.\n",
    "\n",
    "Итак, определим следующий код программы:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Имя: Tom  Возраст: 37\n",
      "Недопустимое значение: -23. Возраст должен быть в диапазоне от 1 до 110\n"
     ]
    }
   ],
   "source": [
    "class PersonAgeException(Exception):\n",
    "    def __init__(self, age, minage, maxage):\n",
    "        self.age = age\n",
    "        self.minage = minage\n",
    "        self.maxage = maxage\n",
    "\n",
    "    def __str__(self):\n",
    "        return f\"Недопустимое значение: {self.age}. \" \\\n",
    "               f\"Возраст должен быть в диапазоне от {self.minage} до {self.maxage}\"\n",
    "\n",
    "class Person:\n",
    "    def __init__(self, name, age):\n",
    "        self.__name = name  # устанавливаем имя\n",
    "        minage, maxage = 1, 110\n",
    "        if minage < age < maxage:   # устанавливаем возраст, если передано корректное значение\n",
    "            self.__age = age\n",
    "        else:                       # иначе генерируем исключение\n",
    "            raise PersonAgeException(age, minage, maxage)\n",
    "\n",
    "    def display_info(self):\n",
    "        print(f\"Имя: {self.__name}  Возраст: {self.__age}\")\n",
    "\n",
    "try:\n",
    "    tom = Person(\"Tom\", 37)\n",
    "    tom.display_info()  # Имя: Tom \tВозраст: 37\n",
    "\n",
    "    bob = Person(\"Bob\", -23)\n",
    "    bob.display_info()\n",
    "except PersonAgeException as e:\n",
    "    print(e)    # Недопустимое значение: -23. Возраст должен быть в диапазоне от 1 до 110"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В начале здесь определен класс `PersonAgeException`, который наследуется от класса `Exception`. Как правило, собственные классы исключений наследуются от класса `Exception`. Класс `PersonAgeException` предназначен для исключений, связанных с возрастом пользователя.\n",
    "\n",
    "В конструкторе `PersonAgeException` получаем три значения - собственное некорректное значение, которое послужило причиной исключения, а также минимальное и максимальное значения возраста."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class PersonAgeException(Exception):\n",
    "    def __init__(self, age, minage, maxage):\n",
    "        self.age = age\n",
    "        self.minage = minage\n",
    "        self.maxage = maxage\n",
    "\n",
    "    def __str__(self):\n",
    "        return f\"Недопустимое значение: {self.age}. \" \\\n",
    "               f\"Возраст должен быть в диапазоне от {self.minage} до {self.maxage}\"\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В функции `__str__` определяем текстовое представление класса - по сути сообщение об ошибке.\n",
    "\n",
    "В конструкторе класса Persoon проверяем переданное для возраста пользователя значение. И если это значение не соответствует определенному диапазону, то генерируем исключение типа `PersonAgeException`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "raise PersonAgeException(age, minage, maxage)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "При применении класса Person нам следует учитывать, что конструктор класса может сгенерировать исключение при передаче некорректного значения. Поэтому создание объектов Person обертывается в конструкцию try..except:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    tom = Person(\"Tom\", 37)\n",
    "    tom.display_info()  # Имя: Tom \tВозраст: 37\n",
    "\n",
    "    bob = Person(\"Bob\", -23)  # генерируется исключение типа PersonAgeException\n",
    "    bob.display_info()\n",
    "except PersonAgeException as e:\n",
    "    print(e)    # Недопустимое значение: -23. Возраст должен быть в диапазоне от 1 до 110"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "И если при вызове конструктора `Person` будет сгенерировано исключение типа `PersonAgeException`, то управление программой перейдет к блоку `except`, который обрабатывает исключения типа `PersonAgeException` в виде вывода информации об исключении на консоль."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.10.6 64-bit",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.6"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "b0fa6594d8f4cbf19f97940f81e996739fb7646882a419484c72d19e05852a7e"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}