python_common/inner_functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Как в Python применяются вложенные функции \n",
    "\n",
    "Данный материал представляет собой незначительно сокращенный перевод статьи Леоданиса Посо Рамоса [Python Inner Functions: What Are They Good For?](https://realpython.com/inner-functions-what-are-they-good-for/#reader-comments).\n",
    "\n",
    "Вложенные (или внутренние, англ. inner, nested) функции – это функции, которые мы определяем внутри других функций. В Python такая функция имеет прямой доступ к переменным и именам, определенным во включающей её функции. Вложенные функции имеют множество применений, в первую очередь для создания замыканий и [декораторов](https://proglib.io/p/vse-chto-nuzhno-znat-o-dekoratorah-python-2020-05-09).\n",
    "\n",
    "В этом руководстве мы...\n",
    "- ... узнаем, как обеспечить инкапсуляцию и скрыть функции от внешнего доступа\n",
    "- ... напишем вспомогательные функции для облегчения повторного использования кода\n",
    "- ... реализуем замыкания для сохранения состояний между вызовами\n",
    "- ... создадим декораторы для добавления поведения к существующим функциям\n",
    "\n",
    "# Создание вложенных функций в Python\n",
    "Начнем с примера кода, содержащего вложенную функцию:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n"
     ]
    }
   ],
   "source": [
    "def outer_func():\n",
    "    def inner_func():\n",
    "        print(\"Hello, World!\")\n",
    "    inner_func()\n",
    "\n",
    "\n",
    "outer_func()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В этом коде мы определяем `inner_func()` внутри `outer_func()` для вывода на экран строки `Hello, World!`. Для этого мы вызываем `inner_func()` в последней строке `outer_func()`.\n",
    "\n",
    "Основная особенность внутренних функций — их способность обращаться к переменным и объектам из включающей («внешней») функции. Включающая функция предоставляет пространство имен, доступное вложенной в нее функции:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n"
     ]
    }
   ],
   "source": [
    "def outer_func(who):\n",
    "    def inner_func():\n",
    "        print(f\"Hello, {who}\")\n",
    "    inner_func()\n",
    "\n",
    "\n",
    "outer_func(\"World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Теперь мы можем передать строку в качестве аргумента функции `external_func()`, и `inner_func()` будет обращаться к этому аргументу через имя `who`. Это имя определяется в локальной области видимости `outer_func()`. Имена, которые мы определяем в локальной области внешней функции, определяются как `nonlocal`. Они нелокальны с точки зрения `inner_func()`.\n",
    "\n",
    "Ещё один пример более сложной вложенной функции:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def factorial(number):\n",
    "    # Валидация входного значения\n",
    "    if not isinstance(number, int):\n",
    "        raise TypeError(\"Число должно быть целым.\")\n",
    "    if number < 0:\n",
    "        raise ValueError(\"Число должно быть неотрицательным.\")\n",
    "    # Расчет факториала\n",
    "    def inner_factorial(number):\n",
    "        if number <= 1:\n",
    "            return 1\n",
    "        return number * inner_factorial(number - 1)\n",
    "    return inner_factorial(number)\n",
    "\n",
    "\n",
    "factorial(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В функции `factorial()` мы сначала проверяем входные данные, чтобы убедиться, что пользователь предоставляет неотрицательное целое число. Затем мы определяем рекурсивную внутреннюю функцию с именем `inner_factorial()`, выполняющую вычисление факториала. На последнем шаге вызывается `inner_factorial()` и выполняется соответствующий расчет.\n",
    "\n",
    "Основное преимущество использования такого шаблона заключается в том, что, выполнив все проверки аргументов во внешней функции, мы можем безопасно пропустить проверку ошибок во внутренней и сосредоточиться на текущих вычислениях.\n",
    "\n",
    "\n",
    "# Основы применения вложенных функций в Python\n",
    "## Инкапсуляция\n",
    "Распространенный вариант использования внутренних функций – когда нужно защитить или скрыть функцию от всего, что происходит за ее пределами, то есть полностью скрыть функцию из глобальной области видимости. Такое поведение обычно называют [инкапсуляцией](https://ru.wikipedia.org/wiki/%D0%98%D0%BD%D0%BA%D0%B0%D0%BF%D1%81%D1%83%D0%BB%D1%8F%D1%86%D0%B8%D1%8F_(%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5)).\n",
    "\n",
    "Начнем с поясняющего примера: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'inner_increment' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-9-084483e29fe9>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0;31m# Вызовем вложенную функцию inner_increment()\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 10\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minner_increment\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'inner_increment' is not defined"
     ]
    }
   ],
   "source": [
    "def increment(number):\n",
    "    def inner_increment():\n",
    "        return number + 1\n",
    "    return inner_increment()\n",
    "\n",
    "\n",
    "print(increment(10))\n",
    "\n",
    "# Вызовем вложенную функцию inner_increment()\n",
    "print(inner_increment())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В этом примере у нас нет прямого доступа к `inner_increment()`. Попытавшись обратиться к вложенной функции, мы получаем `NameError`. Функция `increment()` полностью скрывает вложенную функцию `inner_increment()`, предотвращая доступ из глобальной области.\n",
    "\n",
    "# Создание внутренних вспомогательных функций\n",
    "Иногда нам нужна функция, выполняющая один и тот же фрагмент кода в нескольких местах своего тела. Например, мы хотим написать функцию для обработки файла CSV, содержащего информацию о точках доступа Wi-Fi в Нью-Йорке. Чтобы узнать общее количество точек доступа, а также информацию о компании, которая их предоставляет, мы создали следующий скрипт:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# hotspots.py\n",
    "\n",
    "import csv\n",
    "from collections import Counter\n",
    "\n",
    "def process_hotspots(file):\n",
    "    def most_common_provider(file_obj):\n",
    "        hotspots = []\n",
    "        with file_obj as csv_file:\n",
    "            content = csv.DictReader(csv_file)\n",
    "\n",
    "            for row in content:\n",
    "                hotspots.append(row[\"Provider\"])\n",
    "\n",
    "        counter = Counter(hotspots)\n",
    "        print(\n",
    "            f\"В Нью-Йорке {len(hotspots)} точек Wi-Fi.\\n\"\n",
    "            f\"{counter.most_common(1)[0][1]} из них предоставляет\"\n",
    "            f\"{counter.most_common(1)[0][0]}.\"\n",
    "        )\n",
    "\n",
    "    if isinstance(file, str):\n",
    "        # Получаем путь к файлу\n",
    "        file_obj = open(file, \"r\")\n",
    "        most_common_provider(file_obj)\n",
    "    else:\n",
    "        # Забираем объект файла\n",
    "        most_common_provider(file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Здесь `process_hotspots()` принимает аргумент `file` и проверяет, является ли файл строковым путем к физическому файлу или файловым объектом. Затем функция вызывает вспомогательную внутреннюю функцию `most_common_provider()`, которая принимает файловый объект и выполняет следующие операции:\n",
    "1. Считывает содержимое файла в генератор, который создает словари с помощью `csv.DictReader`.\n",
    "2. Составляет список провайдеров Wi-Fi.\n",
    "3. Подсчитывает количество точек доступа Wi-Fi для каждого поставщика с помощью объекта `collections.Counter`.\n",
    "4. Печатает сообщение с полученной информацией.\n",
    "\n",
    "Запустив функцию, мы получим следующий результат:\n",
    "\n",
    "```python\n",
    "\n",
    ">>> from hotspots import process_hotspots\n",
    "\n",
    ">>> file_obj = open(\"./NYC_Wi-Fi_Hotspot_Locations.csv\", \"r\")\n",
    ">>> process_hotspots(file_obj)\n",
    "В Нью-Йорке 3319 точек Wi-Fi.\n",
    "1868 из них предоставляет LinkNYC - Citybridge.\n",
    "\n",
    ">>> process_hotspots(\"./NYC_Wi-Fi_Hotspot_Locations.csv\")\n",
    "В Нью-Йорке 3319 точек Wi-Fi.\n",
    "1868 из них предоставляет LinkNYC - Citybridge.\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Независимо от того, вызываем ли мы `process_hotspots()` со строковым путем к файлу или с файловым объектом, вы получите один и тот же результат.\n",
    "\n",
    "## Использование внутренних и приватных вспомогательных функций\n",
    "Обычно мы создаем вспомогательные внутренние функции, такие как `most_common_provider()`, когда хотим обеспечить инкапсуляцию либо если не собираемся вызывать их где-либо еще, кроме включающей функции.\n",
    "\n",
    "Хотя написание внутренних вспомогательных функций дает желаемый результат, обычно лучше вынести их, как функции верхнего уровня. В этом случае можно использовать префикс из знака подчеркивания `(_)` в имени функции, чтобы указать, что она является приватной для текущего модуля или класса. Это позволит получить доступ к вспомогательным функциям из любого места в текущем модуле или классе и повторно использовать их по мере необходимости.\n",
    "\n",
    "Извлечение внутренних функций в приватные функции верхнего уровня может сделать код чище и  читаемее. Такая практика соответствует [принципу единственной ответственности](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B8%D0%BD%D1%86%D0%B8%D0%BF_%D0%B5%D0%B4%D0%B8%D0%BD%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D0%BE%D0%B9_%D0%BE%D1%82%D0%B2%D0%B5%D1%82%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D0%BE%D1%81%D1%82%D0%B8).\n",
    "\n",
    "\n",
    "# Сохранение состояния с помощью вложенных функций: замыкания в Python\n",
    "\n",
    "Функции Python в своих правах равны любым другим объектам, таким как числа, строки, списки, кортежи, модули и т. д. То есть их можно динамически создавать или уничтожать, сохранять в структурах данных, передавать в качестве аргументов другим функциям, использовать как возвращаемые значения.\n",
    "\n",
    "В Python также можно создавать [функции высшего порядка](https://ru.wikipedia.org/wiki/%D0%A4%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D1%8F_%D0%B2%D1%8B%D1%81%D1%88%D0%B5%D0%B3%D0%BE_%D0%BF%D0%BE%D1%80%D1%8F%D0%B4%D0%BA%D0%B0), которые принимают и возвращают другие функции.\n",
    "\n",
    "Примеры внутренних функций, которые мы видели до сих пор, были обычными функциями, которые волей случая оказались вложенными внутрь других функций. Если нам не нужно скрывать эти функции от внешнего мира, то и нет особых причин для вложения.\n",
    "\n",
    "В этом разделе мы поговорим о другом роде вложенных функций – замыканиях. Это динамически создаваемые функции, возвращаемые другими функциями. Главная особенность состоит в том, что замыкания имеют полный доступ к переменным и именам, определенным в локальном пространстве имен, в котором было создано замыкание, даже если включающая функция завершила свое выполнение.\n",
    "\n",
    "Чтобы определить замыкание, нужно выполнить три шага:\n",
    "1. Создать вложенную функцию.\n",
    "2. Сослаться на переменные из включающей функции.\n",
    "3. Вернуть вложенную функцию.\n",
    "\n",
    "Сейчас разберемся на примерах.\n",
    "\n",
    "\n",
    "## Сохранение состояния в замыкании\n",
    "\n",
    "Итак, замыкание заставляет вложенную функцию при вызове сохранять состояние своего окружения. То есть замыкание – это не только сама внутренняя функция, но и окружающая среда.\n",
    "\n",
    "Рассмотрим следующий пример:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# powers.py\n",
    "\n",
    "def generate_power(exponent):\n",
    "    def power(base):\n",
    "        return base ** exponent\n",
    "    return power"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Здесь мы определяем функцию `generate_power()`, которая представляет собой [фабрику](https://ru.wikipedia.org/wiki/%D0%90%D0%B1%D1%81%D1%82%D1%80%D0%B0%D0%BA%D1%82%D0%BD%D0%B0%D1%8F_%D1%84%D0%B0%D0%B1%D1%80%D0%B8%D0%BA%D0%B0_(%D1%88%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD_%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F)) для создания замыканий. То есть эта функция при каждом вызове создает и возвращает новую функцию-замыкание.\n",
    "В следующей строке определяется функция `power()`, которая является внутренней функцией, и принимает единственный аргумент `base` и возвращает результат выражения `base ** exponent`.\n",
    "Последняя строка возвращает `power` как функциональный объект, не вызывая его.\n",
    "\n",
    "Откуда `power()` получает значение показателя степени `esponent`? Вот где в игру вступает замыкание. В этом примере `power()` получает значение экспоненты из внешней функции `generate_power()`. Вот что делает Python, когда мы вызываем `generate_power()`:\n",
    "\n",
    "1. Определяет новый экземпляр `power()`, который принимает аргумент `base`.\n",
    "2. Делает «снимок» окружения `power()`. Он включает `exponent` с текущим значением.\n",
    "3. Возвращает `power()` вместе с состоянием.\n",
    "\n",
    "Таким образом, когда мы вызываем экземпляр `power()`, возвращаемый функцией `generate_power()`, мы видим, что функция запоминает значение степени `exponent`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "raise_two = generate_power(2)\n",
    "raise_three = generate_power(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "raise_two(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "raise_two(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "64"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "raise_three(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "125"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "raise_three(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Обратите внимание, что оба замыкания запоминают соответствующий показатель степени между вызовами. В этих примерах `raise_two()` запоминает, что `exponent = 2`, а `rise_three()` запоминает, что `exponent = 3`.\n",
    "\n",
    "Рассмотрим другой пример:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def has_permission(page):\n",
    "    def permission(username):\n",
    "        if username.lower() == \"admin\":\n",
    "            return f\"'{username}' имеет доступ к {page}.\"\n",
    "        else:\n",
    "            return f\"'{username}' не имеет доступа к {page}.\"\n",
    "    return permission"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "check_admin_page_permision = has_permission(\"Admin Page\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'admin' имеет доступ к Admin Page.\n"
     ]
    }
   ],
   "source": [
    "print(check_admin_page_permision(\"admin\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'john' не имеет доступа к Admin Page.\n"
     ]
    }
   ],
   "source": [
    "print(check_admin_page_permision(\"john\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Вложенная функция проверяет, имеет ли данный пользователь необходимы права доступа к странице. Вместо того чтобы проверять, равен ли пользователь `'admin'`, можно сделать [запрос к базе данных](https://proglib.io/p/kak-podruzhit-python-i-bazy-dannyh-sql-podrobnoe-rukovodstvo-2020-02-27).\n",
    "\n",
    "Обычно замыкания не изменяют состояние, которое они получили «при рождении», как было показано в приведенных выше примерах. Но можно создавать и динамические замыкания, используя изменяемые объекты – словари, множества или списки.\n",
    "\n",
    "Предположим, нужно вычислить среднее значение для набора данных. Данные поступают в виде потока последовательных измерений анализируемого параметра, и нужно, чтобы функция сохраняла между вызовами предшествующие измерения. В этом случае можно код фабрики для создания замыканий может выглядеть следующим образом:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mean():\n",
    "    sample = []\n",
    "    def inner_mean(number):\n",
    "        sample.append(number)\n",
    "        return sum(sample) / len(sample)\n",
    "    return inner_mean\n",
    "\n",
    "sample_mean = mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100.0"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sample_mean(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "102.5"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sample_mean(105)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "102.0"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sample_mean(101)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "101.0"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sample_mean(98)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Замыкание, присвоенное `sample_mean`, сохраняет состояние выборки между вызовами. Хотя мы определяем  список `sample` внутри `mean()`, он также доступен и в замыкании, благодаря чему мы можем его изменять.\n",
    "\n",
    "\n",
    "## Изменение состояния замыкания\n",
    "\n",
    "Обычно переменные замыкания полностью скрыты от внешнего мира. Однако мы можем задать для них функции геттера и сеттера:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_point(x, y):\n",
    "    def point():\n",
    "        print(f\"Point({x}, {y})\")\n",
    "    def get_x():\n",
    "        return x\n",
    "    def get_y():\n",
    "        return y\n",
    "    def set_x(value):\n",
    "        nonlocal x\n",
    "        x = value\n",
    "    def set_y(value):\n",
    "        nonlocal y\n",
    "        y = value\n",
    "    # Добавляем геттеры и сеттеры\n",
    "    point.get_x = get_x\n",
    "    point.set_x = set_x\n",
    "    point.get_y = get_y\n",
    "    point.set_y = set_y\n",
    "    return point\n",
    "\n",
    "point = make_point(1, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "point.get_x()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "point.get_y()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Point(1, 2)\n"
     ]
    }
   ],
   "source": [
    "point()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Point(42, 7)\n"
     ]
    }
   ],
   "source": [
    "point.set_x(42)\n",
    "point.set_y(7)\n",
    "point()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Здесь `make_point()` возвращает замыкание, представляющее объект `point`. К этому объекту прикреплены функции, которые мы можем использовать для получения доступа к чтению и записи переменных `x` и `y`.\n",
    "\n",
    "Такая фабрика может работать даже быстрее, чем эквивалентный класс, но подход не предоставляет наследование, дескрипторы и прочие возможности [классов Python](https://proglib.io/p/vvedenie-v-obektno-orientirovannoe-programmirovanie-oop-na-python-2020-07-23).\n",
    "\n",
    "\n",
    "# Изменение поведения с помощью вложенных функций: декораторы\n",
    "\n",
    "[Декораторы Python](https://proglib.io/p/vse-chto-nuzhno-znat-o-dekoratorah-python-2020-05-09) – еще один популярный и удобный вариант использования внутренних функций, особенно для замыканий. Декораторы – это функции высшего порядка, которые принимают в качестве аргумента вызываемый объект (функцию, метод, класс) и возвращают другой вызываемый объект.\n",
    "\n",
    "Обычно декораторы применяются для динамического добавления свойств к существующему вызываемому объекту и прозрачного расширения его поведения, не затрагивая и не изменяя вызываемого объекта. Функцию-декоратор можно применить к любому вызываемому объекту. Для этого в предваряющей его строке ставится символ `@ ` и имя декоратора:\n",
    "\n",
    "```python\n",
    "@decorator\n",
    "def decorated_func():\n",
    "    # Function body...\n",
    "    pass\n",
    "```\n",
    "\n",
    "Этот синтаксис заставляет `decorator()` автоматически принимать `decorator_func()` в качестве аргумента и обрабатывать его в своем теле. Эта операция является сокращением для инструкции следующего вида:\n",
    "\n",
    "```python\n",
    "decorated_func = decorator(decorated_func)\n",
    "```\n",
    "\n",
    "Вот пример того, как можно создать функцию-декоратор для изменения поведения уже существующей функции:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Это мой первый декоратор.\n",
      "Привет, мир!\n",
      "Пока!\n"
     ]
    }
   ],
   "source": [
    "def add_messages(func):\n",
    "    def _add_messages():\n",
    "        print(\"Это мой первый декоратор.\")\n",
    "        func()\n",
    "        print(\"Пока!\")\n",
    "    return _add_messages\n",
    "\n",
    "@add_messages\n",
    "def greet():\n",
    "    print(\"Привет, мир!\")\n",
    "    \n",
    "greet()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В этом примере мы используем `@add_messages` для декорирования функции `greet()`. В результате функция приобретает новые функциональные возможности. Теперь, когда мы вызываем `greet()`, вместо того, чтобы просто напечатать `Привет, мир!`, она выводит два дополнительных сообщения.\n",
    "\n",
    "Простейшей практикой отладки кода на Python является вставка вызовов `print()` для проверки значений переменных. Однако добавляя и удаляя вызовы `print()` мы рискуем забыть о некоторых из них. Чтобы предотвратить эту ситуацию, мы можем написать следующий декоратор:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "add(args: (5, 6), kwargs: {}) -> 11\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def debug(func):\n",
    "    def _debug(*args, **kwargs):\n",
    "        result = func(*args, **kwargs)\n",
    "        print(\n",
    "            f\"{func.__name__}(args: {args}, kwargs: {kwargs}) -> {result}\"\n",
    "        )\n",
    "        return result\n",
    "    return _debug\n",
    "\n",
    "\n",
    "@debug\n",
    "def add(a, b):\n",
    "    return a + b\n",
    "\n",
    "\n",
    "add(5, 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В этом примере функция-декоратор `debug ()` печатает имя декорируемой функции, текущие значения каждого аргумента и возвращаемый результат. Такой декоратор можно использовать для простейшей отладки функций. Как только мы получаем желаемый результат, достаточно удалить вызов декоратора `@debug`, и отлаженная функция будет работать как обычно.\n",
    "\n",
    "Приведем последний пример и заново реализуем `generate_power()` в виде функции-декоратора:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_power(exponent):\n",
    "    def power(func):\n",
    "        def inner_power(*args):\n",
    "            base = func(*args)\n",
    "            return base ** exponent\n",
    "        return inner_power\n",
    "    return power\n",
    "\n",
    "\n",
    "@generate_power(2)\n",
    "def raise_two(n):\n",
    "    return n\n",
    "\n",
    "\n",
    "@generate_power(3)\n",
    "def raise_three(n):\n",
    "    return n\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "49"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "raise_two(7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "125"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "raise_three(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Эта версия `generate_power()` дает те же результаты, что и в исходной реализации. В этом случае мы используем для запоминания показателя степени и замыкание, и декоратор, который возвращает измененную версию функции `func()`.\n",
    "\n",
    "Здесь декоратор должен принимать аргумент (показатель степени), поэтому нам потребовалось два уровня вложенность. Первый уровень представлен функцией `power()`, которая принимает в качестве аргумента декорируемую функцию. Второй уровень представлен функцией `inner_power()`, которая упаковывает показатель степени в `args`, выполняет окончательный расчет и возвращает результат.\n",
    "\n",
    "\n",
    "## Заключение\n",
    "\n",
    "Итак, в Python вложенные функции имеют прямой доступ к переменным и именам, которые вы определяете во включающей функции. Это предоставляет механизм для инкапсуляции функций, создания вспомогательных решений, реализации замыканий и декораторов. Если у вас остались какие-либо вопросы или комментарии, обязательно поделитесь ими в комментариях или написав мне в [телеграм-чат](https://t.me/matyushkin_chat)."
   ]
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}