lessons/lesson11/interactive_conspect (2).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ООП: Базовые концепции\n",
    "\n",
    "На [прошлой лекции](../lesson10/interactive_conspect.ipynb) мы начали изучать объектно ориентированный стиль программирования и его проявление в Python. В самом начале занятия мы затронули 4 основные концепции ООП: инкапсуляция, наследование, полиморфизм и абстракция. В сегодняшнем занятии мы постараемся рассмотреть реализацию этих концепций в Python.\n",
    "\n",
    "## Инкапсуляция\n",
    "\n",
    "Согласно концепции инкапсуляции все данные и методы объекта деляться на два основных класса: интерфейс и реализацию. Интерфейс описывает совокупность данных и операций, доступных пользователю для манипуляции над объектом. По факту в сознании пользователя объект определенного типа данных полностью описывается и определяется его интерфейсом. Реализация же состоит из служебной информации и включает в себя данные и методы обеспечивающие надежное функционирование объекта, но скрытые от пользователя. В идеале пользователь не должен иметь доступ к реализации, а все его взаимодействие с объектом должно выстраиваться через использование методов и данных, предоставляемых интерфейсом. \n",
    "\n",
    "В таких объектно-ориентированных языках программирования, как С++ инкапсуляция реализуется с помощтю спецификаторов доступа, типа private, shared или public. В Python подобных механизмов нет. По умолчанию, вы можете получить доступ абсолютно к любому полю класса. Однако, в Python существуют специальные соглашения об именовании атрибутов, чтобы разработчики могли понимать, какая часть функционала вашего объекта задумывалась как интерфейс, а какая - как реализация. Согласно данному соглашению, атрибуты класса поддерживают три типа именования.\n",
    "\n",
    "**Первый тип**   \n",
    "\n",
    "Имя атрибута не содержит ведущих нижних подчеркиваний. В данном случае атрибут является публичным и входит в состав интерфейса. Вы можете смело обращаться к нему и, если класс не определяет иного, перезаписывать этот атрибут в своих приложениях.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Point2D:\n",
    "    abscissa: float = 0\n",
    "    ordinate: float = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'__module__': '__main__', '__annotations__': {'abscissa': <class 'float'>, 'ordinate': <class 'float'>}, 'abscissa': 0, 'ordinate': 0, '__dict__': <attribute '__dict__' of 'Point2D' objects>, '__weakref__': <attribute '__weakref__' of 'Point2D' objects>, '__doc__': None}\n",
      "point.abscissa = 0; point.ordinate = 0;\n",
      "point.abscissa = 6; point.ordinate = 0;\n"
     ]
    }
   ],
   "source": [
    "point = Point2D()\n",
    "print(Point2D.__dict__)\n",
    "\n",
    "print(f'{point.abscissa = }; {point.ordinate = };')\n",
    "point.abscissa = 6\n",
    "print(f'{point.abscissa = }; {point.ordinate = };')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Второй тип**  \n",
    " \n",
    "Имя атрибута содержит одно нижнее подчеркивание в качестве первого символа. В этом случае вы можете думать об этом атрибуте, как о shared-атрибуте. Т.е. атрибут является деталью реализации. Предполагается, что такой атрибут может быть использован при написании любых методов данного класса. Также вы можете использовать его в дочерних классах для реализации определнного функционала. Но как пользователь обращаться напрямую к этому методу вы не должны. Однако за прямое обращение вы не получите никаких санкций со стороны интерпретатора. Максимум - предупреждение в достатоно интеллектуальных IDE. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Point2D:\n",
    "    _abscissa: float = 0\n",
    "    _ordinate: float = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'__module__': '__main__', '__annotations__': {'_abscissa': <class 'float'>, '_ordinate': <class 'float'>}, '_abscissa': 0, '_ordinate': 0, '__dict__': <attribute '__dict__' of 'Point2D' objects>, '__weakref__': <attribute '__weakref__' of 'Point2D' objects>, '__doc__': None}\n",
      "point._abscissa = 0; point._ordinate = 0;\n",
      "point._abscissa = 6; point._ordinate = 0;\n"
     ]
    }
   ],
   "source": [
    "point = Point2D()\n",
    "print(Point2D.__dict__)\n",
    "\n",
    "print(f'{point._abscissa = }; {point._ordinate = };')\n",
    "point._abscissa = 6\n",
    "print(f'{point._abscissa = }; {point._ordinate = };')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Третий тип**\n",
    "\n",
    "Имя атрибута содержит два ведущих нижних подчеркивания. В этом случае такой атрибут считается полностью приватным и используется только в реализации данного класса. Вы не сможете обратиться к нему напрямую вне тела данного класса. Обращение к приватному атрибуту по его имени в пользовательском коде или в теле дочернего класса приведет к ошибке. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Point2D:\n",
    "    __abscissa: float = 0\n",
    "    __ordinate: float = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'__module__': '__main__', '__annotations__': {'_Point2D__abscissa': <class 'float'>, '_Point2D__ordinate': <class 'float'>}, '_Point2D__abscissa': 0, '_Point2D__ordinate': 0, '__dict__': <attribute '__dict__' of 'Point2D' objects>, '__weakref__': <attribute '__weakref__' of 'Point2D' objects>, '__doc__': None}\n"
     ]
    },
    {
     "ename": "AttributeError",
     "evalue": "'Point2D' object has no attribute '__abscissa'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32mc:\\Users\\Michail\\Desktop\\mipt\\teaching\\python_mipt_dafe\\lessons\\lesson11\\interactive_conspect.ipynb Cell 9\u001b[0m line \u001b[0;36m4\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/Users/Michail/Desktop/mipt/teaching/python_mipt_dafe/lessons/lesson11/interactive_conspect.ipynb#X24sZmlsZQ%3D%3D?line=0'>1</a>\u001b[0m point \u001b[39m=\u001b[39m Point2D()\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/Users/Michail/Desktop/mipt/teaching/python_mipt_dafe/lessons/lesson11/interactive_conspect.ipynb#X24sZmlsZQ%3D%3D?line=1'>2</a>\u001b[0m \u001b[39mprint\u001b[39m(Point2D\u001b[39m.\u001b[39m\u001b[39m__dict__\u001b[39m)\n\u001b[1;32m----> <a href='vscode-notebook-cell:/c%3A/Users/Michail/Desktop/mipt/teaching/python_mipt_dafe/lessons/lesson11/interactive_conspect.ipynb#X24sZmlsZQ%3D%3D?line=3'>4</a>\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39mf\u001b[39m\u001b[39m'\u001b[39m\u001b[39m{\u001b[39;00mpoint\u001b[39m.\u001b[39;49m__abscissa\u001b[39m \u001b[39m\u001b[39m= }\u001b[39;00m\u001b[39m; \u001b[39m\u001b[39m{\u001b[39;00mpoint\u001b[39m.\u001b[39m__ordinate\u001b[39m \u001b[39m\u001b[39m= }\u001b[39;00m\u001b[39m;\u001b[39m\u001b[39m'\u001b[39m)\n",
      "\u001b[1;31mAttributeError\u001b[0m: 'Point2D' object has no attribute '__abscissa'"
     ]
    }
   ],
   "source": [
    "point = Point2D()\n",
    "print(Point2D.__dict__)\n",
    "\n",
    "print(f'{point.__abscissa = }; {point.__ordinate = };')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Такие атрибуты называются чисто служебными. Детальное изучения атрибута \\_\\_dict\\_\\_ класса Point2D, код которого приведен в примере выше, показывает, что в момент определения класса, интерпретатор Python неявным образом подменяет имя чисто служебных атрибутов и сохраняет их в пространство имен класса под именем \\_Classname\\_\\_atributename. Т.е., зная эту деталь, мы все же можем получить доступ к данным атрибутам, минуя препятствия, созданные интерпретатором: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'__module__': '__main__', '__annotations__': {'_Point2D__abscissa': <class 'float'>, '_Point2D__ordinate': <class 'float'>}, '_Point2D__abscissa': 0, '_Point2D__ordinate': 0, '__dict__': <attribute '__dict__' of 'Point2D' objects>, '__weakref__': <attribute '__weakref__' of 'Point2D' objects>, '__doc__': None}\n",
      "point._Point2D__abscissa = 0; point._Point2D__ordinate = 0;\n",
      "point._Point2D__abscissa = 6; point._Point2D__ordinate = 0;\n"
     ]
    }
   ],
   "source": [
    "point = Point2D()\n",
    "print(Point2D.__dict__)\n",
    "\n",
    "print(f'{point._Point2D__abscissa = }; {point._Point2D__ordinate = };')\n",
    "point._Point2D__abscissa = 6\n",
    "print(f'{point._Point2D__abscissa = }; {point._Point2D__ordinate = };')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### property\n",
    "\n",
    "Встроенный декоратор **property** позволяет добавить в ваш класс дескриптор, ограничивающий доступ к тому или иному атрибуту через интерфейс. Стоит отметить, что property не решает проблему доступа полностью, но лишь позволяет описать интерфейс взаимодействия с тем или иным атрибутом. Так, например, с помощью property мы можем добавить в интерфейс нашего класса поля, доступные исключительно для чтения:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "from dataclasses import dataclass\n",
    "from typing import Any, Generator\n",
    "\n",
    "\n",
    "@dataclass\n",
    "class Vector2D:\n",
    "    _x: float = 0\n",
    "    _y: float = 0\n",
    "\n",
    "    def __iter__(self) -> Generator:\n",
    "        yield from (self._x, self._y)\n",
    "\n",
    "    def __abs__(self) -> float:\n",
    "        return sum(x_i ** 2 for x_i in self) ** 0.5\n",
    "\n",
    "    @property\n",
    "    def x(self) -> float:\n",
    "        return self._x\n",
    "\n",
    "    @property\n",
    "    def y(self) -> float:\n",
    "        return self._y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "vector.x = 2; vector.y = 7\n"
     ]
    },
    {
     "ename": "AttributeError",
     "evalue": "property 'x' of 'Vector2D' object has no setter",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32mc:\\Users\\Michail\\Desktop\\mipt\\teaching\\python_mipt_dafe\\lessons\\lesson11\\interactive_conspect.ipynb Cell 15\u001b[0m line \u001b[0;36m4\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/Users/Michail/Desktop/mipt/teaching/python_mipt_dafe/lessons/lesson11/interactive_conspect.ipynb#X36sZmlsZQ%3D%3D?line=0'>1</a>\u001b[0m vector \u001b[39m=\u001b[39m Vector2D(\u001b[39m2\u001b[39m, \u001b[39m7\u001b[39m)\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/Users/Michail/Desktop/mipt/teaching/python_mipt_dafe/lessons/lesson11/interactive_conspect.ipynb#X36sZmlsZQ%3D%3D?line=2'>3</a>\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39mf\u001b[39m\u001b[39m'\u001b[39m\u001b[39m{\u001b[39;00mvector\u001b[39m.\u001b[39mx\u001b[39m \u001b[39m\u001b[39m= }\u001b[39;00m\u001b[39m; \u001b[39m\u001b[39m{\u001b[39;00mvector\u001b[39m.\u001b[39my\u001b[39m \u001b[39m\u001b[39m= }\u001b[39;00m\u001b[39m'\u001b[39m)\n\u001b[1;32m----> <a href='vscode-notebook-cell:/c%3A/Users/Michail/Desktop/mipt/teaching/python_mipt_dafe/lessons/lesson11/interactive_conspect.ipynb#X36sZmlsZQ%3D%3D?line=3'>4</a>\u001b[0m vector\u001b[39m.\u001b[39;49mx \u001b[39m=\u001b[39m \u001b[39m-\u001b[39m\u001b[39m2\u001b[39m\n",
      "\u001b[1;31mAttributeError\u001b[0m: property 'x' of 'Vector2D' object has no setter"
     ]
    }
   ],
   "source": [
    "vector = Vector2D(2, 7)\n",
    "\n",
    "print(f'{vector.x = }; {vector.y = }')\n",
    "vector.x = -2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "При необходимости, с помощью propery мы можем включить перезапись значения того или иного атрибута в интерфейс:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from dataclasses import dataclass\n",
    "from typing import Generator\n",
    "\n",
    "\n",
    "@dataclass\n",
    "class Vector2D:\n",
    "    _x: float = 0\n",
    "    _y: float = 0\n",
    "\n",
    "    def __iter__(self) -> Generator:\n",
    "        yield from (self._x, self._y)\n",
    "\n",
    "    def __abs__(self) -> float:\n",
    "        return sum(x_i ** 2 for x_i in self) ** 0.5\n",
    "\n",
    "    @property\n",
    "    def x(self) -> float:\n",
    "        return self._x\n",
    "    \n",
    "    @x.setter\n",
    "    def x(self, x_new: float) -> None:\n",
    "        self._x = float(x_new)\n",
    "\n",
    "    @property\n",
    "    def y(self) -> float:\n",
    "        return self._y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "vector.x = 2; vector.y = 7\n",
      "vector.x = -2.0; vector.y = 7\n"
     ]
    }
   ],
   "source": [
    "vector = Vector2D(2, 7)\n",
    "\n",
    "print(f'{vector.x = }; {vector.y = }')\n",
    "vector.x = -2\n",
    "print(f'{vector.x = }; {vector.y = }')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Однако, как было сказано ранее, property не решает проблему полной инкапсуляции. Несмотря на возможность ограничения манипуляции с атрибутами через интерфейс, мы по-прежнему имеем доступ к реализации:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "vector._x = -2.0\n",
      "vector._x = 2\n"
     ]
    }
   ],
   "source": [
    "print(f'{vector._x = }')\n",
    "vector._x = 2\n",
    "print(f'{vector._x = }')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Наследование\n",
    "\n",
    "Концепция наследования позволяет сформулировать четкую иерархуию классов в вашем коде. Помимо этого, вы можете думать о наследовании, как о расширении функционала существующего класса и о средстве, позволяющим избежать дублирования кода. Классы, от которых происходит наследование, обычно называются родительскими классами, или суперклассами. В Python принят второй вариант наименования. Классы-наследники называются дочерними классами или сабклассами, в Python принят второй вариант именования.\n",
    "\n",
    "Как мы помним из предыдущей лекции, суперклассы указываются в момент создания нового класса. Синтаксически наследование выглядит следующим образом:\n",
    "\n",
    "```python\n",
    "class Derived(base-classes):\n",
    "    ...\n",
    "```\n",
    "\n",
    "В данном псевдокоде, `base-classes` - это последовательность выражений, разделенных запятыми. Результаты вычисления этих выражений - классы."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### MRO\n",
    "\n",
    "Из факта того, что `base-classes` - это последовательность выражений, можно сделать вывод о допустимости множественного наследования в Python, т.е. наш класс может расширять одновременно несколько классов и приходятся сабклассом одноврменное для нескольких суперклассов. Однако возможность множественного наследования ведет к большому количеству проблем. Самая популярная проблема - это, так называемая проблема ромба (англ. *diamond problem*).\n",
    "\n",
    "Проблема ромба заключается в следующем: предположим у нас есть некоторый класс, который обладает некоторым методом. Для конкретики представим, что имеется класс `Parallelogram`, у которого есть метод `area`. У данного супер класса есть два сабкласса `Rectangle` и `Rhombus`, которые переопределяют метод area исходного класса. Также есть класс `Square`, который является сабклассом и для класса `Rectangle`, и для класса `Rhombus`. Мы создаем экземпляр класса Square и вызываем у него метод area, метод какого класса будет вызван? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Parallelogram:\n",
    "    def area(self) -> None:\n",
    "        print('parallelogram area')\n",
    "\n",
    "\n",
    "class Rectangle(Parallelogram):\n",
    "    def area(self) -> None:\n",
    "        print('rectangle area')\n",
    "\n",
    "\n",
    "class Rhombus(Parallelogram):\n",
    "    def area(self) -> None:\n",
    "        print('rhombus area')\n",
    "\n",
    "\n",
    "class Square(Rectangle, Rhombus):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "rectangle area\n"
     ]
    }
   ],
   "source": [
    "square = Square()\n",
    "square.area()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Данный пример иллюстрирует две вещи: первая вещь - возможность переопределять атрибуты суперкласса в сабклассе, об этой возможности мы поговорим чуть позже; вторая вещь - это стратегия для решения проблемы ромба в Python. Как мы видим, в качестве метода area наш класс Square использует метод класса Rectangle. Но почему?\n",
    "\n",
    "В момент определения класса Python сохраняет весь граф наследования в специальный атрибут, который называется \\_\\_mro\\_\\_. Это сокращение от английского method resolution order, т.е. порядок разрешения методов. \\_\\_mro\\_\\_ - это специальный атрибут класса, в котором хранится порядок обхода графа наследования для поиска того или иного атрибута. Сам алгоритм поиска мы обсуждали на предыдущей лекции. Давайте посмотрим на порядок обхода классов для поиска аттрибута и освежим в памяти этот самый алгоритм поиска. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(<class '__main__.Square'>, <class '__main__.Rectangle'>, <class '__main__.Rhombus'>, <class '__main__.Parallelogram'>, <class 'object'>)\n"
     ]
    }
   ],
   "source": [
    "print(Square.__mro__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Итак, при попытке вызвать метод area у экземпляра класса Square, интерпретатор пытается найти переопределяющий дескрипток в классе Square. Поскольку класс Square не содержит в себе подобного дескриптора, интерпретатор пытается найти имя area в атрибуте \\_\\_dict\\_\\_ экземпляра класса Square. Но данный атрибут пуст. Тогда интерпретатор пытается найти указанное имя в атрибуте \\_\\_dict\\_\\_ самого класса Square, но и этот атрибут не содержит нужного имени. Тогда интерпретатор начинает поиск в следующем элементе кортежа \\_\\_mro\\_\\_, т.е. в классе Rectangle. Атрибут \\_\\_dict\\_\\_ данного класса содержит искомое имя, интерпретатор использует найденное в Rectangle значение для имени area в качестве результата поиска, а сам поиск на этом завершается.\n",
    "\n",
    "Но почему классы в атрибуте \\_\\_mro\\_\\_ расположены именно в такой последовательности? И что в этом кортеже делает класс `object`? Ответ на первый вопрос достаточно сложный, однако, если упростить алгоритм обхода графа наследования, то он будет представлять из себя следующую конструкцию. Чем ближе суперклассы к сабклассу в графе наследования, тем левее они будут находится в кортеже \\_\\_mro\\_\\_, более того, при множественном наследовании, классы, указанные левее, будут располагаться левее и в \\_\\_mro\\_\\_. Собственно, это явно и илюстрирует полученный кортеж. Классы, от которых мы наследовались напрямую, расположены ближе к левой границе массива. При этом, порядок их расположения соответствует порядку из следования в области наследования при определении нашего класса Square.\n",
    "\n",
    "Ответ на второй вопрос состоит в следующем: даже при отсутствии наследования, все объекты Python неявно наследуются от встроенного типа данных object, который описывает объекты Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### super()\n",
    "\n",
    "Предположим, что в предыдущем примере мы бы хотели переопределить функцию area в классе Square. Однако наша переопределенная функция не должна перекрывать функцию суперкласса, но лишь дополнять ее поведение. Как нам быть в этом случае? Вообще, ничего не мешает нам вызвать нужную функцию, явно указав базовый класс, чей метод мы хотели бы модифицировать. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Parallelogram:\n",
    "    def area(self) -> None:\n",
    "        print('parallelogram area')\n",
    "\n",
    "\n",
    "class Rectangle(Parallelogram):\n",
    "    def area(self) -> None:\n",
    "        print('rectangle area')\n",
    "\n",
    "\n",
    "class Rhombus(Parallelogram):\n",
    "    def area(self) -> None:\n",
    "        print('rhombus area')\n",
    "\n",
    "\n",
    "class Square(Rectangle, Rhombus):\n",
    "    def area(self) -> None:\n",
    "        Rhombus.area(self)\n",
    "        print('square area')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "rhombus area\n",
      "square area\n"
     ]
    }
   ],
   "source": [
    "square = Square()\n",
    "square.area()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Однако, в этом случае нам приходится держать в голове порядок обхода графа наследования, чтобы точно знать, у какого именно класса нам необходимо вызвать нужный метод. Чтобы избежать этой головной боли мы можем использовать встроенный объект `super()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Parallelogram:\n",
    "    def area(self) -> None:\n",
    "        print('parallelogram area')\n",
    "\n",
    "\n",
    "class Rectangle(Parallelogram):\n",
    "    def area(self) -> None:\n",
    "        print('rectangle area')\n",
    "\n",
    "\n",
    "class Rhombus(Parallelogram):\n",
    "    def area(self) -> None:\n",
    "        print('rhombus area')\n",
    "\n",
    "\n",
    "class Square(Rectangle, Rhombus):\n",
    "    def area(self) -> None:\n",
    "        super().area()\n",
    "        print('square area')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "rectangle area\n",
      "square area\n"
     ]
    }
   ],
   "source": [
    "square = Square()\n",
    "square.area()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Во-первых, данный подход является более элегантным. Во-вторых, данный подход требует от вас меньше умственных усилий, поскольку super осуществит поиск нужного атрибута среди суперклассов графа наследования и вернет значение первого найденного. Однако, если вам необходимо осуществить поиск конкретного атрибута в конкретном суперклассе, минуя метод разрешения методов, вы всегда можете воспользоваться явным вызовом метода класса, как это было в примере выше. \n",
    "\n",
    "Вызов super необходим при инициализации экземпляра сабкласса:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Parent:\n",
    "    def __init__(self) -> None:\n",
    "        print('init Parent')\n",
    "\n",
    "\n",
    "class ChildWrong(Parent):\n",
    "    def __init__(self) -> None:\n",
    "        print('init ChildWrong')\n",
    "\n",
    "\n",
    "class ChaildNaive(Parent):\n",
    "    pass\n",
    "\n",
    "\n",
    "class ChildGood(Parent):\n",
    "    def __init__(self) -> None:\n",
    "        super().__init__()\n",
    "        print('init ChildGood')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "init ChildWrong\n",
      "init Parent\n",
      "init Parent\n",
      "init ChildGood\n"
     ]
    }
   ],
   "source": [
    "child_wrong = ChildWrong()\n",
    "child_naive = ChaildNaive()\n",
    "child_good = ChildGood()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В данном примере показано два важных положения. Первое: если сабкласс не переопределяет метод init, то для инициализации его экземпляров будет использоваться соответствующий метод суперкласса. Второе: при переопределении метода init в сабклассе метод init суперкласса не вызывается неявным образом, его необходимо вызывать явно. Причем, если имеет место мультинаследование, то вызова super будет недостаточно, поскольку, как обсуждалось выше, super прервет выполнение найдя нужный атрибут в одном из суперклассов:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "class A:\n",
    "    def __init__(self) -> None:\n",
    "        print('init A')\n",
    "\n",
    "\n",
    "class B:\n",
    "    def __init__(self) -> None:\n",
    "        print('init B')\n",
    "\n",
    "\n",
    "class C(A, B):\n",
    "    def __init__(self) -> None:\n",
    "        super().__init__()\n",
    "        print('init C')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "init A\n",
      "init C\n"
     ]
    }
   ],
   "source": [
    "c_instance = C()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Корректная реализация данного класса выглядила бы следующим образом:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "class A:\n",
    "    def __init__(self) -> None:\n",
    "        print('init A')\n",
    "\n",
    "\n",
    "class B:\n",
    "    def __init__(self) -> None:\n",
    "        print('init B')\n",
    "\n",
    "\n",
    "class C(A, B):\n",
    "    def __init__(self) -> None:\n",
    "        A.__init__(self)\n",
    "        B.__init__(self)\n",
    "        \n",
    "        print('init C')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "init A\n",
      "init B\n",
      "init C\n"
     ]
    }
   ],
   "source": [
    "c_instance = C()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Полиморфизм\n",
    "\n",
    "Концепция полиморфизма заключается в унификации точки входа в определенную операцию для разных типов данных или комбинаций аргементов. Мы уже знакомы с полиморфизмом на примере вногих втроенных функций. Ярким примером может быть функция `len()`. Данная функция способна принимать на вход список, кортеж, словарь, любой объект, реализующий функцию \\_\\_len\\_\\_(). Т.е. это единая точка входа в операции определения размера для объектов различных типов данных.\n",
    "\n",
    "В ООП под полиморфизмом обычно понимают полиморфизм классов. Т.е. наличие в классах методов с одинаковыми сигнатурами, однако реализующими операции, исходя из логики самого класса. Для демонстрации полиморфизма классов рассмотрим один из примеров, приведенных выше."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Parallelogram:\n",
    "    def area(self) -> None:\n",
    "        print('parallelogram area')\n",
    "\n",
    "\n",
    "class Rectangle(Parallelogram):\n",
    "    def area(self) -> None:\n",
    "        print('rectangle area')\n",
    "\n",
    "\n",
    "class Rhombus(Parallelogram):\n",
    "    def area(self) -> None:\n",
    "        print('rhombus area')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "parallelogram area\n",
      "rectangle area\n",
      "rhombus area\n"
     ]
    }
   ],
   "source": [
    "polygons = [Parallelogram(), Rectangle(), Rhombus()]\n",
    "\n",
    "for polygon in polygons:\n",
    "    polygon.area()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как мы видим, в данном случае классы обладают полиморфной функцией area. Благодаря этому мы можем работать схожим образом с тремя разными экземплярами трех разных классов.\n",
    "\n",
    "Подобный полиморфизм классов приводит нас к понятию протоколов. Говоря о протаколе, мы подразумеваем, что объект реализует некоторый функционал. Например, мы знакомы с вами с протоколом последовательностей. Когда мы говорили, что объект является последовательность, мы подразумевали, что он ведет себя как последовательсноть, т.е. поддерживает определенный набор операций.\n",
    "\n",
    "Понятие протокола является неформальным, это значит, что обычно нам не приходится проверять соответствие объекта определенному типу данных. Вместо этого мы просто пытаемся работать с полученным объектом, как с представителем данного протокола. Если у нас получается обработать его нужным образом - хорошо, не получается - значит объект не удовлетворял требуемому протоколу. \n",
    "\n",
    "Ярким примером данного принципа может служить стремление интерпретатора обрабатывать объект, частично реализующий протокол последовательности, как последовательность:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Iterable, Union, Any\n",
    "\n",
    "\n",
    "class MySequence:\n",
    "    _iterable: list\n",
    "\n",
    "    def __init__(self, iterable: Iterable) -> None:\n",
    "        self._iterable = list(iterable)\n",
    "\n",
    "    def __getitem__(self, index: Union[int, slice]) -> Any:\n",
    "        return self._iterable[index]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "my_seq = MySequence((1, 2, 3, 4))\n",
    "\n",
    "for elem in my_seq:\n",
    "    print(elem)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Абстракция\n",
    "\n",
    "Последняя концепция ООП - это абстракция. Абстракция - это выделение в моделируемом предмете важного для решения конкретной задачи. Абстракции являются более формальными протоколами, посколько они строго определены. Если, как мы видели выше, для обработки объекта по протоколу последовательностей не требуется строгого соответствия протоколу последовательности, то при разработке абстракций, от объекта, наследующего некоторый абстрактный интерфейс, требуется четкое соответствие ему. \n",
    "\n",
    "Для реализации обстракций в коде используют абстрактные базовые классы. Это специальные классы, которые описывают четкий интерфес взаимодействия с объектами, но при этом не реализующие его. Создать экземпляр абстрактного класса невозможно. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "import abc\n",
    "\n",
    "\n",
    "class Polygon(abc.ABC):\n",
    "    @abc.abstractmethod\n",
    "    def area(self) -> float:\n",
    "        ...\n",
    "\n",
    "\n",
    "class Square(Polygon):\n",
    "    _side_len: float\n",
    "\n",
    "    def __init__(self, side_len: float) -> None:\n",
    "        self._side_len = float(side_len)\n",
    "\n",
    "    def area(self) -> float:\n",
    "        return self._side_len ** 2\n",
    "    \n",
    "    @property\n",
    "    def side_len(self) -> float:\n",
    "        return self._side_len\n",
    "    \n",
    "\n",
    "class Rectangle(Polygon):\n",
    "    _length: float\n",
    "    _width: float\n",
    "\n",
    "    def __init__(self, length: float, width: float) -> None:\n",
    "        self._length = float(length)\n",
    "        self._width = float(width)\n",
    "\n",
    "    def area(self) -> float:\n",
    "        return self._length * self._width\n",
    "    \n",
    "    @property\n",
    "    def length(self) -> float:\n",
    "        return self._length\n",
    "    \n",
    "    @property\n",
    "    def width(self) -> float:\n",
    "        return self._width"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "square: 16.0; rect: 15.0;\n"
     ]
    }
   ],
   "source": [
    "square = Square(4)\n",
    "rectangle = Rectangle(3, 5)\n",
    "\n",
    "print(f'square: {square.area()}; rect: {rectangle.area()};')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "Can't instantiate abstract class Polygon with abstract method area",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32mc:\\Users\\Michail\\Desktop\\mipt\\teaching\\python_mipt_dafe\\lessons\\lesson11\\interactive_conspect.ipynb Cell 51\u001b[0m line \u001b[0;36m1\n\u001b[1;32m----> <a href='vscode-notebook-cell:/c%3A/Users/Michail/Desktop/mipt/teaching/python_mipt_dafe/lessons/lesson11/interactive_conspect.ipynb#Y206sZmlsZQ%3D%3D?line=0'>1</a>\u001b[0m polygon \u001b[39m=\u001b[39m Polygon()\n",
      "\u001b[1;31mTypeError\u001b[0m: Can't instantiate abstract class Polygon with abstract method area"
     ]
    }
   ],
   "source": [
    "polygon = Polygon()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как вы видите, абстрактный базовый класс не подерживает создание экземпляров. Абстрактный базовый класс может включать как обычные методы, так и чисто виртуальные методы, как в данном примере. При этом, если абстрактный базовый класс включает в себя методы с реализацией, то реализация должна состоять только из вызовов методов описываемого интерфейса, без ограничения возможностей внутренний реализации объектов. Классы, наследующиеся от абстрактного базового класса обязаны реализовать в себе чисто виртуальные методы, иначе итерпретатор будет считать их виртуальными классами и не позволит создавать экземпляры. При этом, классы наследники могут дополнять интерфейс исходного базового класса."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Абстрактные базовые классы и чистые интерфейсы - это большая редкость в Python. Большая часть объектов реализуются как представители определнных протоколов. На практике, вам врят ли придется реализовывать свой абстрактный базовый класс."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}