07 Модули исключения менеджеры контекста.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# [Программирование на Python (SCS)](https://compscicenter.ru/courses/python/2015-autumn/classes/)\n",
    "\n",
    "## Лектор Сергей Лебедев:  sergei.a.lebedev@gmail.com\n",
    "\n",
    "\n",
    "|     **Дата**     |   **Название**  |     |\n",
    "|:----------------:|:---------------:|:-----------------:|\n",
    "| 19 октября 2015      |    Исключения и менеджеры контекста| \n",
    "\n",
    "# 7. Исключения и менеджеры контекста\n",
    "### Зачем нужны исключения?\n",
    "- для обработки исключительных (непредвиденных) ситуаций\n",
    "\n",
    "\n",
    "Исключения — это ошибки, которые можно обрабатывать.\n",
    "В этом их прелесть.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false
    }
   },
   "outputs": [],
   "source": [
    "[0] * int(1e16)  # Memory error\n",
    "import foobar    # ImportError: No module named 'foobar'\n",
    "[1, 2, 3] + 4    # TypeError: can only concatenate list to list\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Слайд 2. Обработка исключений: try...except\n",
    "\n",
    "Для обработки исключений в Python используются\n",
    "операторы `try` и `except`:\n",
    "```\n",
    "try:\n",
    "    something_dangerous()\n",
    "except (ValueError, ArithmeticError):\n",
    "    pass\n",
    "except TypeError as e:\n",
    "    pass\n",
    "```\n",
    "Ветка **except** принимает два аргумента:\n",
    "1. выражение, возвращающее тип или кортеж типов,\n",
    "2. опциональное имя для перехваченного исключения.\n",
    "- Исключение `e` обрабатывается веткой **except**, если её\n",
    "первый аргумент expr _можно сопоставить_ с исключением:\n",
    "**isinstance(e, expr)**\n",
    "- При наличии нескольких веток **except** интерпретатор\n",
    "сверху вниз ищет подходящую"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Слайд 3. подробнее о try...except\n",
    "\n",
    "На месте выражения в ветке except может стоять любое\n",
    "выражение, например, вызов функции или обращение к\n",
    "переменной:\n",
    "```\n",
    "try:\n",
    "    something_dangerous()\n",
    "except Exception as e:\n",
    "    try:\n",
    "        something_else()\n",
    "    except type(e):  # Какое исключение мы\n",
    "        pass         # перехватим?\n",
    "```\n",
    "• Время жизни переменной `e` ограничивается веткой `except`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    1 + \"42\"\n",
    "except TypeError as e:\n",
    "    pass  # Что делать, если нам нужно e? - создать переменную в глоб. вид-ти\n",
    "e"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Слайд 4. Встроенные исключения\n",
    "- <font color=red>**BaseException**</font> — базовый класс для встроенных\n",
    "исключений в Python.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "BaseException.__subclasses__()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Напрямую от класса <font color=red>**BaseException**</font> наследуются только\n",
    "системные исключения и исключения, приводящие к\n",
    "завершению работы интерпретатора.\n",
    "- Все остальные встроенные исключения, а также\n",
    "исключения, объявленные пользователем, должны\n",
    "наследоваться от класса <font color=red>**Exception**</font>.\n",
    "- Отсюда следует, что, чтобы обработать любое исключение,\n",
    "достаточно написать:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    something_dang()\n",
    "except Exception:  # Почему не BaseException?\n",
    "    pass\n",
    "# - Если программа завершиться аварийно или по Ctrl+C то она попадёт в этот\n",
    "# обработчик и не завершиться \"номарльным\" способом"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Слайд 5. Встроенные исключения: AssertionError\n",
    "\n",
    "Исключение **AssertionError** поднимается, когда условие\n",
    "оператора `assert` не выполняется:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert 2 + 2 == 5, (\"Math\", \"still\", \"works\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Оператор `assert` используется для ошибок, которые могут\n",
    "возникнуть только в результате ошибки программиста,\n",
    "поэтому перехватывать **AssertionError** считается дурным\n",
    "тоном"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Слайд 6. Встроенные исключения: ImportError и NameError\n",
    "Если оператор **import** не смог найти модуль с указанным\n",
    "именем, поднимается исключение **ImportError**:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import foobar  # ImportError: No module named 'foobar'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " **NameError** поднимается, если не была найдена локальная\n",
    "или глобальная переменная:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "foobar   # NameError: name 'foobar' is not defined"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Слайд 7. Встроенные исключения: AttributeError и LookupError\n",
    "Исключение **AttributeError** поднимается при попытке\n",
    "прочитать или (в случае `__slots__`) записать значение в\n",
    "несуществующий атрибут:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "object().foobar  # AttributeError: 'object' object has no attribute 'foobar'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Исключения **KeyError** и **IndexError** наследуются от\n",
    "базового класса **LookupError** и поднимаются, если в\n",
    "контейнере нет элемента по указанному ключу или\n",
    "индексу:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "{}[\"foobar\"]  # KeyError: 'foobar'\n",
    "[][0]         # IndexError: list index out of range"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Слайд 8. Встроенные исключения: ValueError и TypeError\n",
    "Исключение **ValueError** используется в случаях, когда\n",
    "другие более информативные исключения, например,\n",
    "**KeyError**, не применимы:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"foobar\".split(\"\")  # ValueError: empty separator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Исключение **TypeError** поднимается, когда оператор,\n",
    "функция или метод вызываются с аргументом\n",
    "несоответствующего типа:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b\"foo\" + \"bar\"  # TypeError: can't concat bytes to str"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Полный список исключений можно найти в документации\n",
    "языка https://docs.python.org/3/library/exceptions.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Слайд  9. Исключения, объявленные пользователем\n",
    "Для объявления нового типа исключения достаточно\n",
    "объявить класс, наследующийся от базового класса\n",
    "**Exception**.\n",
    "- Хорошая практика при написании библиотек на Python —\n",
    "объявлять свой базовый класс исключений, например:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CSCException(Exception):\n",
    "    pass\n",
    "class TestFailure(CSCException):\n",
    "    def __str__(self):\n",
    "        return \"lecture test failed\"\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Наличие базового класса позволяет пользователю\n",
    "обработать любое исключение, специфичное для\n",
    "библиотеки в одной ветке **except**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    do_something()\n",
    "except CSCException:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Слайд 10. Интерфейс исключений\n",
    "Интерфейс исключений в Python довольно нехитрый:\n",
    "- атрибут **args** хранит кортеж аргументов, переданных\n",
    "конструктору исключения,\n",
    "- атрибут `__traceback__` содержит информацию о стеке\n",
    "вызовов на момент возникновения исключения. Используется если нам надо передать информацию об исключении куда-то передать (на емэйл)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    1 + \"42\"\n",
    "except Exception as e:\n",
    "    caught = e\n",
    "caught.args"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "caught.__traceback__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import traceback\n",
    "traceback.print_tb(caught.__traceback__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Слайд 11. Оператор raise\n",
    "Поднять исключение можно с помощью оператора **raise**:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "raise TypeError(\"type mismatch\")  # TypeError: type mismatch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Аргумент оператора **raise** должен наследоваться от\n",
    "базового класса **BaseException**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "raise 42  # TypeError: exceptions must derive from BaseException"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если вызвать оператор **raise** без аргумента, то он\n",
    "поднимет последнее пойманное исключение или, если\n",
    "такого исключения нет, **RuntimeError**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "raise  # RuntimeError: No active exception to reraise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "ename": "ZeroDivisionError",
     "evalue": "division by zero",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-1-d053adcd2fbd>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# Поднимет последнее пойманное исключение\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m     \u001b[0;36m1\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0;32mraise\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mZeroDivisionError\u001b[0m: division by zero"
     ]
    }
   ],
   "source": [
    "# Поднимет последнее пойманное исключение\n",
    "try:\n",
    "    1/0\n",
    "except Exception:\n",
    "    raise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Слайд 12. Оператор raise from"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    {}[\"foobar\"]\n",
    "except KeyError as e:\n",
    "    raise RuntimeError(\"Ooops!\") from e"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Слайд 13. Обработка исключений: try...finally\n",
    "Иногда требуется выполнить какое-то действие вне\n",
    "зависимости от того, произошло исключение или нет,\n",
    "например, закрыть файл:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    handle = open(\"example.txt\", \"wt\")\n",
    "    try:\n",
    "        do_something(handle)\n",
    "    finally:\n",
    "        handle.close()\n",
    "except IOError as e:\n",
    "    print(e, file=sys.stderr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Аналогичным образом нужно работать с любыми другими\n",
    "ресурсами: сетевыми соединениями, примитивами\n",
    "синхронизации."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Слайд 14. Обработка исключений: try...else\n",
    "С помощью ветки **else** можно выполнить какое-то\n",
    "действие в ситуации, когда внутри **try** блока не возникло\n",
    "исключения:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    handle = open(\"example.txt\", \"wt\")\n",
    "else:\n",
    "    report_success(handle)\n",
    "except IOError as e:\n",
    "    print(e, file=sys.stderr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Чем использование **else** лучше следующего варианта?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    handle = open(\"example.txt\", \"wt\")\n",
    "    report_success(handle)\n",
    "except IOError as e:\n",
    "    print(e, file=sys.stderr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "тем что в else уже нет ловли исключения, т.е. разделяется логика работы участка с обработкой исключения и без."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Слайд 15. Цепочки исключений: except и оператор raise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    {}[\"foobar\"]\n",
    "except KeyError:\n",
    "    \"foobar\".split(\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Слайд 16. Цепочки исключений: finally и оператор raise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    {}[\"foobar\"]\n",
    "finally:\n",
    "    \"foobar\".split(\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Слайд 17. Исключения: резюме\n",
    "- Механизм обработки исключений в Python похож на\n",
    "аналогичные конструкции в С++ и Java, но Python\n",
    "расширяет привычную пару ``try...except`` веткой ``else``.\n",
    "- Поднять исключение можно с помощью оператора raise,\n",
    "его семантика эквивалентна `throw` в C++ и Java.\n",
    "- В Python много встроенных типов исключений, которые\n",
    "можно и нужно использовать при написании функций и\n",
    "методов.\n",
    "- Для объявления нового типа исключения достаточно\n",
    "унаследоваться от базового класса **Exception**.\n",
    "- Два важных правила при работе с исключениями:\n",
    "- минимизируйте размер ветки **try**,\n",
    "- всегда старайтесь использовать наиболее специфичный тип\n",
    "исключения в ветке **except**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Слайд 18. Зачем нужны менеджеры контекста?\n",
    "Менеджеры контекста позволяют компактно выразить уже\n",
    "знакомый нам паттерн управления ресурсами:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "r = acquire_resource()\n",
    "try:\n",
    "    do_something(r)\n",
    "finally:\n",
    "    release_resource(r)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "С помощью менеджера контекста пример выше можно\n",
    "записать так:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with acquire_resource() as r:\n",
    "    do_something(r)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Действие _release_resource_ будет выполнено\n",
    "автоматически, вызывать его явно не нужно."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Слайд 19. Протокол менеджеров контекста\n",
    "Протокол менеджеров контекста состоит из двух методов.\n",
    "- Метод `__enter__` инициализирует контекст, например,\n",
    "открывает файл или захватывает мьютекс. Значение,\n",
    "возвращаемое методом `__enter__`, записывается по\n",
    "имени, указанному после оператора **as**.\n",
    ">- Метод ``__exit__`` вызывается после выполнения тела\n",
    "оператора **with**. Метод принимает три аргумента:<br>\n",
    ">`1.` тип исключения,<br>\n",
    ">`2.` само исключение и<br>\n",
    ">`3.` объект типа traceback.<br>\n",
    "Если в процессе исполнения тела оператора **with** было\n",
    "поднятно исключение, метод `__exit__` может подавить его,\n",
    "вернув **True**.\n",
    "- Экземпляр **любого** класса, реализующего эти два метода,\n",
    "является менеджером контекста."
   ]
  },
  {
   "attachments": {
    "duck%20typing.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Слайд 20. Duck typing\n",
    "`-` если что-то выглядит как утка, значит это и есть утка. \n",
    "Т.е. если класс реализует два метода менеджера контекста `__enter__` и `__exit__` значит это и есть менеджер контекста. <br>\n",
    "http://theregister.co.uk/Print/2007/05/06/fables\n",
    "![duck%20typing.png](attachment:duck%20typing.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Слайд 21. “Семантика” оператора with\n",
    "Напоминание:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with acquire_resource() as r:\n",
    "    do_something(r)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Процесс исполнения оператора with можно\n",
    "концептуально записать так:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "manager = acquire_resource()\n",
    "r = manager.__enter__()\n",
    "\n",
    "try:\n",
    "    do_something(r)\n",
    "finally:\n",
    "    exc_type, exc_value, tb = sys.exc_info()\n",
    "    suppress = manager.__exit__(exc_type,\n",
    "                exc_value, tb)\n",
    "    if exc_value is not None and not suppress:\n",
    "        raise exc_value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Слайд 22. Расширенные возможности оператора with\n",
    "Оператор **with** позволяет работать с несколькими\n",
    "контекстными менеджерами одновременно:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with acquire_resource() as r, \\\n",
    "    acquire_other_resource() as other:\n",
    "    do_something(r, other)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Такая запись эквивалентна двум вложенным менеджерам\n",
    "контекста:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with acquire_resource() as r:\n",
    "    with acquire_other_resource() as other:\n",
    "        do_something(r, other)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Можно также использовать оператор with без указания\n",
    "имени переменной:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with acquire_resource():\n",
    "    do_something()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Слайд 23. Примеры менеджеров контекста: opened\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from functools import partial\n",
    "\n",
    "class opened:\n",
    "    \"\"\"Реализует менеджер контекста для файлов\n",
    "    \n",
    "    Принимает путь, по которому нужно открыть файл\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, path, *args, **kwargs):\n",
    "        self.opener = partial(open, path,\n",
    "                *args, **kwargs)\n",
    "\n",
    "#     Открываем файл и возвращаем объект\n",
    "    def __enter__(self):\n",
    "        self.handle = self.opener()\n",
    "        return self.handle\n",
    "\n",
    "# Удаляем ссылку на файл (дескриптор), т.к. зачем его хранить без файла\n",
    "    def __exit__(self, *exc_info):\n",
    "        self.handle.close() # Почему можно обойтись\n",
    "        del self.handle     # без return?\n",
    "\n",
    "        # - без ретурн мы возвращаем None, что значит мы НЕ подавляем никакие\n",
    "# исключения \n",
    "\n",
    "with opened(\"./example.txt\", mode=\"rt\") as handle:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color=blue>Капитан сообщает</font><br>\n",
    "`opened` интересен только в качестве примера, потому что файлы\n",
    "в Python уже поддерживают протокол менеджеров контекста"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Слайд 24. Примеры менеджеров контекста: модуль tempfile\n",
    "Модуль `tempfile` реализует классы для работы с\n",
    "временными файлами.\n",
    "- Все классы реализуют протокол менеджеров контекста,\n",
    "которые работают так же, как и для обычных файлов.\n",
    "- Интересный пример — класс `TemporaryFile`, который\n",
    "автоматически удаляет временный файл при выходе из\n",
    "менеджера контекста:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Andrey\\AppData\\Local\\Temp\\tmpadn6vagy\n"
     ]
    },
    {
     "ename": "FileNotFoundError",
     "evalue": "[Errno 2] No such file or directory: 'C:\\\\Users\\\\Andrey\\\\AppData\\\\Local\\\\Temp\\\\tmpadn6vagy'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-30-2f33dcab42fb>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      3\u001b[0m     \u001b[0mpath\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mhandle\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mpath\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m \u001b[0mopen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mpath\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'C:\\\\Users\\\\Andrey\\\\AppData\\\\Local\\\\Temp\\\\tmpadn6vagy'"
     ]
    }
   ],
   "source": [
    "import tempfile\n",
    "with tempfile.TemporaryFile() as handle:\n",
    "    path = handle.name\n",
    "    print(path)\n",
    "open(path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Слайд 25. Примеры менеджеров контекста: syncronized\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class synchronized:\n",
    "    \"\"\"Гарантирует эксклюзивный доступ к with\"\"\"\n",
    "    def __init__(self):\n",
    "        self.lock = threading.Lock()\n",
    "        \n",
    "    def __enter__(self):\n",
    "        self.lock.acquire()\n",
    "\n",
    "    def __exit__(self, *exc_info):\n",
    "        self.lock.release()\n",
    "\n",
    "with synchronized():\n",
    "    do_something()\n",
    "    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color=blue>Капитан сообщает</font><br>\n",
    "Большая часть примитивов синхронизации в Python, включая\n",
    "класс **Lock**, реализует протокол менеджера контекста.\n",
    "Использовать менеджер **synchronized** не нужно — он\n",
    "интересен только в качестве примера."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Слайд 26. Примеры контекстных менеджеров: cd\n",
    "Полезен для скриптов, работающих с файлами"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "e:\\py\\python_jupyter\n",
      "e:\\py\n",
      "e:\\py\\python_jupyter\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "from os.path import dirname\n",
    "\n",
    "class cd:\n",
    "    def __init__(self, path):\n",
    "        self.path = path\n",
    "\n",
    "    def __enter__(self):\n",
    "        self.saved_cwd = os.getcwd()\n",
    "        os.chdir(self.path)\n",
    "\n",
    "    def __exit__(self, *exc_info):\n",
    "        os.chdir(self.saved_cwd)\n",
    "\n",
    "print(os.getcwd())\n",
    "\n",
    "# with cd(\"/tmp\"):  # linux\n",
    "with cd(\"e:/py\"):   # win\n",
    "    print(os.getcwd())\n",
    "    \n",
    "print(os.getcwd())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Слайд 27. Менеджеры контекста: резюме\n",
    "- Менеджеры контекста — удобный способ управлять\n",
    "жизненным циклом ресурсов в Python.\n",
    "- Для работы с менеджером контекста используется\n",
    "оператор `with`.\n",
    "- Менеджером контекста является экземпляр любого класса,\n",
    "реализующего методы `__enter__` и `__exit__`.\n",
    "- Некоторые встроенные типы, например, файлы и\n",
    "примитивы синхронизации уже поддерживают протокол\n",
    "менеджеров контекста — этим можно и нужно\n",
    "пользоваться при написании кода."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Слайд 28. Модуль contextlib: closing\n",
    "**contextlib** - некий \"functools\" для менеджеров контекста"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Менеджер контекста `closing` обобщает логику уже\n",
    "известного нам `opened` на экземпляр любого класса,\n",
    "реализующего метод `close`.\n",
    "- Реализовать `closing` самому несложно, но приятно, когда в\n",
    "стандартной библиотеке языка есть и такие мелочи.\n",
    "- С помощью `closing` можно, например, безопасно работать\n",
    "с HTTP ресурсами:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from contextlib import closing\n",
    "from urllib.request import urlopen\n",
    "url = \"http://compscicenter.ru\"\n",
    "with closing(urlopen(url)) as page:\n",
    "    do_something(page)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Слайд 29. Модуль contextlib: redirect_stdout"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Менеджер контекста `redirect_stdout` позволяет локально\n",
    "перехватывать вывод в стандартный поток.\n",
    "- Пример использования:\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello, World!\\n'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from contextlib import redirect_stdout\n",
    "import io\n",
    "handle = io.StringIO()\n",
    "with redirect_stdout(handle):\n",
    "    print(\"Hello, World!\")\n",
    "handle.getvalue()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color=blue>Вопрос</font><br>\n",
    "Как можно было бы реализовать `redirect_stdout`?\n",
    "\n",
    "сохранить текущий handle, в enter переназначить sys.stdout = handle, a в exit вернуть sys.sydout на сохранённый ранее текущий handle"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Слайд 30. Модуль contextlib: suppress\n",
    "С помощью менеджера контекста suppress можно\n",
    "локального подавить исключения указанных типов:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from contextlib import supress\n",
    "with supress(FileNotFoundError):\n",
    "    os.remove(\"example.txt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Реализация менеджера не хитра:\n",
    "class supress:\n",
    "def __init__(self, *suppressed):\n",
    "    self.suppressed = suppressed\n",
    "\n",
    "def __enter__(self):\n",
    "    pass\n",
    "\n",
    "def __exit__(self, exc_type, exc_value, tb):\n",
    "    return (exc_type is not None and\n",
    "        issubclass(exc_type, suppressed))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "При использовании `suppress`, как и в целом при работе с\n",
    "исключениями, стоит указывать наиболее специфичный\n",
    "тип исключения."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Слайд 31. Модуль contextlib: ContextDecorator\n",
    "Базовый класс `ContextDecorator` позволяет объявлять\n",
    "менеджеры контекста, которые можно использовать как\n",
    "декораторы\n",
    "\n",
    "Зачем это нужно? Допустим есть функция, которая сразу использует менеджер контекста: занимает файл, что-то долго пишет, занимает ресурс... В этом случае нет смысла писать with..., а можно использовать декоратор"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f():\n",
    "    with context():\n",
    "        ...\n",
    "@context()\n",
    "def f():\n",
    "    ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Переход к синтаксису декораторов:\n",
    "- подчеркивает, что менеджер контекста применяется ко\n",
    "всему телу функции,\n",
    "- позволяет сэкономить 4 пробела :)<br>\n",
    "\n",
    "<font color=blue>Вопрос</font><br>\n",
    "Как должен быть реализован менеджер контекста, чтобы его\n",
    "можно было использовать в качестве декоратора?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Слайд 32. Модуль contextlib: менеджеры контекста и декораторы\n",
    "Для того, чтобы менеджер контекста можно было\n",
    "использовать как декоратор, достаточно унаследовать его\n",
    "от `ContextDecorator`.\n",
    "\n",
    "Модифицируем менеджер suppress из модуля contextlib,\n",
    "чтобы с помощью него можно было подавлять исключения\n",
    "во всей функции:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from contextlib import (suppress as _suppress,\n",
    "        ContextDecorator)\n",
    "\n",
    "class suppressed(_suppress, ContextDecorator):\n",
    "    pass\n",
    "\n",
    "@suppressed(IOError)\n",
    "def do_something():\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Слайд 33. Модуль contextlib: ExitStack"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Что делать, если количество ресурсов может быть\n",
    "произвольным? Например:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def merge_logs(output_path, *logs):\n",
    "    handles = open_files(logs)\n",
    "    with open(output_path, \"wt\") as output:\n",
    "        merge(output, handles)\n",
    "    close_files(logs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Правильный ответ: `ExitStack`. Менеджер `ExitStack`\n",
    "позволяет управлять произвольным количеством\n",
    "менеджеров контекста:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from contextlib import ExitStack\n",
    "def merge_logs(output_path, *logs):\n",
    "    with ExitStack() as stack:\n",
    "        handles = [stack.enter_context(open(log)) for log in logs]\n",
    "        output = open(output_path, \"wt\")\n",
    "        stack.enter_context(output)\n",
    "        merge(output, handles)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Слайд 34. “Семантика” менеджера ExitStack\n",
    "Менеджер `ExitStack` поддерживает стек вложенных\n",
    "менеджеров контекста:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with ExitStack() as stack:\n",
    "    stack.enter_context(some_resource)\n",
    "    stack.enter_context(other_resource)\n",
    "    do_something(some_resource, other_resource)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "При выходе из контекста, **ExitStack** обходит список\n",
    "вложенных менеджеров контекста в обратном порядке и\n",
    "вызывает у каждого менеджера метод `__exit__`.\n",
    "- Менеджер **ExitStack** корректно обрабатывает ситуации,\n",
    "- когда метод `__exit__` подавил исключение\n",
    "- или, когда в процессе работы метода `__exit__` возникло\n",
    "новое исключение"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.6"
  },
  "pycharm": {
   "stem_cell": {
    "cell_type": "raw",
    "metadata": {
     "collapsed": false
    },
    "source": []
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}