ws05-OOP.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qrN7lJzWDI6V"
      },
      "source": [
        "## 0. Объектно-ориентированное программирование в Python."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "57byHXhMDI6V"
      },
      "source": [
        "Бывает, что вам нужно написать программу, которую вы запустите один раз и которая просто должна решить некоторую задачу. В этом случае все средства хороши, и можно оформлять код так, как вам удобно. Есть и другая ситуация: вам надо запрограммировать что-то, что потом вы будете использовать много раз, а ещё этот код могут захотеть редактировать другие люди. Тут надо задуматься о правильном оформлении кода.\n",
        "\n",
        "В машинном обучении главное — это модели, их обучение, применение, подсчёт качества и прочие связанные операции. Допустим, вы собрались запрограммировать обучение и применение метода k ближайших соседей и выложить в открытый доступ. Тогда будет логично потребовать от вашего кода следующее:\n",
        "1. Вы можете что-то улучшить в нём, не поменяв логику работы, и это не сломает ничего у пользователей. Будет странно, если вы, скажем, замените циклы на векторные операции в numpy, опубликуете новую версию, и любой код, зависящий от вашего, перестанет работать. Ведь суть того, что делает ваш код, не поменялась!\n",
        "2. Достаточно легко можно сделать расширенные версии kNN на основе вашего кода — например, запрограммировать kNN с весами.\n",
        "3. От пользователей скрыты все детали вашей реализации — чтобы пользоваться вашим кодом для kNN, им не нужно вникать, как вы храните данные, как ищете ближайших соседей и т.д. Они просто вызывают нужные функции, и всё работает.\n",
        "\n",
        "Объектно-ориентированное программирование (ООП) — это подход к организации кода, который (наверное) лучше всего подходит для оформления операций из машинного обучения. В его основе лежат классы и объекты, а также три важных свойства: инкапсуляция, наследование и полиморфизм. Ниже мы разберёмся со всем этим.\n",
        "\n",
        "Программист может создать класс, своеобразный чертёж, который будет определять поведение объектов этого класса: какие данные они могут хранить и какой код исполнять. После этого можно создавать объекты класса с ожидаемым поведением.\n",
        "\n",
        "Поломать голову над формальными определениями ООП можно [на вики](https://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D0%BD%D0%BE-%D0%BE%D1%80%D0%B8%D0%B5%D0%BD%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S9rhmW7rDI6W"
      },
      "source": [
        "Оглавление:\n",
        "* [Как создать класс](#Как-создать-класс)\n",
        "* [Методы](#Методы)\n",
        "* [Атрибуты класса и метод `__init__`](#Атрибуты-класса-и-метод-__init__)\n",
        "* [Magic методы](#Magic-методы)\n",
        "* [Копирование](#Копирование)\n",
        "* [getter, setter](#getter,-setter)\n",
        "* [`@staticmethod`](#@staticmethod)\n",
        "* [`@classmethod`](#@classmethod)\n",
        "* [Наследование, `super()`](#Наследование,-super())\n",
        "* [ABC — Abstract Base Classes](#ABC-—-Abstract-Base-Classes)\n",
        "* [Datacasses](#Dataclasses)\n",
        "\n",
        "<a name=\"introduction\"></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2CIa0wejDI6W"
      },
      "source": [
        "### Как создать класс"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zKeAbgxwDI6W"
      },
      "source": [
        "Класс в питоне создаётся специальной конструкцией `class`. Экземпляр (объект, instance) класса создаётся вызовом класса со скобками."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "79i_EYnmDI6W",
        "pycharm": {
          "name": "#%%\n"
        },
        "outputId": "c8ec3c5c-a5ac-4850-8f85-6464d5809769",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "__main__.DummyClass"
            ]
          },
          "metadata": {},
          "execution_count": 1
        }
      ],
      "source": [
        "class DummyClass:\n",
        "    pass\n",
        "\n",
        "\n",
        "dummy_object = DummyClass()\n",
        "\n",
        "dummy_object\n",
        "\n",
        "type(DummyClass)\n",
        "\n",
        "type(dummy_object)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "6nwBilljDI6X",
        "pycharm": {
          "name": "#%%\n"
        },
        "outputId": "44dfaac5-3a04-4784-c465-8e2b0e9dc48a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'__doc__': 'This module provides access to the mathematical functions\\ndefined by the C standard.',\n",
              " '__loader__': _frozen_importlib.BuiltinImporter,\n",
              " '__name__': 'math',\n",
              " '__package__': '',\n",
              " '__spec__': ModuleSpec(name='math', loader=<class '_frozen_importlib.BuiltinImporter'>, origin='built-in'),\n",
              " 'acos': <function math.acos>,\n",
              " 'acosh': <function math.acosh>,\n",
              " 'asin': <function math.asin>,\n",
              " 'asinh': <function math.asinh>,\n",
              " 'atan': <function math.atan>,\n",
              " 'atan2': <function math.atan2>,\n",
              " 'atanh': <function math.atanh>,\n",
              " 'ceil': <function math.ceil>,\n",
              " 'copysign': <function math.copysign>,\n",
              " 'cos': <function math.cos>,\n",
              " 'cosh': <function math.cosh>,\n",
              " 'degrees': <function math.degrees>,\n",
              " 'e': 2.718281828459045,\n",
              " 'erf': <function math.erf>,\n",
              " 'erfc': <function math.erfc>,\n",
              " 'exp': <function math.exp>,\n",
              " 'expm1': <function math.expm1>,\n",
              " 'fabs': <function math.fabs>,\n",
              " 'factorial': <function math.factorial>,\n",
              " 'floor': <function math.floor>,\n",
              " 'fmod': <function math.fmod>,\n",
              " 'frexp': <function math.frexp>,\n",
              " 'fsum': <function math.fsum>,\n",
              " 'gamma': <function math.gamma>,\n",
              " 'gcd': <function math.gcd>,\n",
              " 'hypot': <function math.hypot>,\n",
              " 'inf': inf,\n",
              " 'isclose': <function math.isclose>,\n",
              " 'isfinite': <function math.isfinite>,\n",
              " 'isinf': <function math.isinf>,\n",
              " 'isnan': <function math.isnan>,\n",
              " 'ldexp': <function math.ldexp>,\n",
              " 'lgamma': <function math.lgamma>,\n",
              " 'log': <function math.log>,\n",
              " 'log10': <function math.log10>,\n",
              " 'log1p': <function math.log1p>,\n",
              " 'log2': <function math.log2>,\n",
              " 'modf': <function math.modf>,\n",
              " 'nan': nan,\n",
              " 'pi': 3.141592653589793,\n",
              " 'pow': <function math.pow>,\n",
              " 'radians': <function math.radians>,\n",
              " 'remainder': <function math.remainder>,\n",
              " 'sin': <function math.sin>,\n",
              " 'sinh': <function math.sinh>,\n",
              " 'sqrt': <function math.sqrt>,\n",
              " 'tan': <function math.tan>,\n",
              " 'tanh': <function math.tanh>,\n",
              " 'tau': 6.283185307179586,\n",
              " 'trunc': <function math.trunc>}"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ],
      "source": [
        "import math\n",
        "vars(DummyClass)\n",
        "DummyClass.__dict__\n",
        "vars(math)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DyCg5UmdDI6X"
      },
      "source": [
        "Названия классов в питоне пишутся CamelCase, названия функций/объектов/переменных snake_case."
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(object)"
      ],
      "metadata": {
        "id": "rxrSNZQZ0ZYD",
        "outputId": "5d927d44-eab5-487f-9ada-af444404df0f",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'object'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-iCFJYh0DI6X"
      },
      "source": [
        "### Методы"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ReOX6JVeDI6X"
      },
      "source": [
        "Классы могут определять функции, которые можно будет вызывать от их объектов. Такие функции называются методами. В любом (почти) методе первым аргументом является self. В него будет передан сам объект, от которого вызывается метод.\n",
        "\n",
        "Наш класс не особо полезен, так как ничего не делает. Давайте напишем класс с методом. Вызов методов происходит через оператор `.`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "id": "uIe4LRcPDI6X",
        "pycharm": {
          "name": "#%%\n"
        },
        "outputId": "00f788d6-2671-474c-d190-4fb67908cc46",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 374
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "abc\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-18-fd0fa794ef2a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     29\u001b[0m \u001b[0mgoose_printer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprint_field\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     30\u001b[0m \u001b[0;32mdel\u001b[0m \u001b[0mgoose_printer\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---> 31\u001b[0;31m \u001b[0mgoose_printer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprint_field\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[1;32m     32\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     33\u001b[0m \u001b[0;31m# GoosePrinter.print_goose()\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-18-fd0fa794ef2a>\u001b[0m in \u001b[0;36mprint_field\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m     19\u001b[0m         \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mGOOSE\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     20\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mprint_field\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;32m---> 21\u001b[0;31m         \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfield\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     22\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     23\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mAttributeError\u001b[0m: 'GoosePrinter' object has no attribute 'field'"
          ]
        }
      ],
      "source": [
        "GOOSE_GLOBAL = \"\"\"\n",
        "░░░░░▄▀▀▀▄░░░░░░░░\n",
        "▄███▀░◐░░░▌░░░░░░░\n",
        "░░░░▌░░░░░▐░░░░░░░\n",
        "░░░░▐░░░░░▐░░░░░░░\n",
        "░░░░▌░░░░░▐▄▄░░░░░\n",
        "░░░░▌░░░░▄▀▒▒▀▀▀▀▄\n",
        "░░░▐░░░░▐▒▒▒▒▒▒▒▒▀▀▄\n",
        "░░░▐░░░░▐▄▒▒▒▒▒▒▒▒▒▒▀▄\n",
        "░░░░▀▄░░░░▀▄▒▒▒▒▒▒▒▒▒▒▀▄\n",
        "░░░░░░▀▄▄▄▄▄█▄▄▄▄▄▄▄▄▄▄▄▀▄\n",
        "░░░░░░░░░░░▌▌▌▌░░░░░\n",
        "░░░░░░░░░░░▌▌░▌▌░░░░░\n",
        "░░░░░░░░░▄▄▌▌▄▌▌░░░░░\"\"\"\n",
        "\n",
        "class GoosePrinter:\n",
        "    GOOSE = GOOSE_GLOBAL\n",
        "    def print_goose(self) -> None:\n",
        "        print(self.GOOSE)\n",
        "    def print_field(self):\n",
        "        print(self.field)\n",
        "\n",
        "\n",
        "goose_printer = GoosePrinter()\n",
        "\n",
        "# GoosePrinter.print_goose()\n",
        "\n",
        "goose_printer.field = \"abc\"\n",
        "goose_printer.print_field()\n",
        "del goose_printer.field\n",
        "goose_printer.print_field()\n",
        "\n",
        "# GoosePrinter.print_goose()\n",
        "\n",
        "goose_printer.print_goose()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "id": "WJeeqPgiDI6Y",
        "pycharm": {
          "name": "#%%\n"
        },
        "outputId": "bda126f9-7e2f-48de-cd65-94590575d67c",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "mappingproxy({'__class__': <attribute '__class__' of 'object' objects>,\n",
              "              '__delattr__': <slot wrapper '__delattr__' of 'object' objects>,\n",
              "              '__dir__': <method '__dir__' of 'object' objects>,\n",
              "              '__doc__': 'The most base type',\n",
              "              '__eq__': <slot wrapper '__eq__' of 'object' objects>,\n",
              "              '__format__': <method '__format__' of 'object' objects>,\n",
              "              '__ge__': <slot wrapper '__ge__' of 'object' objects>,\n",
              "              '__getattribute__': <slot wrapper '__getattribute__' of 'object' objects>,\n",
              "              '__gt__': <slot wrapper '__gt__' of 'object' objects>,\n",
              "              '__hash__': <slot wrapper '__hash__' of 'object' objects>,\n",
              "              '__init__': <slot wrapper '__init__' of 'object' objects>,\n",
              "              '__init_subclass__': <method '__init_subclass__' of 'object' objects>,\n",
              "              '__le__': <slot wrapper '__le__' of 'object' objects>,\n",
              "              '__lt__': <slot wrapper '__lt__' of 'object' objects>,\n",
              "              '__ne__': <slot wrapper '__ne__' of 'object' objects>,\n",
              "              '__new__': <function object.__new__>,\n",
              "              '__reduce__': <method '__reduce__' of 'object' objects>,\n",
              "              '__reduce_ex__': <method '__reduce_ex__' of 'object' objects>,\n",
              "              '__repr__': <slot wrapper '__repr__' of 'object' objects>,\n",
              "              '__setattr__': <slot wrapper '__setattr__' of 'object' objects>,\n",
              "              '__sizeof__': <method '__sizeof__' of 'object' objects>,\n",
              "              '__str__': <slot wrapper '__str__' of 'object' objects>,\n",
              "              '__subclasshook__': <method '__subclasshook__' of 'object' objects>})"
            ]
          },
          "metadata": {},
          "execution_count": 21
        }
      ],
      "source": [
        "vars(GoosePrinter)\n",
        "\n",
        "vars(object)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t2qmFba2DI6Y"
      },
      "source": [
        "Обратите внимание, что мы вызвали метод без аргументов, хотя в сигнатуре есть аргумент `self`. `self` подаётся \"автоматически\"."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E21HgeRADI6Y"
      },
      "source": [
        "**NB:** первый аргумент можно назвать как угодно, не обязательно `self`. Но не нужно."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p_jqonyODI6Y"
      },
      "source": [
        "### Атрибуты класса и метод `__init__`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vZVJPZcIDI6Y"
      },
      "source": [
        "Помимо методов у объектов класса могут быть атрибуты &mdash; переменные. К ним так же можно обращаться через `.`, а создавать внутри класса их как раз можно при помощи вышеупомянутого `self`.\n",
        "\n",
        "Любой класс может определить метод `__init__` &mdash; конструктор: он выполняется при создании объекта класса, а его аргументы передаются в скобках после названия класса во время создания. Обычно именно в нём и задаются атрибуты класса.\n",
        "\n",
        "Давайте напишем класс целочисленной точки на плоскости, объекты которого будут уметь выводить свои координаты:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BY3N2D_8DI6Z",
        "outputId": "4eb579a3-a36d-4b3d-9f7a-99abfef06a72",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(3, 5)\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "mappingproxy({'__dict__': <attribute '__dict__' of 'Point2D' objects>,\n",
              "              '__doc__': '\\n    A point in 2D space\\n    :param x: x coordinate\\n    :param y: y coordinate\\n    ',\n",
              "              '__init__': <function __main__.Point2D.__init__>,\n",
              "              '__module__': '__main__',\n",
              "              '__weakref__': <attribute '__weakref__' of 'Point2D' objects>,\n",
              "              'first_coord': <function __main__.Point2D.first_coord>,\n",
              "              'print_coords': <function __main__.Point2D.print_coords>})"
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ],
      "source": [
        "class Point2D:\n",
        "    \"\"\"\n",
        "    A point in 2D space\n",
        "    :param x: x coordinate\n",
        "    :param y: y coordinate\n",
        "    \"\"\"\n",
        "    def __init__(self, x: int, y: int) -> None:\n",
        "        # Создаём атрибуты и присваиваем им переданные значения координат\n",
        "        self.x = x\n",
        "        self.y = y\n",
        "\n",
        "    def print_coords(self) -> None:\n",
        "        # Выводим координаты, обращаясь к ним через self с точкой\n",
        "        print(f\"({self.x}, {self.y})\")\n",
        "\n",
        "    def first_coord(self) -> int:\n",
        "        return x\n",
        "\n",
        "\n",
        "point = Point2D(3, 5)\n",
        "# del point.x\n",
        "point.print_coords()\n",
        "\n",
        "vars(Point2D)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mkSztPH2DI6Z"
      },
      "source": [
        "Мы задаём координаты в конструкторе, присваивая их `self` через точку, и потом можем использовать их в методе."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AgksAiRIDI6Z"
      },
      "source": [
        "### Magic методы"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "42aEngaBDI6Z"
      },
      "source": [
        "В питоне у классов могут быть так называемые магические методы. Это методы, которые может определить класс, которые позволяют ему действовать определённым образом. Обычно они не вызываются напрямую.\n",
        "\n",
        "Все магические методы отличаются тем, что их названия начинаются и заканчиваются на двойные подчёркивания (`__method__`). С одним таким мы уже познакомились &mdash; это метод `__init__`, который вызывается при создании объекта класса. Давайте посмотрим, какие ещё бывают магические методы:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XHQEELK_DI6a"
      },
      "source": [
        "#### \\_\\_str\\_\\_ и \\_\\_repr\\_\\_ [(Документация)](https://docs.python.org/3/reference/datamodel.html#object.__repr__)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uwNcaox3DI6a"
      },
      "source": [
        "Методы `__str__` и `__repr__` позволяют добавить текстовое описание к объекту класса. Они возвращают строку, описывающую объект.\n",
        "\n",
        "Метод `__str__` должен возвращать строку, описывающую объект простым, понятным, читаемым образом, а метод `__repr__` предназаначен больше для дебага и должен возвращать всю информацию об объекте, а его вывод должен в идеале быть исполняемым кодом, с помощью которого можно было бы создать такой же объект.\n",
        "\n",
        "Метод `__str__` вызывается, например, когда мы принтим объект или берём `str` от него (например, `str(point)`).\n",
        "Метод `__repr__` вызывается, например, когда мы просто выводим объект в консоли или берём `repr` от него.\n",
        "Если `__str__` не определён, по дефолту его роль будет играть `__repr__`.\n",
        "\n",
        "Давайте избавимся от метода `print_coords` и добавим нашим точкам хорошее форматирование:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 48,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "emSxWDoPDI6a",
        "outputId": "593dc5b5-4851-42c1-8b11-18e1aecef698",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "delete A 2D point with coordinates (5, 5)\n",
            "Некрасивая точка: A 2D point with coordinates (5, 5)\n",
            "A 2D point with coordinates (5, 5)\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Point2D(3, 4)"
            ]
          },
          "metadata": {},
          "execution_count": 48
        }
      ],
      "source": [
        "# Для начала убедимся, что по дефолту наши точки не умеют красиво печататься:\n",
        "print(f\"Некрасивая точка: {Point2D(5, 5)}\")\n",
        "\n",
        "class Point2D:\n",
        "    \"\"\"\n",
        "    A point in 2D space\n",
        "    :param x: x coordinate\n",
        "    :param y: y coordinate\n",
        "    \"\"\"\n",
        "    def __init__(self, x: int, y: int) -> None:\n",
        "        # Создаём атрибуты и присваиваем им переданные значения координат\n",
        "        self.x = x\n",
        "        self.y = y\n",
        "\n",
        "    def __repr__(self) -> str:\n",
        "        return f\"Point2D({self.x}, {self.y})\"\n",
        "\n",
        "    def __str__(self) -> str:\n",
        "        return f\"A 2D point with coordinates ({self.x}, {self.y})\"\n",
        "\n",
        "    def __deepcopy__(self):\n",
        "        pass\n",
        "\n",
        "# Посмотрим, что у нас есть теперь:\n",
        "print(Point2D(5, 5))\n",
        "Point2D(3, 4)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 26,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fVbzdcZvDI6a",
        "outputId": "9388d4ee-a692-4c31-a3c5-714d2c9f84a7",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Point2D(10, 11)"
            ]
          },
          "metadata": {},
          "execution_count": 26
        }
      ],
      "source": [
        "p = Point2D(10, 11)\n",
        "p"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 27,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 200
        },
        "id": "uV6iL3PBDI6a",
        "outputId": "e16444dd-94fc-4388-d44e-34292d272443",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "A 2D point with coordinates (10, 11)\n"
          ]
        },
        {
          "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-27-6a46ff8d6649>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mp\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mp\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mPoint2D\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\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: unsupported operand type(s) for +: 'Point2D' and 'Point2D'"
          ]
        }
      ],
      "source": [
        "print(p)\n",
        "p + Point2D(1, 1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nSeeQGQ_DI6b"
      },
      "source": [
        "Обратите внимание, что `__str__` вызвался, когда мы запринтили объект, а `__repr__`, когда мы вывели его в конце ячейки."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HlTeTyJwDI6b"
      },
      "source": [
        "#### \\_\\_add\\_\\_, \\_\\_sub\\_\\_, \\_\\_mul\\_\\_, \\_\\_truediv\\_\\_, etc. [(Документация)](https://docs.python.org/3/reference/datamodel.html#emulating-numeric-types)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DR7FklQdDI6b"
      },
      "source": [
        "Методы `__add__`, `__sub__`, `__mul__`, `__truediv__` позовляют добавить классу функционал сложения, вычитания, умножения, деления и так далее, (операторы `+`, `-`, `*`, `/`, etc.). Они вызываются от левого операнда и применяются к правому, возвращая результат. Давайте научим наши точки складываться и вычитаться:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 28,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BYA5_43VDI6b",
        "outputId": "f1031dff-2bc8-4576-d37b-767e3b568ce7",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "A 2D point with coordinates (7, 12)\n",
            "A 2D point with coordinates (-1, -2)\n"
          ]
        }
      ],
      "source": [
        "class Point2D:\n",
        "    \"\"\"\n",
        "    A point in 2D space\n",
        "    :param x: x coordinate\n",
        "    :param y: y coordinate\n",
        "    \"\"\"\n",
        "    def __init__(self, x: int, y: int) -> None:\n",
        "        # Создаём атрибуты и присваиваем им переданные значения координат\n",
        "        self.x = x\n",
        "        self.y = y\n",
        "\n",
        "    def __repr__(self) -> str:\n",
        "        return f\"Point2D({self.x}, {self.y})\"\n",
        "\n",
        "    def __str__(self) -> str:\n",
        "        return f\"A 2D point with coordinates ({self.x}, {self.y})\"\n",
        "\n",
        "    def __add__(self, other: Point2D) -> Point2D:\n",
        "        return Point2D(self.x + other.x, self.y + other.y)\n",
        "\n",
        "    def __sub__(self, other: Point2D) -> Point2D:\n",
        "        return Point2D(self.x - other.x, self.y - other.y)\n",
        "\n",
        "\n",
        "print(Point2D(3, 5) + Point2D(4, 7))\n",
        "print(Point2D(3, 5) - Point2D(4, 7))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BcHy0-BNDI6c"
      },
      "source": [
        "У каждого из вышеописанных методов есть так же версия \"i\" в начале, отвечающая за операцию с присвоением (`__iadd__` &mdash; `+=`, `__isub__` &mdash; `-=`, etc.)\n",
        "\n",
        "В принципе, операции с присовением будут работать и так, питон сам выведет их из обычных операций. Но на самом деле они не будут модифицировать объект in-place, а будут возвращать новый объект и присваивать его переменной:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 32,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eJHiiwi5DI6c",
        "outputId": "b6fddf21-8f7e-4b87-8048-61fff8039756",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "139914472652560\n",
            "139914472652560\n",
            "A 2D point with coordinates (4, 4)\n"
          ]
        }
      ],
      "source": [
        "a = Point2D(3, 3)\n",
        "print(id(a))\n",
        "\n",
        "a += Point2D(1, 1)\n",
        "print(id(a))\n",
        "print(a)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rBhIpwPCDI6c"
      },
      "source": [
        "В данном случае это скорее правильное поведение, но давайте для практики добавим в наш класс эти методы:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 33,
      "metadata": {
        "id": "8RkpFz-CDI6c",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [],
      "source": [
        "class Point2D:\n",
        "    \"\"\"\n",
        "    A point in 2D space\n",
        "    :param x: x coordinate\n",
        "    :param y: y coordinate\n",
        "    \"\"\"\n",
        "    def __init__(self, x: int, y: int) -> None:\n",
        "        # Создаём атрибуты и присваиваем им переданные значения координат\n",
        "        self.x = x\n",
        "        self.y = y\n",
        "\n",
        "    def __repr__(self) -> str:\n",
        "        return f\"Point2D({self.x}, {self.y})\"\n",
        "\n",
        "    def __str__(self) -> str:\n",
        "        return f\"A 2D point with coordinates ({self.x}, {self.y})\"\n",
        "\n",
        "    def __add__(self, other: Point2D) -> Point2D:\n",
        "        return Point2D(self.x + other.x, self.y + other.y)\n",
        "\n",
        "    def __sub__(self, other: Point2D) -> Point2D:\n",
        "        return Point2D(self.x - other.x, self.y - other.y)\n",
        "\n",
        "    def __iadd__(self, other: Point2D) -> Point2D:\n",
        "        self.x *= other.x\n",
        "        self.y += other.y\n",
        "        return self\n",
        "\n",
        "    def __isub__(self, other: Point2D) -> Point2D:\n",
        "        self.x -= other.x\n",
        "        self.y -= other.y\n",
        "        return self"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 35,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JcPagzzgDI6c",
        "outputId": "4a1f8b09-7747-4753-8f57-b4b33d944199",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "139914472325200\n",
            "139914472325200\n",
            "A 2D point with coordinates (6, 5)\n",
            "139914472325200\n",
            "A 2D point with coordinates (12, 7)\n",
            "139914472325264\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Point2D(17, 13)"
            ]
          },
          "metadata": {},
          "execution_count": 35
        }
      ],
      "source": [
        "a = Point2D(3, 3)\n",
        "print(id(a))\n",
        "\n",
        "a += Point2D(2, 2)\n",
        "print(id(a))\n",
        "print(a)\n",
        "\n",
        "a += Point2D(2, 2)\n",
        "print(id(a))\n",
        "print(a)\n",
        "\n",
        "a = a + Point2D(5, 6)\n",
        "print(id(a))\n",
        "a"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jqf5IscXDI6d"
      },
      "source": [
        "Теперь при использовании `+=` мы остаёмся с тем же объектом."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "B6DWpUovDI6d"
      },
      "source": [
        "#### \\_\\_eq\\_\\_, \\_\\_ne\\_\\_, \\_\\_lt\\_\\_, \\_\\_le\\_\\_, \\_\\_gt\\_\\_, \\_\\_ge\\_\\_,  [(Документация)](https://docs.python.org/3/reference/datamodel.html#object.__lt__)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MaIJiWD0DI6d"
      },
      "source": [
        "По умолчанию объекты классов в питоне не имеют порядка и сравниваются на равенство при помощи `is`.\n",
        "Таким образом, две точки будут равны друг другу только тогда когда они представляют один и тот же объект в памяти:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 36,
      "metadata": {
        "id": "47czREhWDI6d",
        "pycharm": {
          "name": "#%%\n"
        },
        "outputId": "fc8d3169-149a-4c93-da4c-2a3284b0eb56",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(False, True)"
            ]
          },
          "metadata": {},
          "execution_count": 36
        }
      ],
      "source": [
        "a = Point2D(1, 1)\n",
        "b = Point2D(1, 1)\n",
        "\n",
        "a == b, a == a"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cQZaiz_fDI6d"
      },
      "source": [
        "Методы `__eq__`, `__ne__`, `__lt__`, `__le__`, `__gt__`, `__ge__` позволяют задать правила сравнения для объектов класса.\n",
        "\n",
        "Давайте научим наши точки сравниваться:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 45,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 426
        },
        "id": "NwaGlmg2DI6d",
        "outputId": "1ea44a6e-3aa1-4f69-e96e-2a72a4c4807e",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "delete A 2D point with coordinates (1, 1)\n",
            "delete A 2D point with coordinates (1, 1)\n",
            "True\n",
            "delete A 2D point with coordinates (1, 1)\n",
            "delete A 2D point with coordinates (1, 1)\n",
            "False\n",
            "delete A 2D point with coordinates (1, 1)\n",
            "delete A 2D point with coordinates (1, 2)\n",
            "False\n",
            "delete A 2D point with coordinates (1, 1)\n",
            "delete A 2D point with coordinates (1, 2)\n",
            "True\n",
            "delete A 2D point with coordinates (10, 10)\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-45-d49e642a87b8>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     46\u001b[0m \u001b[0mp\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mPoint2D\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     47\u001b[0m \u001b[0;32mdel\u001b[0m \u001b[0mp\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 48\u001b[0;31m \u001b[0mp\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m: name 'p' is not defined"
          ]
        }
      ],
      "source": [
        "class Point2D:\n",
        "    \"\"\"\n",
        "    A point in 2D space\n",
        "    :param x: x coordinate\n",
        "    :param y: y coordinate\n",
        "    \"\"\"\n",
        "    def __init__(self, x: int, y: int) -> None:\n",
        "        # Создаём атрибуты и присваиваем им переданные значения координат\n",
        "        self.x = x\n",
        "        self.y = y\n",
        "\n",
        "    def __repr__(self) -> str:\n",
        "        return f\"Point2D({self.x}, {self.y})\"\n",
        "\n",
        "    def __str__(self) -> str:\n",
        "        return f\"A 2D point with coordinates ({self.x}, {self.y})\"\n",
        "\n",
        "    def __add__(self, other: Point2D) -> Point2D:\n",
        "        return Point2D(self.x + other.x, self.y + other.y)\n",
        "\n",
        "    def __sub__(self, other: Point2D) -> Point2D:\n",
        "        return Point2D(self.x - other.x, self.y - other.y)\n",
        "\n",
        "    def __iadd__(self, other: Point2D) -> Point2D:\n",
        "        self.x += other.x\n",
        "        self.y += other.y\n",
        "        return self\n",
        "\n",
        "    def __isub__(self, other: Point2D) -> Point2D:\n",
        "        self.x -= other.x\n",
        "        self.y -= other.y\n",
        "        return self\n",
        "\n",
        "    def __eq__(self, other: Point2D) -> Point2D:\n",
        "        return self.x == other.x and self.y == other.y\n",
        "\n",
        "    def __del__(self):\n",
        "        print('delete', end=' ')\n",
        "        print(self)\n",
        "\n",
        "print(Point2D(1, 1) == Point2D(1, 1))\n",
        "print(Point2D(1, 1) != Point2D(1, 1))\n",
        "print(Point2D(1, 1) == Point2D(1, 2))\n",
        "print(Point2D(1, 1) != Point2D(1, 2))\n",
        "\n",
        "p = Point2D(10, 10)\n",
        "del p\n",
        "p"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I1pqo2nLDI6e"
      },
      "source": [
        "Обратите внимание, что когда мы определили `__eq__` (==) для сравнения, `__ne__` (!=) вывелся автоматически. Однако, это исключение. Если мы, например, определим ещё и `__gt__` (>), операция `__le__` (<=) сама не выведется.\n",
        "\n",
        "**NB**: Если вам хочется написать одну операцию, чтобы остальные вывелись автоматически, используйте декоратор [`functools.total_ordering`](https://docs.python.org/3/library/functools.html#functools.total_ordering)\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6jWMexRKDI6e"
      },
      "source": [
        "Кроме описанных в питоне есть ещё великое множество магических методов, которые способны осуществить примерно любое поведение, которое вы видели в питоне. Все их можно посмотреть [в документации](https://docs.python.org/3/reference/datamodel.html#special-method-names) или нагуглить.\n",
        "\n",
        "Из полезных можно отметить:\n",
        "* `__new__` и `__del__` &mdash; создание и удаление объекта.\n",
        "* `__len__` &mdash; возвращение длины объекта (например, контейнера). Используется функцией `len`.\n",
        "* `__getitem__`, `__setitem__` &mdash; индексация квадратными скобками.\n",
        "* `__getattr__`, `__setattr__` &mdash; обращение к атрибутам по точке.\n",
        "* `__iter__` &mdash; возвращает итератор, проходящий по объекту. Используется, например, for.\n",
        "* `__next__` &mdash; возвращает следующее состояние итератора\n",
        "* `__nonzero__` &mdash; определяет поведение функции `bool` на объекте.\n",
        "* `__contains__` &mdash; определяет поведение оператора `in` (полезно для контейнеров)\n",
        "* `__call__` &mdash; вызывается, когда объект класса вызывается со скобками (как функция). Позволяет сделать объекты класса callable.\n",
        "* `__copy__`, `__deepcopy__` &mdash; определяют, как объект класса копируется."
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a = [0]\n",
        "bool(a)"
      ],
      "metadata": {
        "id": "Uk4jHW273mWe",
        "outputId": "99f6d816-197e-4af2-9bd6-2fb07d160df4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 47,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 47
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kQrOYapCDI6e"
      },
      "source": [
        "### Копирование"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "M5ta9BYhDI6e"
      },
      "source": [
        "Переменные в питоне всегда хранят ссылку на объект.  Если мы присвоим объект нашего класса двум разным переменным, они обе будут хранить один и тот же объект и \"меняться\" вместе:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 49,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zxClRc39DI6e",
        "outputId": "f6b5fb18-f10c-4eea-9b64-0d150721cc62",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "A 2D point with coordinates (3, 4)\n",
            "A 2D point with coordinates (-1, 4)\n",
            "139914441664656 139914441664656\n"
          ]
        }
      ],
      "source": [
        "a = Point2D(3, 4)\n",
        "print(a)\n",
        "\n",
        "b = a\n",
        "b.x = -1\n",
        "\n",
        "print(a)\n",
        "\n",
        "print(id(a), id(b))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OpdmkkM1DI6e"
      },
      "source": [
        "Мы поменяли значение в переменной `b`, но значение в `a` тоже поменялось, потому что они ссылаются на один и тот же объект.\n",
        "\n",
        "Чтобы избежать этого недоразумения в питоне существует модуль `copy` и соответствующая функция:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 51,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FHRLkZACDI6f",
        "outputId": "4432d8c5-cf39-41c3-efb6-05d93424dd6b",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "A 2D point with coordinates (3, 4)\n",
            "A 2D point with coordinates (3, 4)\n",
            "A 2D point with coordinates (-1, 4)\n",
            "139914472327056 139914441792720\n"
          ]
        }
      ],
      "source": [
        "import copy\n",
        "\n",
        "a = Point2D(3, 4)\n",
        "print(a)\n",
        "\n",
        "b = copy.copy(a)\n",
        "b.x = -1\n",
        "\n",
        "print(a)\n",
        "print(b)\n",
        "\n",
        "print(id(a), id(b))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2hjToR63DI6g"
      },
      "source": [
        "Однако и это не спасёт нас, если в объекте нашего класса снова хранятся изменяемые переменные (например, списки). В таком случае нам понадобится функция `deepcopy`, которая полностью скопирует как сам объект класса, так и всё внутри него, по сути действуя рекурсивно.\n",
        "\n",
        "Продемонстрируем это на новом классе `Student`:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 67,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Gcw90je9DI6h",
        "outputId": "764eba29-214f-4ccb-cc03-5e1bfda414b9",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "До изменений\n",
            "Student('Ваня', ['Линал', 'Алгосы', 'Машинное обучение'])\n",
            "\n",
            "Изменения в deepcopy\n",
            "Student('Катя', ['Матан', 'Алгосы', 'Машинное обучение', 'This is deepcopy'])\n",
            "Student('Ваня', ['Линал', 'Алгосы', 'Машинное обучение'])\n",
            "\n",
            "Изменения в copy\n",
            "Student('Лиза', ['Экономика', 'Алгосы', 'Машинное обучение'])\n",
            "Student('Ваня', ['Экономика', 'Алгосы', 'Машинное обучение'])\n",
            "\n",
            "Изменения в простом присваивании\n",
            "Student('Лёша', ['Алгебра', 'Алгосы', 'Машинное обучение'])\n",
            "Student('Лёша', ['Алгебра', 'Алгосы', 'Машинное обучение'])\n"
          ]
        }
      ],
      "source": [
        "from typing import Iterable\n",
        "import copy\n",
        "\n",
        "class Student1:\n",
        "    def __init__(self, name: str, classes: int) -> None:\n",
        "      self.name = name\n",
        "      self.classes = classes\n",
        "      self.classes.append('This is deepcopy')\n",
        "\n",
        "    def __repr__(self) -> str:\n",
        "        return f\"Student({repr(self.name)}, {repr(self.classes)})\"\n",
        "\n",
        "class Student:\n",
        "    \"\"\"\n",
        "    A class representing student along with his name and classes he/she takes\n",
        "    :param name: name of the student\n",
        "    :param classes: iterable of strings with names of classes\n",
        "    \"\"\"\n",
        "    def __init__(self, name: str, classes: int) -> None:\n",
        "        self.name = name\n",
        "        self.classes = classes\n",
        "\n",
        "    def __repr__(self) -> str:\n",
        "        return f\"Student({repr(self.name)}, {repr(self.classes)})\"\n",
        "    \n",
        "    def __deepcopy__(self, arg):\n",
        "      return Student1(self.name, copy.copy(self.classes))\n",
        "\n",
        "student = Student(\"Ваня\", [\"Линал\", \"Алгосы\", \"Машинное обучение\"])\n",
        "student_deepcopy = copy.deepcopy(student)\n",
        "student_copy = copy.copy(student)\n",
        "student_naive = student\n",
        "\n",
        "# Распечатаем студента\n",
        "print(\"До изменений\")\n",
        "print(student)\n",
        "\n",
        "student_deepcopy.name = \"Катя\"\n",
        "student_deepcopy.classes[0] = \"Матан\"\n",
        "print(\"\\nИзменения в deepcopy\")\n",
        "print(f\"{student_deepcopy}\")\n",
        "print(f\"{student}\")\n",
        "\n",
        "student_copy.name = \"Лиза\"\n",
        "student_copy.classes[0] = \"Экономика\"\n",
        "print(\"\\nИзменения в copy\")\n",
        "print(f\"{student_copy}\")\n",
        "print(f\"{student}\")\n",
        "\n",
        "student_naive.name = \"Лёша\"\n",
        "student_naive.classes[0] = \"Алгебра\"\n",
        "print(\"\\nИзменения в простом присваивании\")\n",
        "print(f\"{student_naive}\")\n",
        "print(f\"{student}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qarYv69kDI6h"
      },
      "source": [
        "Как видим, если мы используем просто `copy`, имя студента действительно не меняется в изначальной переменной `student`, потому что соответствующий атрибут `name` был скопирован. А вот список дисциплин меняется, потому что `copy` скопировал в новый объект **ссылку** на этот список, и мы обращаемся к ней из обоих студентов. `deepcopy` позволяет избежать этой проблемы, потому что он создаст новый список."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vIG6mKzPDI6i"
      },
      "source": [
        "### getter, setter"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p2Z_flzyDI6i"
      },
      "source": [
        "Иногда нам хочется, чтобы чтение или установка атрибута объекта сопровождались какой-нибудь логикой, будь то проверка или ещё что. Предположим, мы создаём класс градусника:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 68,
      "metadata": {
        "id": "RhYlU8aTDI6i",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [],
      "source": [
        "class Thermometer:\n",
        "    \"\"\"\n",
        "    Thermometer containing temperature in Celsius\n",
        "    :param temperature: temperature to contain\n",
        "    \"\"\"\n",
        "    def __init__(self, temperature: float) -> None:\n",
        "        self.temperature = temperature"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K-AoC_qBDI6i"
      },
      "source": [
        "У такого класса есть проблема: мы можем присовить ему температуру ниже возможного минимума:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 69,
      "metadata": {
        "id": "o26v7yqcDI6i",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [],
      "source": [
        "thermometer = Thermometer(10.)\n",
        "thermometer.temperature = -100000."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 182
        },
        "id": "D0L0UQuN7Vff",
        "outputId": "98456ac7-50bc-4cfc-e2be-97cb02b3c7ed"
      },
      "outputs": [
        {
          "ename": "AttributeError",
          "evalue": "ignored",
          "output_type": "error",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-26-2d7c46d9349b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdel\u001b[0m \u001b[0mthermometer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtemperature\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mthermometer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtemperature\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m: 'Thermometer' object has no attribute 'temperature'"
          ]
        }
      ],
      "source": [
        "del thermometer.temperature\n",
        "thermometer.temperature"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AiqQN1AsDI6j"
      },
      "source": [
        "Мы могли бы решить эту проблему, добавив специальную функцию set_temperature, и сказав, что установка температуры должна происходить только через неё:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 70,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 322
        },
        "id": "QuXTv52-DI6j",
        "outputId": "26f455e5-e74c-4c4c-e8dc-4f3bc35bb4f4",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [
        {
          "output_type": "error",
          "ename": "ValueError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-70-7f9a2280ed68>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     14\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     15\u001b[0m \u001b[0mthermometer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mThermometer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m10.\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 16\u001b[0;31m \u001b[0mthermometer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_temperature\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m100000.\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m<ipython-input-70-7f9a2280ed68>\u001b[0m in \u001b[0;36mset_temperature\u001b[0;34m(self, value)\u001b[0m\n\u001b[1;32m     10\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mset_temperature\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mfloat\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     11\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mvalue\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0mThermometer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mMINIMAL_TEMPERATURE\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 12\u001b[0;31m             \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"Temperature cannot be less than {Thermometer.MINIMAL_TEMPERATURE}\"\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     13\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtemperature\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     14\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mValueError\u001b[0m: Temperature cannot be less than -273.15"
          ]
        }
      ],
      "source": [
        "class Thermometer:\n",
        "    \"\"\"\n",
        "    Thermometer containing temperature in Celsius\n",
        "    :param temperature: temperature to contain\n",
        "    \"\"\"\n",
        "    MINIMAL_TEMPERATURE = -273.15\n",
        "    def __init__(self, temperature: float) -> None:\n",
        "        self.set_temperature(temperature)\n",
        "\n",
        "    def set_temperature(self, value: float) -> None:\n",
        "        if value < Thermometer.MINIMAL_TEMPERATURE:\n",
        "            raise ValueError(f\"Temperature cannot be less than {Thermometer.MINIMAL_TEMPERATURE}\")\n",
        "        self.temperature = value\n",
        "\n",
        "thermometer = Thermometer(10.)\n",
        "thermometer.set_temperature(-100000.)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lQuzjP4UDI6j"
      },
      "source": [
        "С таким решением, во-первых, мы теряем удобное присвивание по имени атрибута, а во-вторых, весь код, который до этого использовал temperature напрямую теперь будет работать неправильно"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S2l1LpJoDI6j"
      },
      "source": [
        "Чтобы избежать этих проблем в python есть декоратор `@property`: он позволяет превратить функцию в атрибут и определить поведение при установке и чтения атрибута:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 76,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nd_OCxFJDI6j",
        "outputId": "f1d290ee-97e3-475d-9d73-27714f0f973f",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "20\n",
            "20\n"
          ]
        }
      ],
      "source": [
        "class Thermometer:\n",
        "    \"\"\"\n",
        "    Thermometer containing temperature in Celsius\n",
        "    :param temperature: temperature to contain\n",
        "    \"\"\"\n",
        "    MINIMAL_TEMPERATURE = -273.15\n",
        "    def __init__(self, temperature: float) -> None:\n",
        "        self.temperature = temperature\n",
        "\n",
        "    @property\n",
        "    def temperature(self):\n",
        "        return self._temperature\n",
        "\n",
        "    @temperature.setter\n",
        "    def temperature(self, value: float) -> None:\n",
        "        if value < Thermometer.MINIMAL_TEMPERATURE:\n",
        "            raise ValueError(f\"Temperature cannot be less than {Thermometer.MINIMAL_TEMPERATURE}\")\n",
        "        self._temperature = value\n",
        "\n",
        "    @temperature.deleter\n",
        "    def temperature(self):\n",
        "        pass\n",
        "\n",
        "    # @temperature.getter\n",
        "    # def temperature(self) -> float:\n",
        "    #     return self._temperature\n",
        "\n",
        "thermometer = Thermometer(10.)\n",
        "thermometer.temperature = 20\n",
        "print(thermometer.temperature)\n",
        "del thermometer.temperature\n",
        "print(thermometer.temperature)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "veHOi3aoDI6j"
      },
      "source": [
        "Разберёмся, как это работает. Во-первых, теперь мы будем хранить нашу реальную температуру в переменной `self._temperature`.\n",
        "Обращение к этой переменной не будет влечь за собой никакой другой логики, но присваивать ей температуру мы будем только внутри класса, а пользователь снаружи не будет о ней ничего знать и не должен к ней обращаться.\n",
        "\n",
        "**NB:** Подчёркивание в начале названия атрибута или метода &mdash; это стандартное в питоне обозначение части внутреннего интерфейса класса. Разработчик не обещает, что этот интерфейс не будет меняться в будущих версиях, и пользователь не должен его использовать. Причём сам питон никак не запрещает обращаться к таким атрибутам и методам, просто программисты соблюдают некоторое джентльменское соглашение (цитата из документации)\n",
        "\n",
        "Сначала мы создаём функцию с названием нашего атрибута (в нашем случае `def temperature`) с декоратором `@property` и в ней возвращаем наше реальное значение температуры (`return self._temperature`). Теперь, когда мы будем обращаться к `thermometer.temperature` будет вызываться эта функция.\n",
        "\n",
        "Затем мы создаём ещё одну функцию с тем же названием, но теперь с декоратором `@temperature.setter`, в которой проверяем наше условие и присваиваем новое значение нашей внутренней переменной `self._temperature`. Эта функция будет вызываться, когда мы будем присваивать значение `thermometer.temperature`."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3HO9e-ZJdmsS"
      },
      "source": [
        "### Дескрипторы"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E8K72WeRfIFB"
      },
      "source": [
        "Дескрипторы позволяют обобщить это поведение. Допустим, у нас сразу 2 элемента, на которые мы хотим навесить ограничение, чтобы они не были, допустим, отрицательными. Можно прописать свойства для каждого, а можно сделать лучше!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 77,
      "metadata": {
        "id": "e3pT0PC2dbSs"
      },
      "outputs": [],
      "source": [
        "class Order:\n",
        "    def __init__(self, name, price, quantity):\n",
        "        self.name = name\n",
        "        self.price = price\n",
        "        self.quantity = quantity\n",
        "    def total(self):\n",
        "        return self.price * self.quantity"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 80,
      "metadata": {
        "id": "TlgYCPq8fanC"
      },
      "outputs": [],
      "source": [
        "class NonNegative:\n",
        "    def __init__(self, name):\n",
        "        self.name = name\n",
        "    def __get__(self, instance, owner):\n",
        "        return instance.__dict__[self.name]\n",
        "    def __set__(self, instance, value):\n",
        "        if value < 0:\n",
        "            raise ValueError('Cannot be negative.')\n",
        "        instance.__dict__[self.name] = value"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 81,
      "metadata": {
        "id": "c5vVx7sNfGJh"
      },
      "outputs": [],
      "source": [
        "class Order:\n",
        "    price = NonNegative('price')\n",
        "    quantity = NonNegative('quantity')\n",
        "    def __init__(self, name, price, quantity):\n",
        "        self._name = name\n",
        "        self.price = price\n",
        "        self.quantity = quantity\n",
        "    def total(self):\n",
        "        return self.price * self.quantity"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 82,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 322
        },
        "id": "9tgr4mvNy6Rg",
        "outputId": "829d07fe-0912-4c82-c2ed-871f613b3c4a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "50\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "ValueError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-82-c4a8c6a50496>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0morder\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mOrder\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'apple'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0morder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtotal\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----> 3\u001b[0;31m \u001b[0morder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mquantity\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m<ipython-input-80-1719e2ee14ee>\u001b[0m in \u001b[0;36m__set__\u001b[0;34m(self, instance, value)\u001b[0m\n\u001b[1;32m      6\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[1;32m      7\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mvalue\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m0\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;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Cannot be negative.'\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[0minstance\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__dict__\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mValueError\u001b[0m: Cannot be negative."
          ]
        }
      ],
      "source": [
        "order = Order('apple', 10, 5)\n",
        "print(order.total())\n",
        "order.quantity = -1"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dizc14rDfwO5"
      },
      "source": [
        "А теперь уберём ещё немного дублирования! (3.6+)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 90,
      "metadata": {
        "id": "MTJIOjWJfyxn"
      },
      "outputs": [],
      "source": [
        "class NonNegative:\n",
        "    def __get__(self, instance, owner):\n",
        "        return instance.__dict__[self.name]\n",
        "    def __set__(self, instance, value):\n",
        "        if value < 0:\n",
        "            raise ValueError('Cannot be negative.')\n",
        "        instance.__dict__[self.name] = value\n",
        "    def __set_name__(self, owner, name):\n",
        "        self.name = name"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 91,
      "metadata": {
        "id": "cE1ZffXQgllt"
      },
      "outputs": [],
      "source": [
        "class Order:\n",
        "    price = NonNegative()\n",
        "    quantity = NonNegative()\n",
        "    def __init__(self, name, price, quantity):\n",
        "        self._name = name\n",
        "        self.price = price\n",
        "        self.quantity = quantity\n",
        "    def total(self):\n",
        "        return self.price * self.quantity"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 92,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LhxBNe7ZgeVZ",
        "outputId": "f2209ca3-5bbe-48e0-d37a-b82aba5c4dd8"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "10\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'_name': 'apple', 'price': 1, 'quantity': 10}"
            ]
          },
          "metadata": {},
          "execution_count": 92
        }
      ],
      "source": [
        "apple_order = Order('apple', 1, 10)\n",
        "print(apple_order.total())\n",
        "apple_order.__dict__"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fVBNIXVdDI6k"
      },
      "source": [
        "### `@staticmethod`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "abNc0aYsDI6k"
      },
      "source": [
        "Иногда метод объекта никак не использует его атрибуты (не обращается к self), а просто выполняет независимую логику. В таком случае такой метод называется статическим. Мы можем использовать на нём специальный декоратор `@staticmethod`, и тогда мы помимо прочего сможем вызывать его, даже не создавая объект"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jq5g8IM-DI6k"
      },
      "source": [
        "Попробуем это на примере нашего термометра. Предположим, мы хотим научить его вычислять выдавать температуру в градусах по Фаренгейту. В таком случае нам следует определить метод `get_fahrenheit` и хорошо бы вынести сам перевод в отдельный метод `celsius_to_fahrenheit`:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9KTyV7O8DI6k",
        "outputId": "2df43073-a359-4420-efc3-7918d1be1652",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "10.0 градусов по Цельсию равны 50.0 градусов по Фаренгейту\n"
          ]
        }
      ],
      "source": [
        "class Thermometer:\n",
        "    \"\"\"\n",
        "    Thermometer containing temperature in Celsius\n",
        "    :param temperature: temperature to contain\n",
        "    \"\"\"\n",
        "    MINIMAL_TEMPERATURE = -273.15\n",
        "    def __init__(self, temperature: float) -> None:\n",
        "        self.temperature = temperature\n",
        "\n",
        "    @property\n",
        "    def temperature(self) -> float:\n",
        "        return self._temperature\n",
        "\n",
        "    @temperature.setter\n",
        "    def temperature(self, value: float) -> None:\n",
        "        if value < Thermometer.MINIMAL_TEMPERATURE:\n",
        "            raise ValueError(f\"Temperature cannot be less than {Thermometer.MINIMAL_TEMPERATURE}\")\n",
        "        self._temperature = value\n",
        "\n",
        "    def celsius_to_fahrenheit(self, value) -> float:\n",
        "        return value * 1.8 + 32\n",
        "\n",
        "    def get_fahrenheit(self) -> float:\n",
        "        return self.celsius_to_fahrenheit(self.temperature)\n",
        "\n",
        "thermometer = Thermometer(10.)\n",
        "print(f\"{thermometer.temperature} градусов по Цельсию равны {thermometer.get_fahrenheit()} градусов по Фаренгейту\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iyp2Jw9sDI6k"
      },
      "source": [
        "Наша функция `celsius_to_fahrenheit` просто переводит температуру, которую получает на вход. Она никак не использует `self`. Давайте сделаем её статическим методом."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 99,
      "metadata": {
        "id": "ovzIRBQKDI6k",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [],
      "source": [
        "class Thermometer:\n",
        "    \"\"\"\n",
        "    Thermometer containing temperature in Celsius\n",
        "    :param temperature: temperature to contain\n",
        "    \"\"\"\n",
        "    MINIMAL_TEMPERATURE = -273.15\n",
        "    def __init__(self, temperature: float) -> None:\n",
        "        self.temperature = temperature\n",
        "\n",
        "    @property\n",
        "    def temperature(self) -> float:\n",
        "        return self._temperature\n",
        "\n",
        "    @temperature.setter\n",
        "    def temperature(self, value: float) -> None:\n",
        "        if value < Thermometer.MINIMAL_TEMPERATURE:\n",
        "            raise ValueError(f\"Temperature cannot be less than {Thermometer.MINIMAL_TEMPERATURE}\")\n",
        "        self._temperature = value\n",
        "\n",
        "    @staticmethod\n",
        "    def celsius_to_fahrenheit(value) -> float:\n",
        "        return value * 1.8 + 32\n",
        "\n",
        "    def get_fahrenheit(self) -> float:\n",
        "        return self.celsius_to_fahrenheit(self.temperature)\n",
        "\n",
        "Thermometer.celsius_to_fahrenheit(10)\n",
        "thermometer = Thermometer(10)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "h8l75EO_DI6l"
      },
      "source": [
        "Обратите внимание, что мы всё так же можем вызывать функцию от объекта класса (как, например, от `self` в `get_fahrenheit`). Но так же теперь мы можем вызывать её и от самого класса:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 101,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kVSsW6SIDI6l",
        "outputId": "95958e91-8b3d-42ac-ed2f-04c04ca37261",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "51.8"
            ]
          },
          "metadata": {},
          "execution_count": 101
        }
      ],
      "source": [
        "t = Thermometer(10)\n",
        "# Thermometer.celsius_to_fahrenheit(10.)\n",
        "t.celsius_to_fahrenheit(11)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YwHIhiokDI6l"
      },
      "source": [
        "### `@classmethod`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ByG2zLQtDI6l"
      },
      "source": [
        "Бывает и другая ситуация. Когда метод не использует атрибуты объекта (не обращается к `self`), но использует знание о том, из какого класса он вызывается. Такой метод называется методом класса и мы можем обозначить его декоратором `@classmethod`. Метод с декоратором `@classmethod` принимает в качестве первого аргумента не объект класса (`self`), а сам класс (`cls`)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cWBysNbCDI6l"
      },
      "source": [
        "Предположим, мы хотим уметь создавать наш термометр сразу из температуры по Фаренгейту. Но наш `__init__` принимает температуру в градусах Цельсия. Создадим новый метод класса `from_fahrenheit`, который будет переводить полученную температуру из Фаренгейта в Цельсии (при помощи нового статического метода `fahrenheit_to_celsius` и возвращать новый объект класса:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "lPGs12jrDI6l",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [],
      "source": [
        "class Thermometer:\n",
        "    \"\"\"\n",
        "    Thermometer containing temperature in Celsius\n",
        "    :param temperature: temperature to contain\n",
        "    \"\"\"\n",
        "    MINIMAL_TEMPERATURE = -273.15\n",
        "    def __init__(self, temperature: float) -> None:\n",
        "        self.temperature = temperature\n",
        "\n",
        "    @property\n",
        "    def temperature(self) -> float:\n",
        "        return self._temperature\n",
        "\n",
        "    @temperature.setter\n",
        "    def temperature(self, value: float) -> None:\n",
        "        if value < Thermometer.MINIMAL_TEMPERATURE:\n",
        "            raise ValueError(f\"Temperature cannot be less than {Thermometer.MINIMAL_TEMPERATURE}\")\n",
        "        self._temperature = value\n",
        "\n",
        "    @staticmethod\n",
        "    def celsius_to_fahrenheit(value) -> float:\n",
        "        return value * 1.8 + 32\n",
        "\n",
        "    @staticmethod\n",
        "    def fahrenheit_to_celsius(value) -> float:\n",
        "        return (value - 32) / 1.8\n",
        "\n",
        "    def get_fahrenheit(self) -> float:\n",
        "        print(type(self))\n",
        "        return self.celsius_to_fahrenheit(self.temperature)\n",
        "\n",
        "    @classmethod\n",
        "    def from_fahrenheit(cls, temperature_fahrenheit) -> Thermometer:\n",
        "        temperature_celsius = cls.fahrenheit_to_celsius(temperature_fahrenheit)\n",
        "        print(type(cls))\n",
        "        return cls(temperature_celsius)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0VcD9xRhDI6m"
      },
      "source": [
        "Теперь мы можем создать термометер из градусов по Фаренгейту:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "44fabdpzDI6m",
        "outputId": "343f533d-8684-4446-82d5-6646e992e254",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "<class 'type'>\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "<__main__.Thermometer at 0x7f1a49d2fed0>"
            ]
          },
          "execution_count": 67,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "thermometer = Thermometer(10)\n",
        "thermometer.from_fahrenheit(100)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bhVUAsxSDI6m"
      },
      "source": [
        "### Наследование, `super()`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ys0KUFTXDI6m"
      },
      "source": [
        "Одним из главных механизмов ООП является наследование. Класс может отнаследоваться от другого класса, тем самым получая доступ к его методам и атрибутам. Класс-ребёнок может добавлять свои новые методы и переопределять методы класса-родителя, но так же может использовать и все методы, определённые в классе родителе."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WvSoJF0JDI6m"
      },
      "source": [
        "Родительский класс в питоне указывается в скобках после названия класса во время объявления: `class Children(Parent)`. Причём один класс может быть ребёнком сразу нескольких классов. В таком случае они перечисляются через запятую."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EnC0fcWDDI6o"
      },
      "source": [
        "Попробуем создать общий класс `Person`, который будет иметь атрибут `name` и сможет представляться при помощи метода `introduce`:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 103,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ToR9XqnxDI6o",
        "outputId": "ac95d2f6-cddc-4ca9-ec61-fdc1af629971",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello, my name is Dima\n",
            "A person named Dima\n"
          ]
        }
      ],
      "source": [
        "class Person:\n",
        "    \"\"\"\n",
        "    A class representing a person with a name that can introduce himself\n",
        "    :param name: the name of the person\n",
        "    \"\"\"\n",
        "    def __init__(self, name: str) -> None:\n",
        "        self.name = name\n",
        "\n",
        "    def introduce(self) -> None:\n",
        "        print(f\"Hello, my name is {self.name}\")\n",
        "\n",
        "    @classmethod\n",
        "    def f(cls):\n",
        "        print(cls)\n",
        "\n",
        "    def __str__(self) -> str:\n",
        "        return f\"A person named {self.name}\"\n",
        "\n",
        "person = Person(\"Dima\")\n",
        "person.introduce()\n",
        "print(person)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 104,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qotM5ffu35o4",
        "outputId": "b397ce72-d1d4-4a8a-d585-9615559ea454"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "type"
            ]
          },
          "metadata": {},
          "execution_count": 104
        }
      ],
      "source": [
        "type(Person)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sPuXprzcDI6o"
      },
      "source": [
        "Теперь создадим подклассы Teacher и Student. Помимо имени у преподавателя будет поле `discipline`, а у студента поле `marks`:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 105,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wh6BkdztDI6o",
        "outputId": "cfdb5b26-2118-4c4e-dd69-198ae3f42822",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello, my name is Evgeny\n",
            "A teacher named Evgeny who teaches Machine Learning\n",
            "\n",
            "Hello, my name is Liza\n",
            "A student named Liza with marks {'Calculus': 5, 'Machine Learning': 10}\n"
          ]
        }
      ],
      "source": [
        "from typing import Dict\n",
        "\n",
        "class Teacher(Person):\n",
        "    \"\"\"\n",
        "    A class representing a teacher with his discipline\n",
        "    :param name: the name of the teacher\n",
        "    :param discipline: the discipline taught by the teacher\n",
        "    \"\"\"\n",
        "    def __init__(self, name: str, discipline: str) -> None:\n",
        "        super().__init__(name)  # Вызываем __init__ класса-родителя\n",
        "        self.discipline = discipline\n",
        "\n",
        "    def __str__(self) -> str:\n",
        "        return f\"A teacher named {self.name} who teaches {self.discipline}\"\n",
        "\n",
        "\n",
        "class Student(Person):\n",
        "    \"\"\"\n",
        "    A class representing a student and his marks\n",
        "    :param name: the name of the student\n",
        "    :param marks: a dict of disciplines as keys and marks as values\n",
        "    \"\"\"\n",
        "    def __init__(self, name: str, marks: Dict[str, int]) -> None:\n",
        "        super().__init__(name)  # Вызываем __init__ класса-родителя\n",
        "        self.marks = marks\n",
        "\n",
        "    def __str__(self) -> str:\n",
        "        return f\"A student named {self.name} with marks {self.marks}\"\n",
        "\n",
        "teacher = Teacher(\"Evgeny\", \"Machine Learning\")\n",
        "teacher.introduce()\n",
        "print(teacher)\n",
        "print()\n",
        "\n",
        "student = Student(\"Liza\", {\"Calculus\": 5, \"Machine Learning\": 10})\n",
        "student.introduce()\n",
        "print(student)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 107,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TOp8OfzJCq1o",
        "outputId": "7b233a99-7c0c-4c58-e6dd-081b083c908d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class '__main__.Person'>\n",
            "<class '__main__.Person'>\n",
            "<class '__main__.Teacher'>\n",
            "<class '__main__.Teacher'>\n",
            "<class '__main__.Student'>\n",
            "<class '__main__.Student'>\n"
          ]
        }
      ],
      "source": [
        "persons = []\n",
        "persons.append(person)\n",
        "persons.append(teacher)\n",
        "persons.append(student)\n",
        "\n",
        "for i in persons:\n",
        "    i.f()\n",
        "    print(type(i))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Iq8XEYvEDI6o"
      },
      "source": [
        "Теперь любой код, который использует метод `introduce` может работать как с классом `Person`, так и с классами `Teacher` и `Student`.\n",
        "\n",
        "И в то же время, ни в одном из этих классов мы не прописывали функцию `introduce`, потому что она уже есть в родительском классе `Person`, так что мы избежали дублирования кода и объединили объекты со схожей логикой между собой."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eQBhp8mHDI6o"
      },
      "source": [
        "Стоит обратить особое внимание на оператор `super()`. Все методы, вызывающиеся от `super()`, будут вызваны от родительского класса (классов) объекта. Таким образом, когда мы вызываем `super().__init__(name)` в классах `Teacher` и `Student` мы выполняем код из метода `__init__` родительского класса `Person`: `self.name = name`, то есть определяем в объекте атрибут `name`. А затем уже мы добавляем новые атрибуты. Если функция `__init__` в родительском классе как-то поменяется, у нас ничего не сломается, и эти изменения будут использоваться и в дочерних классах.\n",
        "\n",
        "Так же следует обратить внимание на то, что метод `__str__` определён как в родительсом классе `Person`, так и в дочерних `Teacher` и `Student`. Таким образом, дочерние классы переопределяют этот метод, и при вызове `print` или `str` от объектов дочерних классов будет вызыван их метод `__str__`, а не родительский."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qF8tj4_nDI6p"
      },
      "source": [
        "Мы могли бы использовать `super()` и не только в `__init__`, например, чтобы расширить функционал представления:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Tf6BVeSWDI6p",
        "outputId": "f2160e3a-440c-44fd-d6a9-ee0b66487c1d",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Hello, my name is Evgeny\n",
            "I teach Machine Learning\n"
          ]
        }
      ],
      "source": [
        "class Teacher(Person):\n",
        "    \"\"\"\n",
        "    A class representing a teacher with his discipline\n",
        "    :param name: the name of the teacher\n",
        "    :param discipline: the discipline taught by the teacher\n",
        "    \"\"\"\n",
        "    def __init__(self, name: str, discipline: str) -> None:\n",
        "        super().__init__(name)  # Вызываем __init__ класса-родителя\n",
        "        self.discipline = discipline\n",
        "\n",
        "    def introduce(self) -> None:\n",
        "        super().introduce()\n",
        "        print(f\"I teach {self.discipline}\")\n",
        "\n",
        "    def __str__(self) -> str:\n",
        "        return f\"A teacher named {self.name} who teaches {self.discipline}\"\n",
        "\n",
        "teacher = Teacher(\"Evgeny\", \"Machine Learning\")\n",
        "teacher.introduce()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g1M-zCfGDI6p"
      },
      "source": [
        "Кроме того мы могли бы определить в дочерних классах совершенно новые методы, которых нет в классе-родителе:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ht51qMWeDI6p",
        "outputId": "10a9cc88-ff45-49a8-8269-6314b940046b",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Hello, my name is Liza\n",
            "Failed disciplines: {'Calculus': 3}\n"
          ]
        }
      ],
      "source": [
        "class Student(Person):\n",
        "    \"\"\"\n",
        "    A class representing a student and his marks\n",
        "    :param name: the name of the student\n",
        "    :param marks: a dict of disciplines as keys and marks as values\n",
        "    \"\"\"\n",
        "    def __init__(self, name: str, marks) -> None:\n",
        "        super().__init__(name)  # Вызываем __init__ класса-родителя\n",
        "        self.marks = marks\n",
        "\n",
        "    def __str__(self) -> str:\n",
        "        return f\"A student named {self.name} with marks {self.marks}\"\n",
        "\n",
        "    def get_fails(self):\n",
        "        \"\"\"\n",
        "        Gets failed disciplines\n",
        "        \"\"\"\n",
        "        return {discipline: mark for discipline, mark in self.marks.items() if mark < 4}\n",
        "\n",
        "student = Student(\"Liza\", {\"Calculus\": 3, \"Machine Learning\": 10})\n",
        "student.introduce()\n",
        "print(f\"Failed disciplines: {student.get_fails()}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Fe90ZXL_DI6p"
      },
      "source": [
        "Мы разобрали очень простой пример наследования. На практике деревья наследования могут быть очень большими, один класс может иметь множество детей и множество родителей. В таких случаях может стать непонятно, в каком именно порядке питон обходит родителей класса, чтобы понять, чью реализацию того или иного метода использовать.\n",
        "\n",
        "Чтобы посмотреть этот порядок можно использовать атрибут **класса** `__mro__` (Method Resolution Order):"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8p6-4LJxDI6q",
        "outputId": "e29faa3f-16e4-4f73-e601-2d78d39de8b6",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(__main__.Student, __main__.Person, object)"
            ]
          },
          "execution_count": 17,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "Student.__mro__"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kqZvuIPPDI6q"
      },
      "source": [
        "Мы видим, что если мы попытаемся вызвать у объекта класса `Student`, например, метод `introduce`, то сначала питон попытается найти его реализацию в самом классе `Student`. Если там её не окажется, он попробует класс `Person`, а если и там нет, то родительский класс всех классов `object`. (А если и там нет, то выдаст `AttributeError`)\n",
        "\n",
        "Подробнее про то, как именно питон определяет этот порядок, можно почитать, например, [тут](https://habr.com/ru/post/62203/)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y5M9b-UHDI6q"
      },
      "source": [
        "### ABC &mdash; Abstract Base Classes"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4zxZsdGwDI6q"
      },
      "source": [
        "Бывает так, что мы хотим обозначить какой-то список методов, которые должны реализовывать все классы одного семейства, но не можем предоставить дефолтной реализации для этих методов. Например, нам нужно написать код, который вычислял бы сумму площадей или периметров списка фигур, но для каждого типа фигуры эти величины вычисляются по-своему, а всё же хотелось бы как-то объединить их всех в один родительский класс и показать, какими методами должна обладать фигура.\n",
        "\n",
        "В таком случае нам на помощь приходит модуль `abc` и декоратор `@abstractmethod`. Если мы отнаследуем наш класс от класса `abc.ABC` и добавим к методам декоратор `@abc.abstractmethod`, все классы, наследующиеся от нашего будут обязаны объявить эти методы, а иначе питон выдаст ошибку.\n",
        "\n",
        "Давайте поробуем:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 108,
      "metadata": {
        "id": "VjKu_B2dDI6r",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [],
      "source": [
        "import abc\n",
        "\n",
        "class Shape(abc.ABC):\n",
        "    \"\"\"\n",
        "    Shape class capable of calculating its area and perimeter\n",
        "    \"\"\"\n",
        "    @abc.abstractmethod\n",
        "    def get_area(self) -> float:\n",
        "        \"\"\"\n",
        "        Method for getting the area of the shape\n",
        "        \"\"\"\n",
        "        pass\n",
        "\n",
        "    @abc.abstractmethod\n",
        "    def get_perimeter(self) -> float:\n",
        "        \"\"\"\n",
        "        Method for getting the perimeter of the shape\n",
        "        \"\"\"\n",
        "        pass"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LrG8z_O9DI6r"
      },
      "source": [
        "Попробуем создать класс, который наследуется от `Shape`, но не реализует эти методы:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 109,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 200
        },
        "id": "UPePamX8DI6r",
        "outputId": "60ebc724-27e6-4288-f7cc-1adbcaa8b088",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "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-109-4f2613e4892b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m     \u001b[0;32mpass\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mbad_shape\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mBadShape\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 BadShape with abstract methods get_area, get_perimeter"
          ]
        }
      ],
      "source": [
        "class BadShape(Shape):\n",
        "    pass\n",
        "\n",
        "bad_shape = BadShape()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HUVv30kzDI6s"
      },
      "source": [
        "Как видим питон не дал нам создать объект такого класса (но сам класс создать дал!)\n",
        "\n",
        "Так же мы не сможем создать объект самого абстрактного класса `Shape`:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 110,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 165
        },
        "id": "4wNvuIx9DI6s",
        "outputId": "60e4cdbe-8eba-431c-a3b7-834920bce34f",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "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-110-935910247ce1>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mshape\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mShape\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 Shape with abstract methods get_area, get_perimeter"
          ]
        }
      ],
      "source": [
        "shape = Shape()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vrYjLxHGDI6s"
      },
      "source": [
        "Теперь реализуем нормальные фигуры:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 111,
      "metadata": {
        "id": "cUyS3dowDI6s",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [],
      "source": [
        "import math\n",
        "\n",
        "class Circle(Shape):\n",
        "    \"\"\"\n",
        "    A circle with a some radius\n",
        "    \"\"\"\n",
        "    def __init__(self, radius: float) -> None:\n",
        "        self.radius = radius\n",
        "\n",
        "    def get_area(self) -> float:\n",
        "        return math.pi * self.radius ** 2\n",
        "\n",
        "    def get_perimeter(self) -> float:\n",
        "        return 2 * math.pi * self.radius\n",
        "\n",
        "\n",
        "class Rectangle(Shape):\n",
        "    \"\"\"\n",
        "    A rectangle with some width and height\n",
        "    \"\"\"\n",
        "    def __init__(self, width: float, height: float) -> None:\n",
        "        self.width = width\n",
        "        self.height = height\n",
        "\n",
        "    def get_area(self) -> float:\n",
        "        return self.width * self.height\n",
        "\n",
        "    def get_perimeter(self) -> float:\n",
        "        return 2 * (self.width + self.height)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AIKL7kN8DI6t"
      },
      "source": [
        "Теперь мы можем написать функции, которая будет работать с нашими объектами `Shape`, и они могут быть уверены, что все классы, наследующиеся от `Shape` будут реализовывать нужные им методы:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 112,
      "metadata": {
        "id": "2g8KaBvlDI6t",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [],
      "source": [
        "def get_areas_sum(shapes):\n",
        "    # Проверяем, что все наши объекты наследуются от Shape:\n",
        "    for shape in shapes:\n",
        "        if not isinstance(shape, Shape):\n",
        "            raise ValueError(f\"Only Shape objects are allowed, you tried to pass object of type {type(shape)}\")\n",
        "    # if not all(isinstance(shape, Shape) for shape in shapes):\n",
        "    #   raise ValueError(\"Only Shape objects are allowed\")\n",
        "    return sum(shape.get_area() for shape in shapes)\n",
        "\n",
        "def get_perimeters_sum(shapes):\n",
        "    # Проверяем, что все наши объекты наследуются от Shape:\n",
        "    if not all(isinstance(shape, Shape) for shape in shapes):\n",
        "        raise ValueError(\"Only Shape objects are allowed\")\n",
        "    return sum(shape.get_perimeter() for shape in shapes)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OjBSNNdBDI6u"
      },
      "source": [
        "Попробуем использовать наши функции по назначению:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 113,
      "metadata": {
        "id": "XpUhqOqkAAu0"
      },
      "outputs": [],
      "source": [
        "my_circle = Circle(10)\n",
        "del my_circle.radius"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 115,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wpsL5gDSDI6u",
        "outputId": "df05d833-d9f8-4d14-e567-7fa0e575efda",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4.141592653589793\n",
            "21.707963267948966\n",
            "10.283185307179586\n",
            "28.84955592153876\n"
          ]
        }
      ],
      "source": [
        "print(get_areas_sum([Circle(1.), Rectangle(1., 1.)]))\n",
        "print(get_areas_sum([Circle(1.), Circle(2.), Rectangle(3., 2.)]))\n",
        "\n",
        "print(get_perimeters_sum([Circle(1.), Rectangle(1., 1.)]))\n",
        "print(get_perimeters_sum([Circle(1.), Circle(2.), Rectangle(3., 2.)]))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7ZK91JtIDI6u"
      },
      "source": [
        "Попробуем подать неправильные объекты:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 279
        },
        "id": "Qu6_wxojDI6u",
        "outputId": "d130fe00-0a76-4b46-d89c-626dba193853",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [
        {
          "ename": "ValueError",
          "evalue": "ignored",
          "output_type": "error",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m/tmp/ipykernel_335/1712053667.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mget_areas_sum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mCircle\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1.\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mRectangle\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1.\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1.\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"STRING\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m/tmp/ipykernel_335/3891696504.py\u001b[0m in \u001b[0;36mget_areas_sum\u001b[0;34m(shapes)\u001b[0m\n\u001b[1;32m      3\u001b[0m     \u001b[0;32mfor\u001b[0m \u001b[0mshape\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mshapes\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;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mShape\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;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"Only Shape objects are allowed, you tried to pass object of type {type(shape)}\"\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      6\u001b[0m     \u001b[0;31m# if not all(isinstance(shape, Shape) for shape in shapes):\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;31m#   raise ValueError(\"Only Shape objects are allowed\")\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mValueError\u001b[0m: Only Shape objects are allowed, you tried to pass object of type <class 'str'>"
          ]
        }
      ],
      "source": [
        "print(get_areas_sum([Circle(1.), Rectangle(1., 1.), \"STRING\"]))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S47Y7IOcDI6u"
      },
      "source": [
        "Питон так же имеет множество встроенных абстрактных классов, которые вы можете использовать, для проверки того, что объект удовлетворяет определённому интерфейсу: https://docs.python.org/3/library/collections.abc.html"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "U64s8X-X7vVj"
      },
      "outputs": [],
      "source": [
        "from collections.abc import *\n",
        "class MyStorage(Sequence):\n",
        "    def __getitem__(self):\n",
        "        pass\n",
        "    def __len__(self):\n",
        "        pass\n",
        "\n",
        "storage = MyStorage()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7HTzGbvDDI6u"
      },
      "source": [
        "### [Dataclasses](https://docs.python.org/3/library/dataclasses.html)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OURss0OvDI6v"
      },
      "source": [
        "Зачастую нам нужен небольшой класс, который не имеет своих методов, но просто хранит в себе какие-то данные. Например, класс человека с именем, фамилией и возрастом.\n",
        "\n",
        "Если мы напишем для такой цели полноценный питоновский класс, мы получим громоздкую конструкцию с множеством повторений:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DyDykQeQDI6v",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [],
      "source": [
        "class Person:\n",
        "    def __init__(self, name, surname, age):\n",
        "        self.name = name\n",
        "        self.surname = surname\n",
        "        self.age = age\n",
        "\n",
        "person = Person(\"Stern\", \"Morgenov\", 13)\n",
        "person"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8IiIxWFwDI61"
      },
      "source": [
        "И это мы не ещё определили такие методы как `__repr__` и `__eq__` для понятного представления и сравнения людей.\n",
        "\n",
        "Чтобы не заниматься всей этой ерундой питон предоставляет удобный способ создания классов, нужных исключительно для хранения данных, определённый во встроенном модуле `dataclasses`:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 122,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SnizQo5EDI61",
        "outputId": "4446a5e7-090a-4cf3-830b-7b114402d9b6",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Person(name='Stern', surname='Morgenov', age=13)\n",
            "Person(name='Stern', surname='Morgenov', age=14)\n"
          ]
        }
      ],
      "source": [
        "from dataclasses import dataclass\n",
        "\n",
        "@dataclass\n",
        "class Person:\n",
        "    name: str\n",
        "    surname: str\n",
        "    age: int\n",
        "\n",
        "    def birthday(self):\n",
        "        self.age += 1\n",
        "\n",
        "person = Person(\"Stern\", \"Morgenov\", 13)\n",
        "print(person)\n",
        "person.birthday()\n",
        "print(person)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_BHChG0IDI62"
      },
      "source": [
        "Стоит отметить, что аннотация типов тут является обязательной частью синтаксиса.\n",
        "Данная конструкция автоматически создаёт для нас класс `Person` с определёнными методами `__init__`, `__repr__` и даже `__eq__`.\n",
        "\n",
        "При создании объекта параметры будут подаваться в том же порядке, в котором они объявлены в классе.\n",
        "\n",
        "Более тонко настроить, какие именно методы будут автоматически добавляться можно при помощи параметров самого декоратора. Например, если мы не хотим, чтобы за нас создавали `__repr__`, мы можем сделать так:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 123,
      "metadata": {
        "id": "G9mwjRLPDI62",
        "pycharm": {
          "name": "#%%\n"
        },
        "outputId": "cb00c038-dc70-4163-fc94-61d4e73ab3b2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<__main__.PersonWORepr at 0x7f405e906a10>"
            ]
          },
          "metadata": {},
          "execution_count": 123
        }
      ],
      "source": [
        "@dataclass(repr=False)\n",
        "class PersonWORepr:\n",
        "    name: str\n",
        "    surname: str\n",
        "    age: int\n",
        "\n",
        "person_wo_repr = PersonWORepr(\"Stern\", \"Morgenov\", 13)\n",
        "person_wo_repr"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2J3raCHSDI62"
      },
      "source": [
        "Как видим, метод `__repr__` не добавился, и информация об объекте красиво не вывелась."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dGxyQc9RDI62"
      },
      "source": [
        "dataclass'ы поддерживают значения по умолчанию:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SrtFJJrwDI62",
        "outputId": "577157b3-fa5c-4e14-cb53-fecd873800de",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "PersonWithDefaultAge(name='Stern', surname='Morgenov', age=28)"
            ]
          },
          "execution_count": 79,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "@dataclass\n",
        "class PersonWithDefaultAge:\n",
        "    name: str\n",
        "    surname: str\n",
        "    age: int = 28\n",
        "\n",
        "person_with_default_age = PersonWithDefaultAge(\"Stern\", \"Morgenov\")\n",
        "person_with_default_age"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qU8QUoP-DI62"
      },
      "source": [
        "Как и в аргументах функций, все переменные со значениями по умолчанию должны стоять после всех переменных без них."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nHfqsn05DI63"
      },
      "source": [
        "Last but not least, иногда вам может быть нужна дополнительная логика при задании полей dataclass'а. Например, вы хотите добавить изменяемый объект в качестве значения по умолчанию. Для таких случаев в модуле `dataclasses` есть `field`:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 380
        },
        "id": "Wx4CfV83DI63",
        "outputId": "26c45705-ca52-4cce-ad3c-4d6295dd13e1",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Student(name='Stern', surname='Morgenov', age=28, classes=[1, 2, 3])\n",
            "{'name': 'Stern', 'surname': 'Morgenov', 'age': 28, 'classes': [1, 2, 3], 'somename': 100}\n"
          ]
        },
        {
          "ename": "AttributeError",
          "evalue": "ignored",
          "output_type": "error",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
            "\u001b[0;32m/tmp/ipykernel_335/3368938962.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     14\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstudent\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__dict__\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     15\u001b[0m \u001b[0;32mdel\u001b[0m \u001b[0mstudent\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 16\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstudent\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m/usr/lib/python3.8/dataclasses.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    366\u001b[0m         \u001b[0mrepr_running\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    367\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 368\u001b[0;31m             \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0muser_function\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[0m\n\u001b[0m\u001b[1;32m    369\u001b[0m         \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    370\u001b[0m             \u001b[0mrepr_running\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdiscard\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<string>\u001b[0m in \u001b[0;36m__repr__\u001b[0;34m(self)\u001b[0m\n",
            "\u001b[0;31mAttributeError\u001b[0m: 'Student' object has no attribute 'name'"
          ]
        }
      ],
      "source": [
        "from typing import List\n",
        "from dataclasses import field\n",
        "\n",
        "@dataclass\n",
        "class Student:\n",
        "    name: str\n",
        "    surname: str\n",
        "    age: int = 28\n",
        "    classes: List[int] = field(default_factory=lambda: [1, 2, 3])\n",
        "\n",
        "student = Student(\"Stern\", \"Morgenov\")\n",
        "print(student)\n",
        "student.somename = 100\n",
        "print(student.__dict__)\n",
        "del student.name\n",
        "print(student)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7LSLxDulDI63"
      },
      "source": [
        "Параметр `default_factory` в `field` принимает функцию, которая создаёт дефолтное значение.\n",
        "(Подробнее, почему изменяемые объекты в дефолтах &mdash; это плохо, спросите у семинариста или почитайте [тут](https://docs.quantifiedcode.com/python-anti-patterns/correctness/mutable_default_value_as_argument.html))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2ivq4RUtDI63"
      },
      "source": [
        "dataclass'ы также поддерживают наследование.\n",
        "\n",
        "Подробнее о dataclass'ах можно почитать [в документации](https://docs.python.org/3/library/dataclasses.html) или [тут](https://habr.com/ru/post/415829/)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n0FTk_gZMdf9"
      },
      "source": [
        "### Слоты"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zJ0JX2rkg_Hl"
      },
      "source": [
        "Чтобы сделать наши классы ещё более управляемыми, мы можем жёстко ограничить используемые имена атрибутов!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 117,
      "metadata": {
        "id": "qqr71tVHDI63",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [],
      "source": [
        "class SlotsClass:\n",
        "    \n",
        "    __slots__ = ('foo', 'bar')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 121,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pz7WLnZshHaF",
        "outputId": "9551de2e-4f87-4eaf-9bb1-75679685fe55"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "100"
            ]
          },
          "metadata": {},
          "execution_count": 121
        }
      ],
      "source": [
        "obj = SlotsClass()\n",
        "obj.foo = 5\n",
        "print(obj.foo)\n",
        "obj.bar = 100\n",
        "obj.bar"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 162
        },
        "id": "MQ35CcQvhMME",
        "outputId": "fa57d59d-89c5-41a5-9045-a7e0382f54c7"
      },
      "outputs": [
        {
          "ename": "AttributeError",
          "evalue": "ignored",
          "output_type": "error",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
            "\u001b[0;32m/tmp/ipykernel_335/1378704169.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mobj\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0manother_attribute\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'Elvis has left the building'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m: 'SlotsClass' object has no attribute 'another_attribute'"
          ]
        }
      ],
      "source": [
        "obj.another_attribute = 'Elvis has left the building'"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "sgyHxMB7Ae0o"
      },
      "outputs": [],
      "source": [
        "del obj.bar"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 162
        },
        "id": "T-dD79BsBATs",
        "outputId": "aa7e2154-0345-498d-f7d9-5ae04d8f7a01"
      },
      "outputs": [
        {
          "ename": "AttributeError",
          "evalue": "ignored",
          "output_type": "error",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
            "\u001b[0;32m/tmp/ipykernel_335/1693525943.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mobj\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbar\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m: bar"
          ]
        }
      ],
      "source": [
        "obj.bar"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KDaoDdtPi-2E"
      },
      "source": [
        "### Классы-декораторы"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ogo9WELTi8Zn",
        "outputId": "a81f0842-bc66-409f-c008-d174c95471bc"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "foo\n",
            "foo\n",
            "foo\n"
          ]
        }
      ],
      "source": [
        "class Repeater:\n",
        "    def __init__(self, n):\n",
        "        self.n = n\n",
        "\n",
        "    def __call__(self, f):\n",
        "        def wrapper(*args, **kwargs):\n",
        "            for _ in range(self.n):\n",
        "                f(*args, **kwargs)\n",
        "        return wrapper\n",
        "\n",
        "@Repeater(3)\n",
        "def foo(a, b):\n",
        "    print('foo')\n",
        "\n",
        "foo(1, 2)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HVOzttTLLmIo"
      },
      "source": [
        "Отступление. Обработка ошибок:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vqfU1GG7Lltz"
      },
      "outputs": [],
      "source": [
        "class MyError(ValueError):\n",
        "    pass"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 414
        },
        "id": "w78F_DMkLqwN",
        "outputId": "865ff85c-1b6e-4d78-85bb-63a871cf8e32"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "finish\n"
          ]
        },
        {
          "ename": "NameError",
          "evalue": "ignored",
          "output_type": "error",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m/tmp/ipykernel_335/2206028458.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m     \u001b[0mn\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'weew'\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      3\u001b[0m     \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mn\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[0;31mValueError\u001b[0m: invalid literal for int() with base 10: 'weew'",
            "\nDuring handling of the above exception, another exception occurred:\n",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m/tmp/ipykernel_335/2206028458.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      4\u001b[0m     \u001b[0;32mraise\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mMyError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'some error happened'\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      5\u001b[0m     \u001b[0;31m# raise(BaseException())\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0;32mexcept\u001b[0m \u001b[0mMyError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\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      7\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\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[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'My Error'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mNameError\u001b[0m: name 'MyError' is not defined"
          ]
        }
      ],
      "source": [
        "try:\n",
        "    n = int('weew')\n",
        "    data = n / 0\n",
        "    raise(MyError('some error happened'))\n",
        "    # raise(BaseException())\n",
        "except MyError as e:\n",
        "    print(e)\n",
        "    print('My Error')\n",
        "except ValueError as e:\n",
        "    print(e)\n",
        "    print('Could not convert!')\n",
        "except ArithmeticError as e:\n",
        "    print(e)\n",
        "    print('Could not divide by zero!')\n",
        "else:\n",
        "    print('else')\n",
        "finally:\n",
        "    print('finish')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w2oVKa3ajuqw"
      },
      "source": [
        "И декораторы для классов!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AQJgxKRxjwqI",
        "outputId": "bf54a0d4-e69f-4f16-e685-4a0447560b50"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "start\n",
            "end\n",
            "func took 560.9626770019531 ms\n"
          ]
        }
      ],
      "source": [
        "import time\n",
        "\n",
        "def timeit(method):\n",
        "    def timed(*args, **kw):\n",
        "        ts = time.time()\n",
        "        result = method(*args, **kw)\n",
        "        te = time.time()\n",
        "        delta = (te - ts) * 1000\n",
        "        print(f'{method.__name__} took {delta} ms')\n",
        "        return result\n",
        "    return timed\n",
        "\n",
        "\n",
        "def time_all_methods(cls):\n",
        "    class NewCls:\n",
        "        def __init__(self, *args, **kwargs):\n",
        "            self._obj = cls(*args, **kwargs)\n",
        "        def __getattribute__(self, s):\n",
        "            try:\n",
        "                x = super().__getattribute__(s)\n",
        "            except AttributeError:\n",
        "                pass\n",
        "            else:\n",
        "                return x\n",
        "            attr = self._obj.__getattribute__(s)\n",
        "            if isinstance(attr, type(self.__init__)):\n",
        "                return timeit(attr)\n",
        "            else:\n",
        "                return attr\n",
        "    return NewCls\n",
        "\n",
        "\n",
        "@time_all_methods\n",
        "class Foo:\n",
        "    def func(self):\n",
        "        print('start')\n",
        "        time.sleep(0.56)\n",
        "        print('end')\n",
        "\n",
        "\n",
        "f = Foo()\n",
        "f.func()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "LvoGRJC8Hw5t"
      },
      "outputs": [],
      "source": [
        "class SelfCount:\n",
        "    __count = 0\n",
        "\n",
        "    def __init__(self):\n",
        "        SelfCount.__count += 1\n",
        "\n",
        "    def get_count(self):\n",
        "        return SelfCount.__count\n",
        "\n",
        "    def set_count(self, value):\n",
        "        return\n",
        "\n",
        "    def del_count(self):\n",
        "        return\n",
        "\n",
        "    def __del__(self):\n",
        "        SelfCount.__count -= 1\n",
        "\n",
        "    count = property(get_count, set_count, del_count)"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "name": "WS3-functions-and-OOP.ipynb",
      "provenance": []
    },
    "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"
    },
    "toc": {
      "base_numbering": 1,
      "nav_menu": {},
      "number_sections": true,
      "sideBar": true,
      "skip_h1_title": false,
      "title_cell": "Table of Contents",
      "title_sidebar": "Contents",
      "toc_cell": false,
      "toc_position": {},
      "toc_section_display": true,
      "toc_window_display": true
    },
    "varInspector": {
      "cols": {
        "lenName": 16,
        "lenType": 16,
        "lenVar": 40
      },
      "kernels_config": {
        "python": {
          "delete_cmd_postfix": "",
          "delete_cmd_prefix": "del ",
          "library": "var_list.py",
          "varRefreshCmd": "print(var_dic_list())"
        },
        "r": {
          "delete_cmd_postfix": ") ",
          "delete_cmd_prefix": "rm(",
          "library": "var_list.r",
          "varRefreshCmd": "cat(var_dic_list()) "
        }
      },
      "types_to_exclude": [
        "module",
        "function",
        "builtin_function_or_method",
        "instance",
        "_Feature"
      ],
      "window_display": false
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}