Дескрипторы_метаклассы_07_10.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Дескрипторы_метаклассы_07_10.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyNVRFXwFkmcboq5RzYFV2hC",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/pythonkvs/seminars/blob/main/%D0%94%D0%B5%D1%81%D0%BA%D1%80%D0%B8%D0%BF%D1%82%D0%BE%D1%80%D1%8B_%D0%BC%D0%B5%D1%82%D0%B0%D0%BA%D0%BB%D0%B0%D1%81%D1%81%D1%8B_07_10.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K1qNCh-2zwIg"
      },
      "source": [
        "https://compscicenter.ru/courses/python/2015-autumn/classes/1559/"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pU376qguXD0U"
      },
      "source": [
        "# Дескрипторы"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yh4OLemaXniZ"
      },
      "source": [
        "## Напоминание: свойства"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-eb05PtbXJmR"
      },
      "source": [
        "* Механизм свойств в Python позволяет контролировать\n",
        "доступ, изменение и удаление атрибута.\n",
        "* Очень безопасный класс запрещает неотрицательные\n",
        "значения для атрибута x:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "I1bzl8kMXVDR"
      },
      "source": [
        "class VerySafe:\n",
        "    def _get_attr(self):\n",
        "        return self._x\n",
        "    def _set_attr(self, x):\n",
        "        assert x > 0, \"non-negative value required\"\n",
        "        self._x = x\n",
        "    def _del_attr(self):\n",
        "        del self._x\n",
        "\n",
        "    x = property(_get_attr, _set_attr, _del_attr)"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6_HMSA7SXqup"
      },
      "source": [
        "## Переиспользование свойств"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KGEx462KXtKM"
      },
      "source": [
        "Проверим, что всё работает:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "k3Gr3_uXXvtB",
        "outputId": "c1d208c7-9133-4210-be0e-0706afa4e496"
      },
      "source": [
        "very_safe = VerySafe()\n",
        "very_safe.x = 42\n",
        "very_safe.x"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "42"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 279
        },
        "id": "XbrXMeXIX0d6",
        "outputId": "ef162d27-9d00-41f1-fca2-fbd8c43f4df3"
      },
      "source": [
        "very_safe.x = -42"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "error",
          "ename": "AssertionError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-3-517757c43987>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mvery_safe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m-\u001b[0m\u001b[0;36m42\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m<ipython-input-1-bc702c025d4a>\u001b[0m in \u001b[0;36m_set_attr\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m      3\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_x\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m_set_attr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\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[0;32m----> 5\u001b[0;31m         \u001b[0;32massert\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"non-negative value required\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      6\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_x\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m_del_attr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\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[0;31mAssertionError\u001b[0m: non-negative value required"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OHJb3m9DX4Ta",
        "outputId": "c2233d23-bb15-40b4-ad70-575abaad55f5"
      },
      "source": [
        "very_safe.y = -42\n",
        "very_safe.y"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "-42"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tk9A5DSCZY7q"
      },
      "source": [
        "## Дескрипторы"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PTMjfPqUZc5D"
      },
      "source": [
        "* Дескриптор — это:\n",
        "    * экземпляр класса, реализующего протокол дескрипторов,\n",
        "    * свойство, которое можно переиспользовать.\n",
        "* Пример: дескриптор `NonNegative`, который делает то же\n",
        "самое, что написанное нами ранее свойство."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "A62l2JQ5Zust"
      },
      "source": [
        "class NonNegative:\n",
        "    def __get__(self, instance, owner):\n",
        "        return magically_get_value(...)\n",
        "    def __set__(self, instance, value):\n",
        "        assert value >= 0, \"non-negative value required\"\n",
        "        magically_set_value(...)\n",
        "    def __delete__(self, instance):\n",
        "        magically_delete_value(...)\n",
        "        "
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aqGqEQ5oaESI"
      },
      "source": [
        "## Дескрипторы и очень безопасный класс"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "74U6UAD9aHnO"
      },
      "source": [
        "class VerySafe:\n",
        "    x = NonNegative()\n",
        "    y = NonNegative()\n",
        "\n",
        "very_safe = VerySafe()\n",
        "very_safe.x = 42\n",
        "very_safe.x"
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 279
        },
        "id": "WpaHMdIpaSlG",
        "outputId": "b2f809ea-e61e-4047-858a-672714b0ef4e"
      },
      "source": [
        "very_safe.x = -42"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "error",
          "ename": "AssertionError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-7-517757c43987>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mvery_safe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m-\u001b[0m\u001b[0;36m42\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m<ipython-input-5-f63b74da6eea>\u001b[0m in \u001b[0;36m__set__\u001b[0;34m(self, instance, value)\u001b[0m\n\u001b[1;32m      3\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0;31m#magically_get_value(...)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__set__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minstance\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\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[0;32m----> 5\u001b[0;31m         \u001b[0;32massert\u001b[0m \u001b[0mvalue\u001b[0m \u001b[0;34m>=\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"non-negative value required\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      6\u001b[0m         \u001b[0;31m#magically_set_value(...)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__delete__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minstance\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[0;31mAssertionError\u001b[0m: non-negative value required"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 279
        },
        "id": "OAWUFyC9aUoP",
        "outputId": "e379ad4b-d9df-4402-9599-18ed508aed33"
      },
      "source": [
        "very_safe.y = -42"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "error",
          "ename": "AssertionError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-8-75e579c4ebc5>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mvery_safe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m-\u001b[0m\u001b[0;36m42\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m<ipython-input-5-f63b74da6eea>\u001b[0m in \u001b[0;36m__set__\u001b[0;34m(self, instance, value)\u001b[0m\n\u001b[1;32m      3\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0;31m#magically_get_value(...)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__set__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minstance\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\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[0;32m----> 5\u001b[0;31m         \u001b[0;32massert\u001b[0m \u001b[0mvalue\u001b[0m \u001b[0;34m>=\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"non-negative value required\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      6\u001b[0m         \u001b[0;31m#magically_set_value(...)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__delete__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minstance\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[0;31mAssertionError\u001b[0m: non-negative value required"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hTQJvXnZbBzb"
      },
      "source": [
        "## Протокол дескрипторов: `__get__`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y-vjMaX1bJ5B"
      },
      "source": [
        "* Метод `__get__` вызывается при доступе к атрибуту.\n",
        "* Метод принимает два аргумента:\n",
        "    * `instance` — экземпляр класса или `None`, если дескриптор\n",
        "был вызван в результате обращения к атрибуту у класса\n",
        "    * `owner` — класс, “владеющий” дескриптором.\n",
        "* Пример:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6hFnPUKfbe54",
        "outputId": "01ff72aa-368b-4f4f-9bd2-674838b91b45"
      },
      "source": [
        "class Descr:\n",
        "    def __get__(self, instance, owner):\n",
        "        print(instance, owner)\n",
        "\n",
        "class A:\n",
        "    attr = Descr()\n",
        "\n",
        "A.attr"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "None <class '__main__.A'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KPWEfS_LbmDj",
        "outputId": "7389f8ef-1087-4a9f-f259-318ac9fcc02a"
      },
      "source": [
        "A().attr"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<__main__.A object at 0x7f1b6528aa90> <class '__main__.A'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VpxPkjQBb1eC"
      },
      "source": [
        "## Протокол дескрипторов: `__get__` и `owner`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3V1cwTBQcN9j"
      },
      "source": [
        "class A:\n",
        "    attr = Descr()\n",
        "\n",
        "\n",
        "class B(A):\n",
        "    pass"
      ],
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "exy2svumcVO0",
        "outputId": "c4e7967d-fb75-4bb4-caa8-a7179f3f1cb1"
      },
      "source": [
        "A.attr"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "None <class '__main__.A'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "s7k-tFB7cPE7",
        "outputId": "522866ed-2f01-4970-a364-e0800c5823b1"
      },
      "source": [
        "A().attr"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<__main__.A object at 0x7f1b65299210> <class '__main__.A'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FrR634a3cO_S",
        "outputId": "a04ec941-576f-42e3-87bb-4869aacfa1b6"
      },
      "source": [
        "B.attr"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "None <class '__main__.B'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "szoY6tdjcO8T",
        "outputId": "5fe386bd-1586-40b1-a345-62dbe05642d6"
      },
      "source": [
        "B().attr"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<__main__.B object at 0x7f1b652a3450> <class '__main__.B'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5r81LhwlclIN"
      },
      "source": [
        "## Протокол дескрипторов: `__set__`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W47t-cf9cqEs"
      },
      "source": [
        "* Метод `__set__` вызывается для изменения значения\n",
        "атрибута.\n",
        "* Метод принимает два аргумента:\n",
        "    * `instance`, экземпляр класса, “владеющего” дескриптором,\n",
        "    * `value` — новое значение атрибута.\n",
        "* Пример:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "U247N6QJc2Fr",
        "outputId": "02d90d83-e6ea-413d-c80e-36f0097959fa"
      },
      "source": [
        "class Descr:\n",
        "    def __set__(self, instance, value):\n",
        "        print(instance, value)\n",
        "\n",
        "class A:\n",
        "    attr = Descr()\n",
        "\n",
        "instance = A()\n",
        "instance.attr = 42"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<__main__.A object at 0x7f1b6bcc4e50> 42\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nUWYelGWdIUG"
      },
      "source": [
        "A.attr = 42"
      ],
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XQv49llLdTxg"
      },
      "source": [
        "## Протокол дескрипторов: `__delete__`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "A5Mmkqogdbdc"
      },
      "source": [
        "* Метод `__delete__` вызывается при удалении атрибута.\n",
        "* Метод принимает один аргумент — экземпляр класса,\n",
        "“владеющего” дескриптором.\n",
        "* Пример:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "su0I5TCLdfpc",
        "outputId": "d80abf12-e52a-4711-a485-edbf006082d7"
      },
      "source": [
        "class Descr:\n",
        "    def __delete__(self, instance):\n",
        "        print(instance)\n",
        "\n",
        "class A:\n",
        "    attr = Descr()\n",
        "\n",
        "del A().attr"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<__main__.A object at 0x7f1b68d4ebd0>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 162
        },
        "id": "Qt_otHo9d3gl",
        "outputId": "a673abe1-8603-4452-961c-53c7df48165d"
      },
      "source": [
        "del A.x"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "error",
          "ename": "AttributeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-19-7a0ba601145a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mdel\u001b[0m \u001b[0mA\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m: x"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sTU5bDnseOzM"
      },
      "source": [
        "## “Семантика” протокола дескрипторов"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eSDITe9peZPO"
      },
      "source": [
        "* Пусть\n",
        "    * `instance` — экземпляр класса `cls`,\n",
        "    * атрибут `attr` которого — дескриптор, и\n",
        "    * `descr = cls.__dict__[\"attr\"]` — непосредственно сам\n",
        "дескриптор.\n",
        "* Тогда\n",
        "```python\n",
        "cls.attr                  descr.__get__(None, cls)\n",
        "instance.attr            ≈descr.__get__(instance, cls)\n",
        "instance.attr = value     descr.__set__(instance, value)\n",
        "del instance.attr         descr.__delete__(instance)\n",
        "```\n",
        "\n",
        "\n",
        "* Всё то же самое справедливо для ситуации, когда\n",
        "дескриптор объявлен где-то в иерархии наследования."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nKNSOI6KhBOM"
      },
      "source": [
        "## Типы дескрипторов"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a1FwRcJUhFXS"
      },
      "source": [
        "* Дескриптор может определять любое сочетание методов\n",
        "`__get__`, `__set__` и `__delete__`.\n",
        "* Все дескрипторы можно поделить на две группы:\n",
        "    * дескрипторы данных *aka* data descriptors, определяющие\n",
        "как минимум метод `__set__`, и\n",
        "    * остальные *aka* non-data descriptors.\n",
        "* Полезные дескрипторы определяют ещё и метод `__get__`.\n",
        "* Отличие между группами в том, как они взаимодействуют с\n",
        "`__dict__` экземпляра."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5w-xjb5JhesN"
      },
      "source": [
        "## Дескрипторы и `__dict__`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DZb9CjnRhjCK"
      },
      "source": [
        "* Пример:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "V3ItayJOhlMk",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e40dee88-88a2-49d6-a526-62dd743636bf"
      },
      "source": [
        "class A:\n",
        "    attr = Descr()\n",
        "\n",
        "A().attr"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<__main__.Descr at 0x7f1b652abd90>"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rzrxkWRphnMA"
      },
      "source": [
        "* Обращение к атрибуту `attr` будет перенаправлено к\n",
        "методу `Descr.__get__` если:\n",
        "1. `Descr` — это дескриптор данных, реализующий метод\n",
        "`__get__`, или\n",
        "2. `Descr` — это дескриптор, реализующий только метод\n",
        "`__get__`, и в `__dict__` экземпляра нет атрибута `attr`.\n",
        "* Во всех остальных случаях сработает стандартная\n",
        "машинерия поиска атрибута: сначала в `__dict__`\n",
        "экземпляра, затем в `__dict__` класса и рекурсивно во всех\n",
        "родительских классах."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Z6Aklj3-iQLE"
      },
      "source": [
        "## Пример: дескриптор данных с методом `__get__`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "daPrxysGiUBI"
      },
      "source": [
        "class Descr:\n",
        "    def __get__(self, instance, owner):\n",
        "        print(\"Descr.__get__\")\n",
        "\n",
        "    def __set__(self, instance, value):\n",
        "        print(\"Descr.__set__\")\n",
        "\n",
        "class A:\n",
        "    attr = Descr()"
      ],
      "execution_count": 21,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "no7FTrZ2icoL",
        "outputId": "eced0b24-583c-4376-a561-0a434d4e6855"
      },
      "source": [
        "instance = A()\n",
        "instance.attr"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Descr.__get__\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xeBjti55ihcJ",
        "outputId": "cbd9c757-21cc-4d0a-c9c7-cca340f10c21"
      },
      "source": [
        "instance.__dict__[\"attr\"] = 42\n",
        "instance.attr"
      ],
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Descr.__get__\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nOQUGpBri2Lg"
      },
      "source": [
        "## Пример: дескриптор с единственным методом `__get__`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2jhg5h23i6IN",
        "outputId": "876c8bbe-f2b9-40ef-dc9a-a1070cfa41a8"
      },
      "source": [
        "class Descr:\n",
        "    def __get__(self, instance, owner):\n",
        "        print(\"Descr.__get__\")\n",
        "\n",
        "class A:\n",
        "    attr = Descr()\n",
        "\n",
        "instance = A()\n",
        "instance.attr"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Descr.__get__\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NZoHjoSRjBc6",
        "outputId": "31dde16f-ae25-4309-d88e-e88d0245e58d"
      },
      "source": [
        "instance.__dict__[\"attr\"] = 42\n",
        "instance.attr"
      ],
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "42"
            ]
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JjG--DO3jeSV"
      },
      "source": [
        "## Как ~~правильно~~ хранить данные в дескрипторах?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qbh5z2Dfjhpt"
      },
      "source": [
        "class Proxy:\n",
        "    def __get__(self, instance, owner):\n",
        "        # вернём значение атрибута для\n",
        "        # переданного экземпляра.\n",
        "    def __set__(self, instance, value):\n",
        "        # сохраним новое значение атрибута\n",
        "        # для переданного экземпляра.\n",
        "    def __delete__(self, instance):\n",
        "        # удалим значение атрибута для переданного\n",
        "        # экземпляра."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "scSyCxdkj-0s"
      },
      "source": [
        "## Хранение данных в дескрипторах: атрибут дескриптора"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jNxXD9-jkCD7"
      },
      "source": [
        "* Можно хранить данные в атрибутах самого дескриптора:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EqHHqlhDkFNO"
      },
      "source": [
        "class Proxy:\n",
        "    def __get__(self, instance, owner):\n",
        "        return self.value\n",
        "\n",
        "    def __set__(self, instance, value):\n",
        "        self.value = value\n",
        "\n",
        "    # __delete__ аналогично"
      ],
      "execution_count": 26,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RSuP6lIckHct"
      },
      "source": [
        "* Как это будет работать в случае нескольких экземпляров\n",
        "класса Something?\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_zAly7_VkJc8",
        "outputId": "1e1de3e4-f399-4176-dcd2-6ac4217e532e"
      },
      "source": [
        "class Something:\n",
        "    attr = Proxy()\n",
        "\n",
        "some = Something()\n",
        "some.attr = 42\n",
        "other = Something()\n",
        "other.attr"
      ],
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "42"
            ]
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KBjuhVbXk_kQ"
      },
      "source": [
        "## Хранение данных в дескрипторах: словарь"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ol-pZBn1lDJ_"
      },
      "source": [
        "* Можно хранить данные для каждого экземпляра в словаре:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "16iWp_RqlD09"
      },
      "source": [
        "class Proxy:\n",
        "    def __init__(self):\n",
        "        self.data = {}\n",
        "        \n",
        "    def __get__(self, instance, owner):\n",
        "        if instance is None:\n",
        "            return self\n",
        "        if instance not in self.data:\n",
        "            raise AttributeError\n",
        "        return self.data[instance]\n",
        "\n",
        "    def __set__(self, instance, value):\n",
        "        self.data[instance] = value\n",
        "\n",
        "    # __delete__ аналогично"
      ],
      "execution_count": 27,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_11kpczllJeC"
      },
      "source": [
        "* Очевидный минус такого подхода — экземпляр должен\n",
        "быть *hashable*, но есть и ещё одна проблема, какая?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YbqzK3gHl0YF"
      },
      "source": [
        "## Хранение данных в дескрипторах: атрибут экземпляра"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "U1Hsctsol4SF"
      },
      "source": [
        "* Наименьшее из зол — хранить данные непосредственно в\n",
        "самом экземпляре:\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6AKurIYYl8sO"
      },
      "source": [
        "class Proxy:\n",
        "    def __init__(self, label):\n",
        "        self.label = label # метка дескриптора\n",
        "    def __get__(self, instance, owner):\n",
        "        if instance is None:\n",
        "            return self\n",
        "        return instance.__dict__[self.label]\n",
        "\n",
        "    def __set__(self, instance, value):\n",
        "        instance.__dict__[self.label] = value\n",
        "\n",
        "    # __delete__ аналогично"
      ],
      "execution_count": 28,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pVmmMu61mABN"
      },
      "source": [
        "* Пример использования:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ru5XpBYFl_Nt",
        "outputId": "ca8d2c50-70e2-4d7a-93ac-41bc9ec3f1de"
      },
      "source": [
        "class Something:\n",
        "    attr = Proxy(\"attr123\")\n",
        "\n",
        "some = Something()\n",
        "some.attr = 42\n",
        "some.attr\n",
        "\n",
        "some.__dict__"
      ],
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'attr123': 42}"
            ]
          },
          "metadata": {},
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3HQuVcOYmk7N"
      },
      "source": [
        "## Примеры дескрипторов: @property"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "R_l88cqLmoSl"
      },
      "source": [
        "class property:\n",
        "    def __init__(self, get=None, set=None, delete=None):\n",
        "        self._get = get\n",
        "        self._set = set\n",
        "        self._delete = delete\n",
        "\n",
        "def __get__(self, instance, owner):\n",
        "    if self._get is None:\n",
        "        raise AttributeError(\"unreadable attribute\")\n",
        "    return self._get(instance)\n",
        "\n",
        "    # __set__ и __delete__ аналогично\n",
        "\n",
        "class Something:\n",
        "    @property\n",
        "    def attr(self):\n",
        "        return 42"
      ],
      "execution_count": 91,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yTMtv1Zlm6Zf"
      },
      "source": [
        "## Методы класса и дескрипторы"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6NaK4wLdm-nF"
      },
      "source": [
        "Напоминание: методы — это обычные функции,\n",
        "объявленные в теле класса."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_cCLukcwnB-0"
      },
      "source": [
        "class Something:\n",
        "    def do_something(self):\n",
        "        pass"
      ],
      "execution_count": 32,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Nvu_3ycSnO1v",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ca54cd56-1e8f-4bc1-b1a0-f4b918a82746"
      },
      "source": [
        "Something.do_something"
      ],
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<function __main__.Something.do_something>"
            ]
          },
          "metadata": {},
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "roykDGuRnRFk",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "67391140-4120-456c-84f6-1104efc4b2d6"
      },
      "source": [
        "Something().do_something"
      ],
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<bound method Something.do_something of <__main__.Something object at 0x7f1b695b5210>>"
            ]
          },
          "metadata": {},
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tKsDH8HUnUY8"
      },
      "source": [
        "Как это работает? Дескрипторы!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4uMSg1vznWt2"
      },
      "source": [
        "from types import MethodType\n",
        "\n",
        "class Function:\n",
        "    def __get__(self, instance, owner):\n",
        "        if instance is None:\n",
        "            return self\n",
        "        else:\n",
        "            return MethodType(self, instance, owner)"
      ],
      "execution_count": 35,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KQNGkMHhnsmO"
      },
      "source": [
        "## Статические методы и методы класса"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ow2Z44HvnyP1"
      },
      "source": [
        "* Декоратор `staticmethod` позволяет объявить статический\n",
        "метод, то есть просто функцию, внутри класса:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wmX8e-odn5Sy"
      },
      "source": [
        "class SomeClass:\n",
        "    @staticmethod\n",
        "    def do_something():\n",
        "        pass\n",
        "\n",
        "SomeClass.do_something()"
      ],
      "execution_count": 36,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kxiESVNYoEzP"
      },
      "source": [
        "* Для объявления методов класса используется похожий\n",
        "декоратор `classmethod`. Первый аргумент метода класса —\n",
        "непосредственно сам класс, а не его экземпляр."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XqTBP8PooJlW",
        "outputId": "330ced0b-b50e-4fbe-ff05-5087be5589e1"
      },
      "source": [
        "class Settings:\n",
        "    @classmethod\n",
        "    def read_from(cls, path):\n",
        "        return cls() # noop\n",
        "\n",
        "Settings.read_from(\"./settings.ini\")"
      ],
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<__main__.Settings at 0x7f1b68d70e90>"
            ]
          },
          "metadata": {},
          "execution_count": 37
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s0bf7TQuofyu"
      },
      "source": [
        "## Примеры дескрипторов: @staticmethod и @classmethod"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nrMUJwqRojrW",
        "outputId": "f92d4e4e-714f-4ad1-9132-925acea2bb12"
      },
      "source": [
        "class staticmethod:\n",
        "    def __init__(self, method):\n",
        "        self._method = method\n",
        "\n",
        "    def __get__(self, instance, owner):\n",
        "        return self._method\n",
        "\n",
        "class Something:\n",
        "    @staticmethod\n",
        "    def do_something():\n",
        "        print(\"I'm busy, alright?\")\n",
        "\n",
        "Something().do_something()"
      ],
      "execution_count": 67,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "I'm busy, alright?\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "x08Ia22J8UTX",
        "outputId": "ddcc9cf9-0b7c-4786-ef18-1a88d3ff2999"
      },
      "source": [
        "import functools\n",
        "\n",
        "class classmethod:\n",
        "    def __init__(self, method):\n",
        "        self._method = method\n",
        "\n",
        "    def __get__(self, instance, owner):\n",
        "        return functools.partial(self._method, owner)\n",
        "\n",
        "\n",
        "class Something:\n",
        "    @classmethod\n",
        "    def do_something(cls):\n",
        "        print(\"Called with \", cls)\n",
        "\n",
        "\n",
        "Something().do_something()"
      ],
      "execution_count": 70,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Called with  <class '__main__.Something'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZYh5I5DDpIVi"
      },
      "source": [
        "## Дескрипторы: резюме"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jsQY2R_2pK2e"
      },
      "source": [
        "* Как и свойства, дескрипторы позволяют контролировать\n",
        "чтение, изменение и удаление атрибута, но, в отличие от\n",
        "свойств, дескрипторы можно переиспользовать.\n",
        "* Дескриптор — это экземпляр класса, реализующего любую\n",
        "комбинацию методов `__get__`, `__set__` и `__delete__`.\n",
        "* Мы поговорили про:\n",
        "    * использование дескрипторов,\n",
        "    * семантику протокола дескрипторов,\n",
        "    * подводные камни при написании собственных\n",
        "дескрипторов,\n",
        "    * декораторы `staticmethod` и `classmethod`."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qzlt2dchqbnY"
      },
      "source": [
        "# Метаклассы"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eW05yMrHqeA9"
      },
      "source": [
        "## Что такое метакласс?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eWDxYXaKqi7t"
      },
      "source": [
        "* Все классы в Python — это экземпляры класса `type`.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0VqBa49bqqm9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1671b88f-1795-434d-8b8f-0a4e22f8ee03"
      },
      "source": [
        "class Something:\n",
        "    attr = 42\n",
        "\n",
        "Something"
      ],
      "execution_count": 40,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "__main__.Something"
            ]
          },
          "metadata": {},
          "execution_count": 40
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SJt89yk4qzVV",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5b916930-dc1c-4219-f4b7-a9011534093c"
      },
      "source": [
        "type(Something)"
      ],
      "execution_count": 41,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "type"
            ]
          },
          "metadata": {},
          "execution_count": 41
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "huetp6RYqsyd"
      },
      "source": [
        "* Чтобы избежать путаницы с обычными классами, класс\n",
        "`type` называют метаклассом, то есть классом, экземпляры\n",
        "которого тоже классы."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uGZv9zLJqu8V",
        "outputId": "77cd9ad1-3850-4f80-afef-4c66cfd9c4e1"
      },
      "source": [
        "name, bases, attrs = \"Something\", (), {\"attr\": 42}\n",
        "Something = type(name, bases, attrs)\n",
        "Something"
      ],
      "execution_count": 42,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "__main__.Something"
            ]
          },
          "metadata": {},
          "execution_count": 42
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_eSnIjVyq8xO",
        "outputId": "14c60794-3a6b-4a36-9bad-615961a09236"
      },
      "source": [
        "some = Something()\n",
        "some.attr"
      ],
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "42"
            ]
          },
          "metadata": {},
          "execution_count": 43
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bRRz93IPrhLx"
      },
      "source": [
        "## Синтаксис использования метаклассов"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EHWgcnIPrjuG"
      },
      "source": [
        "При объявлении класса можно указать для него метакласс,\n",
        "отличный от `type`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "escGB7k0rnhJ",
        "outputId": "3a659e69-2ef0-432d-d0ad-3bb10a88c02e"
      },
      "source": [
        "class Meta(type):\n",
        "    def some_method(cls):\n",
        "        return \"foobar\"\n",
        "\n",
        "class Something(metaclass=Meta):\n",
        "    attr = 42\n",
        "\n",
        "type(Something)"
      ],
      "execution_count": 44,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "__main__.Meta"
            ]
          },
          "metadata": {},
          "execution_count": 44
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EQZLW5pMrpq3",
        "outputId": "1cd81a56-4b35-4093-93a2-a50041838fa7"
      },
      "source": [
        "Something.some_method"
      ],
      "execution_count": 45,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<bound method Meta.some_method of <class '__main__.Something'>>"
            ]
          },
          "metadata": {},
          "execution_count": 45
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 162
        },
        "id": "AuXALETVrwa3",
        "outputId": "fc0c66ca-0042-479b-9e3e-777fb27bcfd9"
      },
      "source": [
        "Something().some_method"
      ],
      "execution_count": 46,
      "outputs": [
        {
          "output_type": "error",
          "ename": "AttributeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-46-71dce19fcc58>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mSomething\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msome_method\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m: 'Something' object has no attribute 'some_method'"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l8nmApgKsJIA"
      },
      "source": [
        "## Как создаются классы: начало"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "guJ_vjGEsL9Q"
      },
      "source": [
        "* Создание классов в Python — многоэтапный процесс.\n",
        "```python\n",
        "class Something(Base, metaclass=Meta):\n",
        "    def __init__(self, attr):\n",
        "        self.attr = attr\n",
        "        \n",
        "    def do_something(self):\n",
        "        pass\n",
        "```\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lDdFcZBesRnP"
      },
      "source": [
        "* Первым делом определим метакласс.\n",
        "    * Для класса `Something` всё просто: метакласс указан явно.\n",
        "    * В общем случае интерпретатору пришлось бы обойти все\n",
        "родительские классы и поинтересоваться их метаклассом.\n",
        "    * Метакласс по умолчанию для всех классов — `type`."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NF7j5l3WDpSy"
      },
      "source": [
        "## Как создаются классы: `__dict__` и `exec`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5FoeAVGBFEmS"
      },
      "source": [
        "* Подготовим `__dict__` для будущего класса.\n",
        "    * По умолчанию это просто словарь, но метакласс может\n",
        "изменить такое поведение, определив метод класса\n",
        "`__prepare__`.\n",
        "    * Для класса `Something`:\n",
        "```python\n",
        "clsdict = Meta.__prepare__(\"Something\", (Base, ))\n",
        "```\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rq1yZbouFXuq"
      },
      "source": [
        "* Вычислим тело класса, используя `clsdict` для хранения\n",
        "локальных переменных:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5CZUIXEaMlsl",
        "outputId": "9e59a9c4-51c4-4704-ac35-7205cb78fd6d"
      },
      "source": [
        "body = \"\"\"\n",
        "def __init__(self, attr):\n",
        "    self.attr = attr\n",
        "\n",
        "def do_something(self):\n",
        "    pass\n",
        "\"\"\"\n",
        "clsdict = {}\n",
        "exec(body, globals(), clsdict)\n",
        "print(clsdict)"
      ],
      "execution_count": 93,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'__init__': <function __init__ at 0x7f1b651403b0>, 'do_something': <function do_something at 0x7f1b65140050>}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s2dkflpHFa3K"
      },
      "source": [
        "* После вызова `exec`, словарь `clsdict` содержит все методы\n",
        "и атрибуты класса."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j0vDRKp2Fvn6"
      },
      "source": [
        "## Как создаются классы: вызов метакласса"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EVGCwfWBFzEj"
      },
      "source": [
        "* Создадим объект класса, вызвав метакласс с тремя\n",
        "аргументами:\n",
        "* `name` — имя класса,\n",
        "* `bases` — кортеж родительских классов,\n",
        "* `clsdict` — словарь атрибутов и методов класса.\n",
        "```python\n",
        "Something = Meta(\"Something\", (Base, ), clsdict)\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "T6M1ow_hGA8W"
      },
      "source": [
        "## “Магический” метод `__new__`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9FiJHRmPGF80"
      },
      "source": [
        "* Кроме метода `__init__`, который инициализирует уже\n",
        "созданный экземпляр, у каждого класса в Python есть\n",
        "метод `__new__`.\n",
        "* Метод `__new__` создаёт экземпляр до инициализации."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gp_9eqbPGVz1",
        "outputId": "6fa8fb34-06c5-4b46-8d50-6cd162f9c458"
      },
      "source": [
        "class Noop:\n",
        "    def __new__(cls, *args, **kwargs):\n",
        "        print(\"Creating instance with {} and {}\"\n",
        "            .format(args, kwargs))\n",
        "        instance = super().__new__(cls)\n",
        "        return instance\n",
        "\n",
        "    def __init__(self, *args, **kwargs):\n",
        "        print(\"Initializing with {} and {}\"\n",
        "            .format(args, kwargs))\n",
        "\n",
        "noop = Noop(42, attr=\"value\")"
      ],
      "execution_count": 50,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Creating instance with (42,) and {'attr': 'value'}\n",
            "Initializing with (42,) and {'attr': 'value'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OOVocvxDIdBQ"
      },
      "source": [
        "## Пример бесполезного метакласса"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iJSC0A0CIhWU",
        "outputId": "50bd70e9-9862-4445-a476-747f9eab7575"
      },
      "source": [
        "from collections import OrderedDict\n",
        "\n",
        "class UselessMeta(type):\n",
        "    def __new__(metacls, name, bases, clsdict):\n",
        "        print(type(clsdict))\n",
        "        print(list(clsdict))\n",
        "        cls = super().__new__(metacls, name, bases,\n",
        "                                clsdict)\n",
        "        return cls\n",
        "\n",
        "    @classmethod\n",
        "    def __prepare__(metacls, name, bases):\n",
        "        return OrderedDict()\n",
        "\n",
        "class Something(metaclass=UselessMeta):\n",
        "    attr = \"foo\"\n",
        "    other_attr = \"bar\""
      ],
      "execution_count": 51,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'collections.OrderedDict'>\n",
            "['__module__', '__qualname__', 'attr', 'other_attr']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Mfw-3Y01I8r_"
      },
      "source": [
        "## Метаклассы и декораторы классов"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3qDL0pjkJADa"
      },
      "source": [
        "* Области применения декораторов классов и метаклассов\n",
        "пересекаются: и те, и другие используются для изменения\n",
        "поведения классов.\n",
        "* При этом метаклассы\n",
        "    * могут временно подменять тип `__dict__`,\n",
        "    * сохраняются при наследовании.\n",
        "* Пример:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VpLSVabvMw_2"
      },
      "source": [
        "class Base(metaclass=Meta):\n",
        "    pass\n",
        "\n",
        "class Something(Base):\n",
        "    pass # имеет метакласс\n",
        "         # Meta, а не type\n",
        "         \n",
        "@meta\n",
        "class Base:\n",
        "    pass\n",
        "\n",
        "# нужно явно\n",
        "# декорировать\n",
        "# каждый раз\n",
        "@meta\n",
        "class Something:\n",
        "    pass"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YIRrcTguJlCH"
      },
      "source": [
        "# Модуль abc"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "R-XdedPwJp3p"
      },
      "source": [
        "* Модуль `abc` содержит метакласс `ABCMeta`, который\n",
        "позволяет объявлять абстрактные базовые классы *aka* ABC.\n",
        "* Класс считается абстрактным, если:\n",
        "    * его метакласс — `ABCMeta`,\n",
        "    * хотя бы один из абстрактных методов не имеет конкретной\n",
        "реализации."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 195
        },
        "id": "dW97-gwrJ1pj",
        "outputId": "b3f22510-1c64-498f-ab22-c8f7b27df75d"
      },
      "source": [
        "import abc\n",
        "class Iterable(metaclass=abc.ABCMeta):\n",
        "    @abc.abstractmethod\n",
        "    def __iter__(self):\n",
        "        pass\n",
        "\n",
        "class Something(Iterable):\n",
        "    pass\n",
        "\n",
        "Something()"
      ],
      "execution_count": 53,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-53-208056c39e59>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      8\u001b[0m     \u001b[0;32mpass\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 10\u001b[0;31m \u001b[0mSomething\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;31mTypeError\u001b[0m: Can't instantiate abstract class Something with abstract methods __iter__"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lhSoToibJ-nt"
      },
      "source": [
        "## MemorizingDict"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NuSdIzsIKBWU",
        "outputId": "34498655-d6e2-4e00-eb93-f7a9829e5b30"
      },
      "source": [
        "from collections import deque\n",
        "\n",
        "class MemorizingDict(dict):\n",
        "    def __init__(self, *args, **kwargs):\n",
        "        super().__init__(*args, **kwargs)\n",
        "        self._history = deque(maxlen=10)\n",
        "\n",
        "    def __setitem__(self, key, value):\n",
        "        self._history.append(key)\n",
        "        super().__setitem__(key, value)\n",
        "\n",
        "    def get_history(self):\n",
        "        return self._history\n",
        "\n",
        "d = MemorizingDict({\"foo\": 42})\n",
        "d.setdefault(\"bar\", 24)"
      ],
      "execution_count": 54,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "24"
            ]
          },
          "metadata": {},
          "execution_count": 54
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "woga14MBKOUT",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "46ff1394-a9ec-4273-cab6-3050d34c9092"
      },
      "source": [
        "d[\"baz\"] = 100500\n",
        "print(d.get_history())"
      ],
      "execution_count": 55,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "deque(['baz'], maxlen=10)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P-xOUXLyKRgE"
      },
      "source": [
        "## Наследование встроенных коллекций"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dLlhPh1pKVVK"
      },
      "source": [
        "* В CPython `list`, `dict`, `set` и др. — это структуры языка C, к\n",
        "которым можно обращаться через конструкции языка\n",
        "Python.\n",
        "* Они не предполагают расширение: `dict` — это не\n",
        "какой-нибудь словарь, описанный в терминах `__getitem__`,\n",
        "`__setitem__` и др., а вполне конкретная его реализация.\n",
        "\n",
        "* Поэтому для `dict` перегруженный метод\n",
        "`MemorizingDict.__setitem__` не существует:\n",
        "* он **не будет** вызван в конструкторе при инициализации\n",
        "словаря,"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_CEVJ4bqKpAf"
      },
      "source": [
        "d = MemorizingDict({\"foo\": 42})"
      ],
      "execution_count": 56,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9f0J8vFFKrUF"
      },
      "source": [
        "\n",
        " * и в методе `setdefault`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "btbqjW3LKwxJ",
        "outputId": "c0c80ae7-71e8-4afe-f7b7-b48c3e7df236"
      },
      "source": [
        "d.setdefault(\"bar\", 24)"
      ],
      "execution_count": 57,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "24"
            ]
          },
          "metadata": {},
          "execution_count": 57
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nBIneBL6K0ti"
      },
      "source": [
        "## Модуль `collections.abc`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UytplmrjK84B"
      },
      "source": [
        "* Модуль `collections.abc` содержит абстрактные базовые\n",
        "классы для коллекций на все случаи жизни.\n",
        "* Например, чтобы реализовать `MemorizingDict`, нужно\n",
        "унаследовать его от `MutableMapping` и реализовать пять\n",
        "методов:\n",
        "    * `__getitem__`, `__setitem__`, `__delitem__`,\n",
        "    * `__iter__` и\n",
        "    * `__len__`.\n",
        "* `MutableMapping` выражает все остальные методы `dict` в\n",
        "терминах этих пяти абстрактных методов."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WO1dEpdBLMBi"
      },
      "source": [
        "**Ещё немного “магических” методов**\n",
        "```python\n",
        "instance[key]               instance.__getitem__(key)\n",
        "instance[key] = value       instance.__setitem__(key, value)\n",
        "del instance[key]           instance.__delitem__(key)\n",
        "```\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qo3OubkJLfKN"
      },
      "source": [
        "## Модуль `collections.abc` и встроенные коллекции"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uGou4RgaLizo"
      },
      "source": [
        "* Все встроенные коллекции являются наследниками `ABC` из\n",
        "модуля `collections.abc`:\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "X4xGc0C2Luia",
        "outputId": "1642f702-aa4b-4b5f-a316-15b18d910ebc"
      },
      "source": [
        "from collections import abc\n",
        "issubclass(list, abc.Sequence)"
      ],
      "execution_count": 58,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 58
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Mz20zBY0LwXS",
        "outputId": "bfc4535b-5e05-4b31-afde-f11d89200690"
      },
      "source": [
        "isinstance({}, abc.Hashable)"
      ],
      "execution_count": 59,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 59
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Fqcr5CrSLqKi"
      },
      "source": [
        "* Это позволяет компактно проверять наличие у экземпляра\n",
        "необходимых методов:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2sEthPnCLsUC",
        "outputId": "2e9b2bdd-e761-49be-e4bb-fa353f715aaf"
      },
      "source": [
        "def flatten(obj):\n",
        "    for item in obj:\n",
        "        if isinstance(item, abc.Iterable): # ?\n",
        "            yield from flatten(item)\n",
        "        else:\n",
        "            yield item\n",
        "\n",
        "list(flatten([[1, 2], 3, [], [4]]))"
      ],
      "execution_count": 60,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 2, 3, 4]"
            ]
          },
          "metadata": {},
          "execution_count": 60
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JKVa6DBzMJF8"
      },
      "source": [
        "## Модуль abc: резюме"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0leGR4FPMLWX"
      },
      "source": [
        "* Модуль abc позволяет классам в Python объявлять\n",
        "абстрактные методы.\n",
        "* Мы также поговорили про модуль `collections.abc` и его\n",
        "использование для:\n",
        "    * написания своих коллекций и\n",
        "    * проверки наличия методов у объекта."
      ]
    }
  ]
}