Seminars/06-classes/classes.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wlIHDTLw-MGR"
      },
      "source": [
        "# `Практикум по программированию на языке Python`\n",
        "<br>\n",
        "\n",
        "## `Занятие 6: Основы ООП, декораторы, исключения, typing`\n",
        "<br><br>\n",
        "\n",
        "### `Воробьев Сергей, t.me/serv01`\n",
        "\n",
        "Источник: https://github.com/MelLain/mipt-python\n",
        "\n",
        "#### `Москва, 2023`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QKnJOzkY-MGS"
      },
      "source": [
        "### `Парадигмы проектирования кода`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WQ9qGbTd-MGS"
      },
      "source": [
        "Императивное программирование (язык ассемблера)\n",
        "\n",
        "`mov ecx, 7`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NYuNfN1W-MGS"
      },
      "source": [
        "Декларативное программирование (SQL)\n",
        "\n",
        "`select * from table where index % 10 == 0`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x4LdAZn1-MGS"
      },
      "source": [
        "Подвид: функциональное программирование (Haskell)\n",
        "\n",
        "`filter even [1..10]`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HpD_miCQ-MGS"
      },
      "source": [
        "Объектно-ориентированное программирование (С++)\n",
        "\n",
        "`auto car = new Car(); a.fill_up(10)`;"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6n6Wb6jm-MGS"
      },
      "source": [
        "### `Объектно-ориентированное программирование`\n",
        "\n",
        "- Программа, как и окружающий мир, состоит из сущностей<br><br>\n",
        "- Сущности имеют какое-то внутренее состояние<br><br>\n",
        "- Также сущности взаимодействуют друг с другом<br><br>\n",
        "- ООП нужно для описания программы в виде сущностей и их взаимоотношений<br><br>\n",
        "- При этом и на сущности, и на отношения накладываются ограничения<br><br>\n",
        "- Это позволяет писать более короткий, простой и переиспользуемый код"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7JpxE0Pj-MGS"
      },
      "source": [
        "### `Базовые понятия: класс и объект`\n",
        "\n",
        "- __Класс__ представляет собой тип данных (как int или str)<br><br>\n",
        "- Это способ описания некоторой сущности, её состояния и возможного поведения<br><br>\n",
        "- Поведение при этом зависит от состояния и может его изменять<br><br>\n",
        "- __Объект__ - это конретный представитель класса (как переменная этого типа)<br><br>\n",
        "- У объекта своё состояние, изменяемое поведением<br><br>\n",
        "- Поведение полностью определяется правилами, описанными в классе<br><br>\n",
        "- Обычно данные класса называют _полями_ (или _атрибутами_), а функции - _методами_ <br><br>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P1tJC2L7-MGT"
      },
      "source": [
        "### `Базовые понятия: абстрактный класс`\n",
        "\n",
        "```\n",
        "from abc import ABCMeta, abstractmethod, abstractproperty\n",
        "class Movable:\n",
        "    __metaclass__ = ABCMeta\n",
        "\n",
        "    @abstractmethod\n",
        "    def move():\n",
        "    \"\"\"Переместить объект\"\"\"\n",
        "    \n",
        "    @abstractproperty\n",
        "    def speed():\n",
        "    \"\"\"Скорость объекта\"\"\"\n",
        "```\n",
        "\n",
        "- **Abstract Base Class** позволяют определить класс, указав при этом, какие методы или свойства обязательно переопределить в классах-наследниках"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Gm6Ctjxr-MGT"
      },
      "source": [
        "### `Принципы ООП`\n",
        "\n",
        "- **Абстракция** - выделение важных свойств объекта и игнорирование прочих<br><br>\n",
        "\n",
        "- **Инкапсуляция** - хранение данных и методов работы с ними внутри одного класса с доступом к данным только через методы<br><br>\n",
        "\n",
        "- **Наследование** - возможность создания наследников, получающих все свойства родителей с возможностью их переопределения и расширения<br><br>\n",
        "\n",
        "- **Полиморфизм** - возможность использования объектов разных типов с общим интерфейсом без информации об их внутреннем устройстве"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l5HQXgiN-MGT"
      },
      "source": [
        "### `ООП в Python`\n",
        "\n",
        "- Python - это полностью объектно-ориентированный язык<br><br>\n",
        "\n",
        "- В Python абсолютно всё является объектами, включая классы<br><br>\n",
        "\n",
        "- Полностью поддерживаются все принципы ООП<br><br>\n",
        "\n",
        "- Инкапсуляция понимается немного в другом смысле: нет ограничения на доступ к полям класса<br><br>\n",
        "\n",
        "- Поэтому для инкапсуляции используют договорные соглашения"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5eEJVUzg-MGT"
      },
      "source": [
        "### `Так выглядят классы в Python`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "Vm43Vc9o-MGT",
        "outputId": "a6745e16-afd7-4daf-adcd-9135a9f45683",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class '__main__.Car'> <class '__main__.Car'>\n",
            "10\n"
          ]
        }
      ],
      "source": [
        "class Car:\n",
        "    def __init__(self):\n",
        "        self.tank = 0\n",
        "        self.is_turned_on = False\n",
        "\n",
        "    def fill_up(self, gas_volume):\n",
        "        self.tank += gas_volume\n",
        "\n",
        "    def turn_on(self):\n",
        "        self.is_turned_on = True\n",
        "\n",
        "    def turn_off(self):\n",
        "        self.is_turned_on = False\n",
        "\n",
        "car = Car()\n",
        "print(type(car), car.__class__)\n",
        "\n",
        "car.fill_up(10)\n",
        "print(car.tank)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sRQAxu3B-MGU"
      },
      "source": [
        "### `Функция __init__`\n",
        "\n",
        "- Главное: `__init__` - не конструктор! Она ничего не создаёт и не возвращает\n",
        "\n",
        "- Созданием объекта занимается функция `__new__`, переопределять которую без необходимости не надо\n",
        "\n",
        "- `__init__` получает на вход готовый объект и инициализирует его атрибуты<br>\n",
        "\n",
        "В отличие от C++, атрибуты можно добавлять/удалять на ходу:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "oTQlINSG-MGU",
        "outputId": "db3e284d-8eea-45ba-f4a8-fdee0783e332",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 241
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "field\n"
          ]
        },
        {
          "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-4-0818b77cab1e>\u001b[0m in \u001b[0;36m<cell line: 9>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[0;32mdel\u001b[0m \u001b[0mcls\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfield\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcls\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfield\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# AttributeError: 'Cls' object has no attribute 'field'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m: 'Cls' object has no attribute 'field'"
          ]
        }
      ],
      "source": [
        "class Cls:\n",
        "    pass\n",
        "\n",
        "cls = Cls()\n",
        "cls.field = 'field'\n",
        "print(cls.field)\n",
        "\n",
        "del cls.field\n",
        "print(cls.field)  # AttributeError: 'Cls' object has no attribute 'field'"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JpuOSbGL-MGU"
      },
      "source": [
        "### `Параметр self`\n",
        "\n",
        "- Метод класса отличается от обычной функции только наличием объекта `self` в качестве первого аргумента <br><br>\n",
        "\n",
        "- Это то же самое, что происходит в C++/Java (там аналогом `self` является указатель/ссылка `this`) <br><br>\n",
        "\n",
        "- Название `self` является общим соглашением, но можно использовать и другое (не надо!)<br><br>\n",
        "\n",
        "- Метод класса, не получающий на вход `self` является _статическим_<br><br>\n",
        "\n",
        "- Статические методы часто используются для специализированного создания объектов класса<br><br>\n",
        "\n",
        "- Еще есть _методы класса_, входом у них является класс как объект<br><br>\n",
        "\n",
        "- В Python `__new__` является статическим методом"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dr-XMflV-MGU"
      },
      "source": [
        "### `Как быть с инкапсуляцией`\n",
        "\n",
        "- Приватное поле прежде всего должно быть обозначено таковым\n",
        "- В Python для этого есть соглашения:<br>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "mBrkaDOy-MGU",
        "outputId": "02fc3a5d-6511-4469-a69a-eca8ddaa4209",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 279
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Ok\n",
            "You're shouldn't see it\n",
            "YOU REALLY SHOULDN'T SEE IT!!!\n"
          ]
        },
        {
          "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-7-44fcf99ca256>\u001b[0m in \u001b[0;36m<cell line: 14>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     12\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcls\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_private_field\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcls\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_mangled_field\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[0;32m---> 14\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcls\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__mangled_field\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m: 'Cls' object has no attribute '__mangled_field'"
          ]
        }
      ],
      "source": [
        "class Cls:\n",
        "    def __init__(self):\n",
        "        self.public_field = 'Ok'\n",
        "        self._private_field = \"You're shouldn't see it\"\n",
        "        self.__mangled_field = \"YOU REALLY SHOULDN'T SEE IT!!!\"\n",
        "\n",
        "    def get_mangled_field(self):\n",
        "        return self.__mangled_field\n",
        "\n",
        "cls = Cls()\n",
        "print(cls.public_field)\n",
        "print(cls._private_field)\n",
        "print(cls.get_mangled_field())\n",
        "print(cls.__mangled_field)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "id": "4kEaNqxL-MGU",
        "outputId": "b6186aa7-23c3-4fb8-f9d6-2147eeab5a4a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "YOU REALLY SHOULDN'T SEE IT!!!\n"
          ]
        }
      ],
      "source": [
        "print(cls._Cls__mangled_field)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uYof1pjd-MGU"
      },
      "source": [
        "### `Атрибуты объекта и класса`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "id": "e0s4eLya-MGU",
        "outputId": "a9186429-fc96-4611-f87a-f1d4a6342128",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[]\n",
            "['some_obj_attr']\n"
          ]
        }
      ],
      "source": [
        "class Cls:\n",
        "    pass\n",
        "\n",
        "cls = Cls()\n",
        "print([e for e in dir(cls) if not e.startswith('__')])\n",
        "\n",
        "cls.some_obj_attr = '1'\n",
        "print([e for e in dir(cls) if not e.startswith('__')])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "id": "Jt1KEspO-MGU",
        "outputId": "36d79133-dc0f-4808-abdd-3446745eaba3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[]\n",
            "['some_cls_attr']\n",
            "['some_cls_attr', 'some_obj_attr']\n"
          ]
        }
      ],
      "source": [
        "print([e for e in dir(Cls) if not e.startswith('__')])\n",
        "\n",
        "Cls.some_cls_attr = '1'\n",
        "print([e for e in dir(Cls) if not e.startswith('__')])\n",
        "print([e for e in dir(cls) if not e.startswith('__')])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vry_VxkH-MGV"
      },
      "source": [
        "### `Переменная __dict__`\n",
        "\n",
        "- Для большого числа типов в Python пределена переменная-словарь `__dict__`\n",
        "- Она содержит атрибуты, специфичные для данного объекта (не его класса и не его родителей)\n",
        "- Множество элементов `__dict__` является подмножеством элементов, возвращаемых функцией `dir()`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 32,
      "metadata": {
        "id": "AtQcfk6y-MGV",
        "outputId": "892ccc10-a336-422a-d53e-ec288191ea1a",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 260
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n"
          ]
        },
        {
          "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-32-133030d28b5d>\u001b[0m in \u001b[0;36m<cell line: 5>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mA\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__dict__\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mkeys\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0missubset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdir\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mA\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[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__dict__\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# https://stackoverflow.com/questions/46575174/if-an-object-doesnt-have-dict-must-its-class-have-a-slots-attribut\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mAttributeError\u001b[0m: 'list' object has no attribute '__dict__'"
          ]
        }
      ],
      "source": [
        "class A: pass\n",
        "\n",
        "print(set(A.__dict__.keys()).issubset(set(dir(A))))\n",
        "\n",
        "[].__dict__\n",
        "# https://stackoverflow.com/questions/46575174/if-an-object-doesnt-have-dict-must-its-class-have-a-slots-attribut"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Bt4JKoFn-MGV"
      },
      "source": [
        "### `Доступ к атрибутам`\n",
        "\n",
        "- Для работы с атрибутами есть функции `getattr`, `setattr` и `delattr`\n",
        "- Их основное преимущество - оперирование именами атрибутов в виде строк"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "OIdXf6-d-MGV",
        "outputId": "c6d7a364-89d4-417a-b116-e5f94f837630"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "some\n"
          ]
        },
        {
          "ename": "AttributeError",
          "evalue": "'Cls' object has no attribute 'some_attr'",
          "output_type": "error",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-13-7a637e97d7b9>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0mdelattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcls\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'some_attr'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgetattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcls\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'some_attr'\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;31mAttributeError\u001b[0m: 'Cls' object has no attribute 'some_attr'"
          ]
        }
      ],
      "source": [
        "cls = Cls()\n",
        "\n",
        "setattr(cls, 'some_attr', 'some')\n",
        "\n",
        "print(getattr(cls, 'some_attr'))\n",
        "\n",
        "delattr(cls, 'some_attr')\n",
        "\n",
        "print(getattr(cls, 'some_attr'))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "73PSm1ue-MGV"
      },
      "source": [
        "### `Class magic methods`\n",
        "\n",
        "- Магические методы придают объекту класса определённые свойства\n",
        "\n",
        "- Такие методы получают `self` вызываются интерпретатором неявно\n",
        "\n",
        "- Например, операторы - это магические методы<bf>\n",
        "\n",
        "Рассмотрим несколько примеров:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "BUS-TxWn-MGV",
        "outputId": "8eb856db-ae41-426e-e84c-89ef9e1d7c4d"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Class: Some class\n",
            "Some classSome class\n"
          ]
        }
      ],
      "source": [
        "class Cls:\n",
        "    def __init__(self):  # initialize object\n",
        "        self.name = 'Some class'\n",
        "\n",
        "    def __repr__(self):  # str for printing object\n",
        "        return 'Class: {}'.format(self.name)\n",
        "\n",
        "    def __call__(self, counter):  # call == operator() in C++\n",
        "        return self.name * counter\n",
        "\n",
        "cls = Cls()\n",
        "print(cls.__repr__())  # == print(cls)\n",
        "print(cls(2))"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class Digit:\n",
        "    def __add__(self, val):\n",
        "        print('add')\n",
        "    def __mul__(self, val):\n",
        "        print('add')\n",
        "Digit() + Digit(), Digit() * Digit()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "d9GEY9rpKO2m",
        "outputId": "66337017-d1bf-4425-b48f-6f21b5bbd3c1"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "add\n",
            "add\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(None, None)"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8h9mIKuu-MGV"
      },
      "source": [
        "### `Class magic methods`\n",
        "\n",
        "Ещё примеры магических методов:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "f9Fuo-VV-MGV"
      },
      "outputs": [],
      "source": [
        "def __lt__(self, other): pass\n",
        "\n",
        "def __eq__(self, other): pass\n",
        "\n",
        "def __add__(self, other): pass\n",
        "\n",
        "def __mul__(self, value): pass\n",
        "\n",
        "def __int__(self): pass\n",
        "\n",
        "def __bool__(self): pass\n",
        "\n",
        "def __hash__(self): pass\n",
        "\n",
        "def __getitem__(self, index): pass\n",
        "\n",
        "def __setitem__(self, index, value): pass"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Wd8hjxvw-MGV"
      },
      "source": [
        "### `Как на самом деле устроен доступ к атрибутам`\n",
        "\n",
        "При работе с атрибутами вызываются магические методы `__getattr__`, `__getattribute__`, `__setattr__` и `__delattr__`:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 25,
      "metadata": {
        "id": "h4P4qonV-MGV"
      },
      "outputs": [],
      "source": [
        "class Cls:\n",
        "    def __setattr__(self, attr, value):\n",
        "        print(f'Create attr with name \"{attr}\" and value \"{value}\"')\n",
        "        self.__dict__[attr] = value\n",
        "\n",
        "    def __getattr__(self, attr):\n",
        "        print(f'WE WILL ENTER IT ONLY IN CASE OF ERROR!')\n",
        "        return self.__dict__[attr]\n",
        "\n",
        "    def __getattribute__(self, attr):\n",
        "        if not attr.startswith('__'):\n",
        "            print(f'Get value of attr with name \"{attr}\"')\n",
        "\n",
        "        return super().__getattribute__(attr)  # call parent method implementation\n",
        "\n",
        "    def __delattr__(self, attr):\n",
        "        print(f'Remove attr \"{attr}\" is impossible!')\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XTcEhc_e-MGV"
      },
      "source": [
        "### `Как на самом деле устроен доступ к атрибутам`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 31,
      "metadata": {
        "id": "M4f8AWt5-MGV",
        "outputId": "a30aeb87-98aa-44c8-d6d8-91f09dadedd5",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 468
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Create attr with name \"some_attr\" and value \"some\"\n",
            "Get value of attr with name \"some_attr\"\n",
            "Remove attr \"some_attr\" is impossible!\n",
            "Get value of attr with name \"some_attr\"\n",
            "Get value of attr with name \"non_exists_attr\"\n",
            "WE WILL ENTER IT ONLY IN CASE OF ERROR!\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "KeyError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-31-e2e4cd9a9b98>\u001b[0m in \u001b[0;36m<cell line: 8>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;32mdel\u001b[0m \u001b[0mcls\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msome_attr\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0mb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcls\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msome_attr\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m \u001b[0mcls\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnon_exists_attr\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m<ipython-input-25-5026201554ff>\u001b[0m in \u001b[0;36m__getattr__\u001b[0;34m(self, attr)\u001b[0m\n\u001b[1;32m      6\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__getattr__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mattr\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[1;32m      7\u001b[0m         \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf'WE WILL ENTER IT ONLY IN CASE OF ERROR!'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__dict__\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mattr\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      9\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__getattribute__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mattr\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;31mKeyError\u001b[0m: 'non_exists_attr'"
          ]
        }
      ],
      "source": [
        "cls = Cls()\n",
        "\n",
        "cls.some_attr = 'some'\n",
        "a = cls.some_attr\n",
        "\n",
        "del cls.some_attr\n",
        "b = cls.some_attr\n",
        "cls.non_exists_attr"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "piUPvzc2-MGV"
      },
      "source": [
        "### `Магические методы и менеджер контекста`\n",
        "\n",
        "Менеджер контекста (оператор `with`) работает с двумя магическими методами:\n",
        "\n",
        "- `__enter__` - код, который нужно выполнить над объектом при входе в блок менеджера\n",
        "- `__exit__` - код, который нужно в любом случае выполнить при выходе из блока"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 40,
      "metadata": {
        "id": "Q8Cw13q3-MGV",
        "outputId": "98d7a890-9316-480b-9854-af90c8c89db2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Set DB to read-write mode\n",
            "Set DB to read-only mode\n",
            "(1,)\n"
          ]
        }
      ],
      "source": [
        "class SomeDataBaseDao:\n",
        "    def __init__(self): self._db = ()\n",
        "\n",
        "    def append(self, value): self._db.append(value)\n",
        "\n",
        "    def __enter__(self):\n",
        "        self._db = list(self._db)\n",
        "        print('Set DB to read-write mode')\n",
        "        return self\n",
        "\n",
        "    def __exit__(self, exception_type, exception_val, trace):\n",
        "        self._db = tuple(self._db)\n",
        "        print('Set DB to read-only mode')\n",
        "        return True\n",
        "\n",
        "dao = SomeDataBaseDao()\n",
        "#dao.append(1)  # AttributeError: 'tuple' object has no attribute 'append'\n",
        "with dao:\n",
        "    dao.append(1)\n",
        "print(dao._db)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Например: https://pytorch.org/docs/stable/_modules/torch/autograd/grad_mode.html#no_grad"
      ],
      "metadata": {
        "id": "kony4y4mL5JP"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IP42hCFH-MGV"
      },
      "source": [
        "### `Наследование в Python`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "L98aLT3n-MGW",
        "outputId": "4eec960b-70ae-4378-cdaf-81a37020300f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "10 10 10\n",
            "{'value': 10}\n",
            "{'value': 10, 'new_value': 20}\n"
          ]
        }
      ],
      "source": [
        "class Parent:\n",
        "    def __init__(self):\n",
        "        self.value = 10\n",
        "\n",
        "    def get_value(self):\n",
        "        return self.value\n",
        "\n",
        "class Child(Parent):\n",
        "    pass\n",
        "\n",
        "class NewChild(Parent):\n",
        "    def __init__(self):\n",
        "        super().__init__()  # without it we will not have `value` field\n",
        "        self.new_value = 20\n",
        "\n",
        "print(Parent().get_value(), Child().get_value(), NewChild().get_value())\n",
        "\n",
        "print(Child().__dict__)\n",
        "print(NewChild().__dict__)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rfZzM2Au-MGW"
      },
      "source": [
        "### `Перегрузка родительских методов`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "nFQ_j6y9-MGW",
        "outputId": "d44171c4-dcb4-4911-e76f-d3db5be4c089"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "10\n",
            "20\n",
            "10\n",
            "Value: 10\n"
          ]
        }
      ],
      "source": [
        "class Parent:\n",
        "    def __init__(self, value):\n",
        "        self._value = value\n",
        "\n",
        "    def get_value(self):\n",
        "        return self._value\n",
        "\n",
        "    def __str__(self):\n",
        "        return f'Value: {self._value}'\n",
        "\n",
        "class Child(Parent):\n",
        "    def __init__(self, value):\n",
        "        Parent.__init__(self, value)  # == super().__init__(value)\n",
        "\n",
        "    def get_value(self):\n",
        "        return Parent.get_value(self) * 2  # == super().get_value() * 2\n",
        "\n",
        "print(Parent(10).get_value())\n",
        "print(Child(10).get_value())\n",
        "print(Child(10)._value)\n",
        "print(Child(10))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "woStdhxN-MGW"
      },
      "source": [
        "### Искаженные (mangled) атрибуты\n",
        "\n",
        "Главное название такого именования - борьба с коллизией важных полей при наследовании (аналог `final` атрибутов в Java):"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 47,
      "metadata": {
        "id": "9lwtRBZB-MGW",
        "outputId": "5db812a0-b017-46b3-89a5-96992fcf51be",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'_Parent__variable': 'Parent'}\n",
            "{'_Child__variable': 'Child'}\n"
          ]
        }
      ],
      "source": [
        "class Parent:\n",
        "    def __init__(self):\n",
        "        self.__variable = 'Parent'\n",
        "\n",
        "class Child(Parent):\n",
        "    def __init__(self):\n",
        "        self.__variable = 'Child'\n",
        "\n",
        "print(Parent().__dict__)\n",
        "print(Child().__dict__)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "agfgeDoy-MGW"
      },
      "source": [
        "### `Множественное наследование`\n",
        "\n",
        "- Даёт возможность классу получить методы и свойства сразу нескольких предков<br><br>\n",
        "- Позволяет строить сложные иерархии зависимостей<br><br>\n",
        "- Использовать без необходимости не нужно, поскольку архитектура кода сильно усложняется<br><br>\n",
        "- В Python поддерживается без ограничений<br><br>\n",
        "- У класса может быть один и более предков (`object` есть всегда)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g3axOS7Y-MGW"
      },
      "source": [
        "### `Множественное наследование в Python`\n",
        "- Методы и атрибуты ищутся в следующем порядке:<br><br>\n",
        "    1. имя ищется в объекте (т.е. в его `__dict__`)\n",
        "    2. дальше в классе объекта\n",
        "    3. дальше в предках класса<br><br>\n",
        "- Для поиска по предкам используется MRO (Method resolution order)<br><br>\n",
        "- У каждого класса в момент создания вычисляется этот порядок и сохраняется в атрибуте `__mro__`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "OUmAybr--MGW",
        "outputId": "cd0aa4e9-376f-440b-a1b7-247c5232b358"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)\n",
            "A\n"
          ]
        }
      ],
      "source": [
        "class A():\n",
        "    def method(self): return 'A'\n",
        "\n",
        "class B():\n",
        "    def method(self): return 'B'\n",
        "\n",
        "class C(A, B): pass\n",
        "\n",
        "print(C.__mro__)\n",
        "print(C().method())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Pp6vGhiI-MGW"
      },
      "source": [
        "### `Вызов метода класса-родителя`\n",
        "\n",
        "- В Python есть два способа обращения к родительским методам<br><br>\n",
        "    - через функцию `super` (использует порядок mro)\n",
        "    - напрямую по имени<br><br>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "FdLDVZFC-MGW",
        "outputId": "4bc20466-e129-45c2-b13e-bfc4c39870ec"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)\n",
            "('A', 'B', 'A')\n"
          ]
        }
      ],
      "source": [
        "class A():\n",
        "    def method(self): return 'A'\n",
        "\n",
        "class B():\n",
        "    def method(self): return 'B'\n",
        "\n",
        "class C(A, B):\n",
        "    def method(self):\n",
        "        return (A.method(self), B.method(self), super().method())\n",
        "\n",
        "print(C.__mro__)\n",
        "print(C().method())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Eiolcicz-MGW"
      },
      "source": [
        "### `Функция isinstance`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "x3GnAg0E-MGW",
        "outputId": "47cbe5fa-9f3f-4bbb-9776-5768c5ec0b3e"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "isinstance(1, int) == True\n",
            "isinstance(1.0, int) == False\n",
            "isinstance(True, int) == True\n",
            "isinstance(Cls1(), Cls1) == True\n",
            "isinstance(Cls1(), Interface) == True\n",
            "isinstance(Cls1(), object) == True\n",
            "isinstance(Cls2(), Cls1) == False\n"
          ]
        }
      ],
      "source": [
        "print('isinstance(1, int) == {}'.format(isinstance(1, int)))\n",
        "print('isinstance(1.0, int) == {}'.format(isinstance(1.0, int)))\n",
        "print('isinstance(True, int) == {}'.format(isinstance(True, int)))\n",
        "\n",
        "class Interface:\n",
        "    def get_value(self):\n",
        "        raise NotImplementedError\n",
        "\n",
        "class Cls1(Interface):\n",
        "    pass\n",
        "\n",
        "class Cls2(Interface):\n",
        "    pass\n",
        "\n",
        "print('isinstance(Cls1(), Cls1) == {}'.format(isinstance(Cls1(), Cls1)))\n",
        "print('isinstance(Cls1(), Interface) == {}'.format(isinstance(Cls1(), Interface)))\n",
        "print('isinstance(Cls1(), object) == {}'.format(isinstance(Cls1(), object)))\n",
        "\n",
        "print('isinstance(Cls2(), Cls1) == {}'.format(isinstance(Cls2(), Cls1)))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XK4igzhq-MGW"
      },
      "source": [
        "### `Функция issubclass`\n",
        "\n",
        "Очень похожа на `isinstance`, но проверяет только классы, не объекты:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1JkMPwJC-MGX",
        "outputId": "02eef66d-3d96-402b-fe25-b9b33c88715c"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "issubclass(float, int) == False\n",
            "issubclass(bool, int) == True\n",
            "issubclass(Cls1, Interface) == True\n",
            "issubclass(Cls1, object) == True\n",
            "issubclass(Cls2, Cls1) == False\n"
          ]
        }
      ],
      "source": [
        "# print('issubclass(1, int) == {}'.format(issubclass(1, int))) -> TypeError: issubclass() arg 1 must be a class\n",
        "print('issubclass(float, int) == {}'.format(issubclass(float, int)))\n",
        "print('issubclass(bool, int) == {}'.format(issubclass(bool, int)))\n",
        "\n",
        "# print('issubclass(Cls1(), Cls1) == {}'.format(issubclass(Cls1(), Cls1))) -> TypeError\n",
        "print('issubclass(Cls1, Interface) == {}'.format(issubclass(Cls1, Interface)))\n",
        "print('issubclass(Cls1, object) == {}'.format(issubclass(Cls1, object)))\n",
        "print('issubclass(Cls2, Cls1) == {}'.format(issubclass(Cls2, Cls1)))"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### `Полиморфизм в Python`"
      ],
      "metadata": {
        "id": "IIewPfAasLM5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Animal:\n",
        "    def speak(self):\n",
        "        print(\"Animal speaks\")\n",
        "\n",
        "class Dog(Animal):\n",
        "    def speak(self):\n",
        "        print(\"Dog barks\")\n",
        "\n",
        "class Cat(Animal):\n",
        "    def speak(self):\n",
        "        print(\"Cat meows\")\n",
        "\n",
        "# Create objects\n",
        "animal1 = Dog()\n",
        "animal2 = Cat()\n",
        "\n",
        "# Call speak for each class\n",
        "animal1.speak()  # Вывод: Dog barks\n",
        "animal2.speak()  # Вывод: Cat meows"
      ],
      "metadata": {
        "id": "1f9Jjn6EsROm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### `Декораторы в Python`\n",
        "\n",
        "- Функции или классы, которые позволяют добавлять дополнительную функциональность к другим функциям или методам <br>\n",
        "- В Python они реализованы как обёртки вокруг функций или методов"
      ],
      "metadata": {
        "id": "8clHgzDOVkwJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def simple_decorator(func):\n",
        "    def wrapper():\n",
        "        print(\"Before function call\")\n",
        "        func()\n",
        "        print(\"After function call\")\n",
        "    return wrapper\n",
        "\n",
        "@simple_decorator\n",
        "def say_hello():\n",
        "    print(\"Hello!\")\n",
        "\n",
        "say_hello()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "o6LnrbbwVv3v",
        "outputId": "5fbbfb53-88b9-49bd-d0eb-61cd7d82c872"
      },
      "execution_count": 57,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Before function call\n",
            "Hello!\n",
            "After function call\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Чтобы передать аргументы в декорируемую функцию, используется `*args` и `**kwargs`:"
      ],
      "metadata": {
        "id": "fAYwrnL9V0e4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def decorator_with_args(func):\n",
        "    def wrapper(*args, **kwargs):\n",
        "        print(f\"Arguments were: {args}, {kwargs}\")\n",
        "        return func(*args, **kwargs)\n",
        "    return wrapper\n",
        "\n",
        "@decorator_with_args\n",
        "def greet(name):\n",
        "    print(f\"Hi, {name}!\")\n",
        "\n",
        "greet(\"Alice\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rcFYbP_9WFOi",
        "outputId": "e2d7768f-dc3a-456d-ae40-1f0781c5271f"
      },
      "execution_count": 58,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Arguments were: ('Alice',), {}\n",
            "Hi, Alice!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Можно накладывать несколько декораторов на одну функцию. Они будут применяться сверху вниз:\n",
        "\n",
        "```\n",
        "@decorator1\n",
        "@decorator2\n",
        "def my_func():\n",
        "    pass\n",
        "```\n",
        "Это эквивалентно\n",
        "```\n",
        "my_func = decorator1(decorator2(my_func))\n",
        "```"
      ],
      "metadata": {
        "id": "oNEc-qf9WPjs"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Класс — это `callable`, так что ему ничто не мешает быть декоратором:"
      ],
      "metadata": {
        "id": "mecB6kzmXeAN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Timer:\n",
        "    from time import time\n",
        "    from sys import stderr\n",
        "\n",
        "    def __init__(self, fun):\n",
        "        self.function = fun\n",
        "\n",
        "    def __call__(self, *args, **kwargs):\n",
        "        start_time = self.time()\n",
        "        result = self.function(*args, **kwargs)\n",
        "        end_time = self.time()\n",
        "        print(f\"Duration: {end_time-start_time} seconds\", file=self.stderr)\n",
        "        return result\n",
        "\n",
        "\n",
        "# adding a decorator to the function\n",
        "@Timer\n",
        "def payload(delay):\n",
        "    return sorted(sum(range(i)) for i in range(delay))\n",
        "\n",
        "print(payload(10000)[-1])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lU7st2abXYvm",
        "outputId": "9efa5831-9492-4b27-f285-fac3eba2a896"
      },
      "execution_count": 59,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "49985001\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Duration: 1.0111806392669678 seconds\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3Jzk-w9B-MGX"
      },
      "source": [
        "### `Декораторы в Python`\n",
        "\n",
        "Есть много декораторов, встроенных в Python:\n",
        "\n",
        "__Пример__: декоратор `@property`, превращающий get-метод класса в неизменяемое поле для чтения:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "F-ZO0vwq-MGX",
        "outputId": "dd47cb5d-c016-40e1-9630-bb4db28d2f03"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "value\n"
          ]
        }
      ],
      "source": [
        "class A:\n",
        "    def __init__(self):\n",
        "        self._field = 'value'\n",
        "\n",
        "    @property\n",
        "    def field(self):\n",
        "        return self._field\n",
        "\n",
        "a = A()\n",
        "print(a.field)\n",
        "\n",
        "#a.field() -> TypeError: 'str' object is not callable\n",
        "#a.field = 5 -> AttributeError: can't set attribute"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2PriSWsl-MGX"
      },
      "source": [
        "- В языке и библиотеках определено множество декораторов, используем далее некоторые\n",
        "- Определять декораторы можно самостоятельно, об этом мы говорили выше"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2-reTzC9-MGX"
      },
      "source": [
        "### `Статические методы`\n",
        "\n",
        "- Обычные методы класса принимают на вход первым параметром вызывающий объект и работают с ним\n",
        "- Статические методы являются методами класса и к объекту не привязаны\n",
        "- Как следствие, их можно вызывать без объекта\n",
        "- В Python статический метод определяется с помощью декоратора `@staticmethod`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "b-BJdeni-MGX",
        "outputId": "dffd049f-1419-4814-e03d-54282d72a373"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Regular method\n",
            "Static method\n",
            "Static method\n",
            "Regular method\n"
          ]
        }
      ],
      "source": [
        "class A:\n",
        "    def method(self):\n",
        "        print('Regular method')\n",
        "\n",
        "    @staticmethod\n",
        "    def static_method():\n",
        "        print('Static method')\n",
        "\n",
        "# A.method()  # method() missing 1 required positional argument: 'self'\n",
        "\n",
        "A().method()\n",
        "A.static_method()\n",
        "A().static_method()  # object also has his type methods\n",
        "A.method(A())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W_dkPe8V-MGX"
      },
      "source": [
        "### `Методы класса`\n",
        "\n",
        "- Метод класса получает на вход объект-класса вместо объекта класса\n",
        "- Используется для доступа к свойствам класса в целом (а не свойствам его экземпляров)\n",
        "- В Python метод класса определяется с помощью декоратора `@classmethod`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "m44Kqp-E-MGX",
        "outputId": "9fe9dedb-4529-47ff-a3be-faac907d6dd9"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "10\n",
            "20\n"
          ]
        }
      ],
      "source": [
        "class Cls:\n",
        "    attr = 10\n",
        "\n",
        "    @classmethod\n",
        "    def set_attr(cls, val):\n",
        "        cls.attr = val\n",
        "\n",
        "a = Cls()\n",
        "print(a.attr)\n",
        "\n",
        "b = Cls()\n",
        "b.set_attr(20)\n",
        "print(a.attr)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "25G20zcV-MGX"
      },
      "source": [
        "### `Исключения`\n",
        "\n",
        "- Исключение - механизм, который был придуман для штатной обработки ошибочных ситуаций<br><br>\n",
        "- Можно воспринимать его как способ передачи управления вверх по стеку вызова<br><br>\n",
        "- Часто ошибочно относится к ООП, на самом деле это иная концепция<br><br>\n",
        "- Python поддерживает исключения, и ими надо пользоваться<br><br>\n",
        "- В языке есть большая иерархия классов исключений на все случаи жизни<br><br>\n",
        "- Если нужен свой класс, то можно наследовать от какого-то из существующих<br><br>\n",
        "- Оптимальный вариант - класс `Exception`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LnQlQOhz-MGX"
      },
      "source": [
        "### `Базовый синтаксис`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "id": "ClMtFIYb-MGX",
        "outputId": "29672bd4-098d-45b5-9ed4-eef9bb9e7fdf",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 185
        }
      },
      "outputs": [
        {
          "output_type": "error",
          "ename": "ZeroDivisionError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-16-bc757c3fda29>\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;36m1\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mZeroDivisionError\u001b[0m: division by zero"
          ]
        }
      ],
      "source": [
        "1 / 0"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "id": "Js7UH5G9-MGX",
        "outputId": "57dff063-c950-432f-8b83-2a7eaffd32b3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Zero division!\n"
          ]
        }
      ],
      "source": [
        "try:\n",
        "    1 / 0\n",
        "except:\n",
        "    print('Zero division!')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "id": "Vm1sdevz-MGY",
        "outputId": "a94c2115-b643-4b79-f372-a47b48f10215",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Zero division!\n"
          ]
        }
      ],
      "source": [
        "try:\n",
        "    raise ZeroDivisionError\n",
        "except:\n",
        "    print('Zero division!')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gEgr7i8t-MGY"
      },
      "source": [
        "### `Полный синтаксис`"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "try:\n",
        "    raise ValueError()\n",
        "except ValueError:\n",
        "    print('ERROR')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_d2lVVbzeWI3",
        "outputId": "c3de2438-4930-47d8-caed-7a2e9c214bab"
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "ERROR\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "yGPa8JTc-MGY",
        "outputId": "ba440671-fcfa-4e81-9f94-0abe9cbd0576"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "OK\n",
            "finally\n"
          ]
        }
      ],
      "source": [
        "try:\n",
        "    # some code\n",
        "    pass\n",
        "\n",
        "except ValueError:  # catch value errors\n",
        "    print('ERROR')  # do something\n",
        "    raise           # continue rising of this exception (or can skip it)\n",
        "\n",
        "except RuntimeError as error:  # catch runtume errors and store object\n",
        "    print(error)               # inspect exception content\n",
        "    raise error                # continue rising\n",
        "\n",
        "except:             # try not to use except without class specification\n",
        "    print('Unknown error')\n",
        "    pass\n",
        "\n",
        "else:            # if there's no exception, execute this branch\n",
        "    print('OK')\n",
        "finally:         # actions that chould be done in any case\n",
        "    #some actions (closing files for instance)\n",
        "    print('finally')\n",
        "    pass"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HGzDExEx-MGY"
      },
      "source": [
        "### `Сохранение объектов: модуль pickle`\n",
        "\n",
        "Метод pickle в Python используется для сериализации и десериализации объектов. Сериализация — это процесс преобразования объекта в байтовый поток, а десериализация — это обратный процесс, возвращающий объект из байтового потока."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vJWSQ9f9-MGY"
      },
      "outputs": [],
      "source": [
        "class Cls:\n",
        "    def __init__(self, value):\n",
        "        self.__value = value\n",
        "\n",
        "    def get_value(self):\n",
        "        return self.__value"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "aHDV-_Ad-MGY"
      },
      "outputs": [],
      "source": [
        "import pickle\n",
        "\n",
        "cls = Cls(Cls(10))\n",
        "\n",
        "with open('cls.pkl', 'wb') as fout:\n",
        "    pickle.dump(cls, fout)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "5PcLjozH-MGY"
      },
      "outputs": [],
      "source": [
        "with open('cls.pkl', 'rb') as fin:\n",
        "    cls_2 = pickle.load(fin)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "scrolled": true,
        "id": "GN2CKEEm-MGY",
        "outputId": "9c6f8c28-f348-4dd6-a45c-e864f2e21b4a"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "10"
            ]
          },
          "execution_count": 16,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "cls_2.get_value().get_value()"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Ограничения и предостережения**\n",
        "\n",
        "- Не все объекты можно сериализовать с помощью pickle. Объекты, определённые в __main__ (например, лямбда-функции), не могут быть корректно сериализованы и десериализованы <br><br>\n",
        "- Будьте осторожны при десериализации данных из ненадежных источников. Модуль pickle не безопасен от произвольного кода, поэтому есть риск выполнения вредоносного кода <br><br>"
      ],
      "metadata": {
        "id": "etIauwCAbF-U"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0h40Udes-MGY"
      },
      "source": [
        "### `Аннотации типов`\n",
        "\n",
        "- Это способ явно указать ожидаемые типы для переменных, атрибутов класса и аргументов/возвращаемых значений функций<br><br>\n",
        "- С Python 3.5 аннотации типов стали официальной частью синтаксиса\n",
        "<br><br>\n",
        "\n",
        "Мотивация:\n",
        "- Читаемость: Улучшают понимание того, как функция или метод должен использоваться<br><br>\n",
        "- Безопасность: Инструменты статического анализа (например, mypy) могут предупредить о возможных ошибках типов<br><br>\n",
        "- Документация: Автоматически создаёт чёткую спецификацию для API<br><br>\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def greet(name: str) -> str:\n",
        "    return \"Hello, \" + name"
      ],
      "metadata": {
        "id": "a2G5eoQnPKZI"
      },
      "execution_count": 51,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "`name: str` указывает, что функция принимает строку <BR>\n",
        "`-> str` указывает, что функция возвращает строку"
      ],
      "metadata": {
        "id": "93MvUfLLS5wC"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Можно создавать элиасы на типы данных:"
      ],
      "metadata": {
        "id": "R_KCBXRJTFxO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# type Vector = list[float] since python 3.12\n",
        "Vector = list[float]\n",
        "\n",
        "def scale(scalar: float, vector: Vector) -> Vector:\n",
        "    return [scalar * num for num in vector]\n",
        "\n",
        "# passes type checking; a list of floats qualifies as a Vector.\n",
        "new_vector = scale(2.0, [1.0, -4.2, 5.4])"
      ],
      "metadata": {
        "id": "y0EARDAvRZig"
      },
      "execution_count": 56,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from typing import List\n",
        "def get_lengths(strings: List[str]) -> List[int]:\n",
        "    return [len(s) for s in strings]"
      ],
      "metadata": {
        "id": "4uIzUVegPOgx"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from typing import Dict\n",
        "def get_name_mapping(names: List[str]) -> Dict[str, int]:\n",
        "    return {name: len(name) for name in names}"
      ],
      "metadata": {
        "id": "bkmgw02sPQIQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from typing import Union\n",
        "def stringify(num: Union[int, float]) -> str:\n",
        "    return str(num)"
      ],
      "metadata": {
        "id": "UGXUKeY7TgAG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "В этом примере num может быть как целым числом (`int`), так и числом с плавающей точкой (`float`)."
      ],
      "metadata": {
        "id": "-8FC1ENmTggq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from typing import Optional\n",
        "def find_index(nums: List[int], target: int) -> Optional[int]:\n",
        "    if target in nums:\n",
        "        return nums.index(target)\n",
        "    return None"
      ],
      "metadata": {
        "id": "JEtCbDTJPUu8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "`Optional[X]` равнозначно `X | None` (или `Union[X, None]`)"
      ],
      "metadata": {
        "id": "Nxx_nE8kTPs5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from typing import Callable\n",
        "def apply_function(value: int, func: Callable[[int], str]) -> str:\n",
        "    return func(value)"
      ],
      "metadata": {
        "id": "XWsT3bGTTcQK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Здесь `func` — это функция, которая принимает `int` и возвращает `str`"
      ],
      "metadata": {
        "id": "tjNUqbWUTrGs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from typing import Iterable\n",
        "def sum_values(values: Iterable[int]) -> int:\n",
        "    return sum(values)"
      ],
      "metadata": {
        "id": "bT7QlFNHTy2y"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "В этом примере `values` — это итерируемый объект, содержащий целые числа."
      ],
      "metadata": {
        "id": "JHVOd_fTT1Rx"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Подробнее об аннотациях: https://docs.python.org/3/library/typing.html <br><br>"
      ],
      "metadata": {
        "id": "rgvk87WnQw7m"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## `Спасибо за внимание!`"
      ],
      "metadata": {
        "id": "MYBYdkSlT6Qc"
      }
    }
  ],
  "metadata": {
    "celltoolbar": "Slideshow",
    "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.8"
    },
    "colab": {
      "provenance": []
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}