lectures/03-classes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Практикум по программированию на языке Python\n",
    "\n",
    "## <font color='lilac'>Занятие 3: Основы ООП: особенности языка, атрибуты, наследование</font>\n",
    "\n",
    "#### Мурат Апишев (mel-lain@yandex.ru)\n",
    "#### Москва, 2025"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Парадигмы проектирования кода</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Императивное программирование (язык ассемблера)\n",
    "\n",
    "`mov ecx, 7`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Декларативное программирование (SQL)\n",
    "\n",
    "`select * from table where index % 10 == 0`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Подвид: функциональное программирование (Haskell)\n",
    "\n",
    "`filter even [1..10]`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Объектно-ориентированное программирование (С++)\n",
    "\n",
    "`auto car = new Car(); a.fill_up(10)`;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Объектно-ориентированное программирование</font>\n",
    "\n",
    "- Программа, как и окружающий мир, состоит из сущностей\n",
    "- Сущности имеют какое-то внутренее состояние\n",
    "- Также сущности взаимодействуют друг с другом\n",
    "- ООП нужно для описания программы в виде сущностей и их взаимоотношений\n",
    "- При этом и на сущности, и на отношения накладываются ограничения\n",
    "- Это позволяет писать более короткий, простой и переиспользуемый код"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Базовые понятия: класс и объект</font>\n",
    "\n",
    "- __Класс__ представляет собой тип данных (как int или str)\n",
    "- Это способ описания некоторой сущности, её состояния и возможного поведения\n",
    "- Поведение при этом зависит от состояния и может его изменять"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- __Объект__ - это конретный представитель класса (как переменная этого типа)\n",
    "- У объекта своё состояние, изменяемое поведением\n",
    "- Поведение полностью определяется правилами, описанными в классе"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Базовые понятия: интерфейс</font>\n",
    "\n",
    "- __Интерфейс__ - это класс, описывающий только поведение\n",
    "- У интерфейса нет состояния\n",
    "- Как следствие, создать объект типа интерфейса невозможно\n",
    "- Вместо этого описываются классы, которые реализуют этот интерфейс и, в то же время, имеют состояние\n",
    "- С помощью интерфейсов реализуется полиморфизм (будет далее)\n",
    "- Программирование на уровне интерфейсов делает код читаемее и проще\n",
    "- Интерфейсы в некоторых языках (например, Java) решают проблему отсутствия множественного наследования"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Интерфейс: пример</font>\n",
    "\n",
    "`interface SomeCar {`\n",
    "\n",
    "$\\quad$`fill_up(gas_volume)`\n",
    "\n",
    "$\\quad$`turn_on()`\n",
    "\n",
    "$\\quad$`turn_off()`\n",
    "\n",
    "`}`\n",
    "\n",
    "__Интерфейс:__\n",
    "\n",
    "- не содержит информации о состоянии автомобиля\n",
    "- не содержит информации о том, как выполнять описанные команды\n",
    "- он только описывает то, какие операции должны быть доступны над объектом, который претендует на то, чтобы быть автомобилем"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Реализация интерфейса</font>\n",
    "\n",
    "`class ConcreteCar(SomeCar) {`\n",
    "\n",
    "$\\quad$`fill_up(gas_volume) { tank += gas_volume }`\n",
    "\n",
    "$\\quad$`turn_on() { is_turned_on = true }`\n",
    "\n",
    "$\\quad$`turn_off() { is_turned_on = false }`\n",
    "\n",
    "$\\quad$`tank = 0`\n",
    "\n",
    "$\\quad$`is_turned_on = false`\n",
    "\n",
    "`}`\n",
    "\n",
    "- Обычно данные класса называют _полями_ (или _атрибутами_), а функции - _методами_ \n",
    "- **Абстрактный класс** - промежуточный вариант между интерфейсом и обычным классом"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Принципы ООП</font>\n",
    "\n",
    "- **Абстракция** - выделение важных свойств объекта и игнорирование прочих\n",
    "\n",
    "- **Инкапсуляция** - хранение данных и методов работы с ними внутри одного класса с доступом к данным только через методы\n",
    "\n",
    "- **Наследование** - возможность создания наследников, получающих все свойства родителей с возможностью их переопределения и расширения\n",
    "\n",
    "- **Полиморфизм** - возможность использования объектов разных типов с общим интерфейсом без информации об их внутреннем устройстве"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>ООП в Python</font>\n",
    "\n",
    "- Python - это полностью объектно-ориентированный язык\n",
    "\n",
    "- В Python абсолютно всё является объектами, включая классы\n",
    "\n",
    "- Полностью поддерживаются все принципы ООП, кроме инкапсуляции\n",
    "\n",
    "- Инкапсуляция поддерживается частично: нет ограничения на доступ к полям класса\n",
    "\n",
    "- Поэтому для инкапсуляции используют договорные соглашения"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Так выглядят классы в Python</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'color']\n",
      "red\n",
      "blue\n",
      "<class '__main__.ConcreteCar'> <class '__main__.ConcreteCar'>\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "class Simple:\n",
    "    color = 'blue'\n",
    "\n",
    "simp = Simple()\n",
    "print(simp.color)\n",
    "simp.color = 'red'\n",
    "print(simp.color)\n",
    "print(Simple.color)\n",
    "\n",
    "class ConcreteCar:\n",
    "    def __init__(self):\n",
    "        self.tank = 0\n",
    "        self.is_turned_on = False\n",
    "\n",
    "    def fill_up(self, gas_volume):\n",
    "        self.tank += gas_volume\n",
    "\n",
    "    def turn_on(self):\n",
    "        self.is_turned_on = True\n",
    "\n",
    "    def turn_off(self):\n",
    "        self.is_turned_on = False\n",
    "        \n",
    "car = ConcreteCar()\n",
    "print(type(car), car.__class__)\n",
    "\n",
    "car.fill_up(10)\n",
    "print(car.tank)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Функция \\_\\_init\\_\\_</font>\n",
    "\n",
    "- Главное: `__init__` - не конструктор! Она ничего не создаёт и не возвращает\n",
    "\n",
    "- Созданием объекта занимается функция `__new__`, переопределять которую без необходимости не надо\n",
    "\n",
    "- `__init__` получает на вход готовый объект и инициализирует его атрибуты\n",
    "\n",
    "В отличие от C++, атрибуты можно добавлять/удалять на ходу:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "field\n"
     ]
    }
   ],
   "source": [
    "class Cls:\n",
    "    pass\n",
    "\n",
    "cls = Cls()\n",
    "cls.field = 'field'\n",
    "print(cls.field)\n",
    "\n",
    "del cls.field\n",
    "print(cls.field)  # AttributeError: 'Cls' object has no attribute 'field'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Параметр self</font>\n",
    "\n",
    "- Метод класса отличается от обычной функции только наличием объекта `self` в качестве первого аргумента \n",
    "- Это то же самое, что происходит в C++/Java (там аналогом `self` является указатель/ссылка `this`) \n",
    "- Название `self` является общим соглашением, но можно использовать и другое (не надо!)\n",
    "- Метод класса, не получающий на вход `self` является _статическим_\n",
    "- Статические методы часто используются для специализированного создания объектов класса\n",
    "- Еще есть _методы класса_, входом у них является класс как объект\n",
    "- В Python `__new__` является статическим методом"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Как быть с инкапсуляцией</font>\n",
    "\n",
    "- Приватное поле прежде всего должно быть обозначено таковым\n",
    "- В Python для этого есть соглашения:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ok\n",
      "You're shouldn't see it\n"
     ]
    },
    {
     "ename": "AttributeError",
     "evalue": "'Cls' object has no attribute '__mangled_field'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[6], line 10\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;28mcls\u001b[39m\u001b[38;5;241m.\u001b[39mpublic_field)\n\u001b[1;32m      9\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;28mcls\u001b[39m\u001b[38;5;241m.\u001b[39m_private_field)\n\u001b[0;32m---> 10\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;28;43mcls\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m__mangled_field\u001b[49m)\n",
      "\u001b[0;31mAttributeError\u001b[0m: 'Cls' object has no attribute '__mangled_field'"
     ]
    }
   ],
   "source": [
    "class Cls:\n",
    "    def __init__(self):\n",
    "        self.public_field = 'Ok'\n",
    "        self._private_field = \"You're shouldn't see it\"\n",
    "        self.__mangled_field = \"YOU REALLY SHOULDN'T SEE IT!!!\"\n",
    "\n",
    "cls = Cls()\n",
    "print(cls.public_field)\n",
    "print(cls._private_field)\n",
    "print(cls.__mangled_field)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "YOU REALLY SHOULDN'T SEE IT!!!\n"
     ]
    }
   ],
   "source": [
    "print(cls._Cls__mangled_field)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Атрибуты объекта и класса</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n",
      "['some_obj_attr']\n"
     ]
    }
   ],
   "source": [
    "class Cls:\n",
    "    pass\n",
    "\n",
    "cls = Cls()\n",
    "print([e for e in dir(cls) if not e.startswith('__')])\n",
    "\n",
    "cls.some_obj_attr = '1'\n",
    "print([e for e in dir(cls) if not e.startswith('__')])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n",
      "['some_cls_attr']\n",
      "['some_cls_attr', 'some_obj_attr']\n"
     ]
    }
   ],
   "source": [
    "print([e for e in dir(Cls) if not e.startswith('__')])\n",
    "\n",
    "Cls.some_cls_attr = '1'\n",
    "print([e for e in dir(Cls) if not e.startswith('__')])\n",
    "print([e for e in dir(cls) if not e.startswith('__')])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Переменная \\_\\_dict\\_\\_</font>\n",
    "\n",
    "- Для большого числа типов в Python пределена переменная-словарь `__dict__`\n",
    "- Она содержит атрибуты, специфичные для данного объекта (не его класса и не его родителей)\n",
    "- Множество элементов `__dict__` является подмножеством элементов, возвращаемых функцией `dir()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    },
    {
     "ename": "AttributeError",
     "evalue": "'list' object has no attribute '__dict__'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-91-5da0a70fb2a1>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mA\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__dict__\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mkeys\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0missubset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdir\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mA\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__dict__\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: 'list' object has no attribute '__dict__'"
     ]
    }
   ],
   "source": [
    "class A: pass\n",
    "\n",
    "print(set(A.__dict__.keys()).issubset(set(dir(A))))\n",
    "\n",
    "[].__dict__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Доступ к атрибутам</font>\n",
    "\n",
    "- Для работы с атрибутами есть функции `getattr`, `setattr` и `delattr`\n",
    "- Их основное преимущество - оперирование именами атрибутов в виде строк"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "some\n"
     ]
    },
    {
     "ename": "AttributeError",
     "evalue": "'Cls' object has no attribute 'some_attr'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[8], line 9\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;28mgetattr\u001b[39m(\u001b[38;5;28mcls\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124msome_attr\u001b[39m\u001b[38;5;124m'\u001b[39m))\n\u001b[1;32m      7\u001b[0m \u001b[38;5;28mdelattr\u001b[39m(\u001b[38;5;28mcls\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124msome_attr\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[0;32m----> 9\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;28;43mgetattr\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mcls\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43msome_attr\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m)\n",
      "\u001b[0;31mAttributeError\u001b[0m: 'Cls' object has no attribute 'some_attr'"
     ]
    }
   ],
   "source": [
    "cls = Cls()\n",
    "\n",
    "setattr(cls, 'some_attr', 'some')\n",
    "\n",
    "print(getattr(cls, 'some_attr'))\n",
    "\n",
    "delattr(cls, 'some_attr')\n",
    "\n",
    "print(getattr(cls, 'some_attr'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Class magic methods</font>\n",
    "\n",
    "- Магические методы придают объекту класса определённые свойства\n",
    "- Такие методы получают `self` вызываются интерпретатором неявно\n",
    "- Например, операторы - это магические методы<bf>\n",
    "\n",
    "Рассмотрим несколько примеров:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Some class\n",
      "[Cls(Some class)]\n",
      "Some classSome class\n"
     ]
    }
   ],
   "source": [
    "class Cls:\n",
    "    def __init__(self, name):  # initialize object\n",
    "        self.name = name\n",
    "    \n",
    "    def __str__(self):\n",
    "        return self.name\n",
    "    \n",
    "    def __repr__(self):  # str for printing object\n",
    "        return f'Cls({self.name})'\n",
    "    \n",
    "    def __call__(self, counter):  # call == operator() in C++\n",
    "        return self.name * counter\n",
    "\n",
    "cls = Cls('Some class')\n",
    "print(cls)\n",
    "print([cls])  # == print(cls)\n",
    "print(cls(2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color='lilac'>Class magic methods</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как выбирается метод при наличии парного, например, `__add__` и `__radd__` для `x + y`:\n",
    "\n",
    "1. ищется `x.__add__()`\n",
    "2. если нашёлся этот метод, то он и вызывается\n",
    "3. если выполнился успешно, то всё\n",
    "4. если `x.__add__()` не нашёлся или вернул специальный объект `NotImplemented` («не знаю я, что с вашим `y` делать!»), ищется метод `y.__radd__()`\n",
    "5. и, наконец, если последний нашёлся — выполняется, если нет — `TypeError`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ClsLeft:\n",
    "    def __add__(self, add):\n",
    "        print(f'__add__ у {self.__class__.__name__}')\n",
    "        return NotImplemented\n",
    "\n",
    "\n",
    "class ClsRight:\n",
    "    def __radd__(self, add):\n",
    "        print(f'__radd__ у {self.__class__.__name__}')\n",
    "        return ClsRight()\n",
    "\n",
    "\n",
    "ClsLeft() + ClsRight()\n",
    "print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Class magic methods</font>\n",
    "\n",
    "Ещё примеры магических методов:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def __lt__(self, other): pass\n",
    "\n",
    "def __eq__(self, other): pass\n",
    "\n",
    "def __add__(self, other): pass\n",
    "\n",
    "def __mul__(self, value): pass\n",
    "\n",
    "def __int__(self): pass\n",
    "\n",
    "def __bool__(self): pass\n",
    "\n",
    "def __hash__(self): pass\n",
    "\n",
    "def __getitem__(self, index): pass\n",
    "\n",
    "def __setitem__(self, index, value): pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Как на самом деле устроен доступ к атрибутам</font>\n",
    "\n",
    "При работе с атрибутами вызываются магические методы `__getattr__`, `__getattribute__`, `__setattr__` и `__delattr__`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Cls:\n",
    "    def __setattr__(self, attr, value):\n",
    "        print(f'Create attr with name \"{attr}\" and value \"{value}\"')\n",
    "        self.__dict__[attr] = value\n",
    "\n",
    "    def __getattr__(self, attr):\n",
    "        print(f'WE WILL ENTER IT ONLY IN CASE OF ERROR!')\n",
    "        return self.__dict__[attr]\n",
    "\n",
    "    def __getattribute__(self, attr):\n",
    "        if not attr.startswith('__'):\n",
    "            print(f'Get value of attr with name \"{attr}\"')\n",
    "            \n",
    "        return super().__getattribute__(attr)  # call parent method implementation\n",
    "        \n",
    "    def __delattr__(self, attr):\n",
    "        print(f'Remove attr \"{attr}\" is impossible!')\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Как на самом деле устроен доступ к атрибутам</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Create attr with name \"some_attr\" and value \"some\"\n",
      "Get value of attr with name \"some_attr\"\n",
      "Remove attr \"some_attr\" is impossible!\n",
      "Get value of attr with name \"some_attr\"\n",
      "Get value of attr with name \"non_exists_attr\"\n",
      "WE WILL ENTER IT ONLY IN CASE OF ERROR!\n"
     ]
    },
    {
     "ename": "KeyError",
     "evalue": "'non_exists_attr'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[22], line 8\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[38;5;28;01mdel\u001b[39;00m \u001b[38;5;28mcls\u001b[39m\u001b[38;5;241m.\u001b[39msome_attr \u001b[38;5;66;03m#\u001b[39;00m\n\u001b[1;32m      7\u001b[0m b \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mcls\u001b[39m\u001b[38;5;241m.\u001b[39msome_attr\n\u001b[0;32m----> 8\u001b[0m \u001b[38;5;28;43mcls\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnon_exists_attr\u001b[49m\n",
      "Cell \u001b[0;32mIn[21], line 8\u001b[0m, in \u001b[0;36mCls.__getattr__\u001b[0;34m(self, attr)\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__getattr__\u001b[39m(\u001b[38;5;28mself\u001b[39m, attr):\n\u001b[1;32m      7\u001b[0m     \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mWE WILL ENTER IT ONLY IN CASE OF ERROR!\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[0;32m----> 8\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;18;43m__dict__\u001b[39;49m\u001b[43m[\u001b[49m\u001b[43mattr\u001b[49m\u001b[43m]\u001b[49m\n",
      "\u001b[0;31mKeyError\u001b[0m: 'non_exists_attr'"
     ]
    }
   ],
   "source": [
    "cls = Cls()\n",
    "\n",
    "cls.some_attr = 'some'\n",
    "a = cls.some_attr\n",
    "\n",
    "del cls.some_attr #\n",
    "b = cls.some_attr\n",
    "cls.non_exists_attr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Магические методы и менеджер контекста</font>\n",
    "\n",
    "Менеджер контекста (оператор `with`) работает с двумя магическими методами:\n",
    "\n",
    "- `__enter__` - код, который нужно выполнить над объектом при входе в блок менеджера\n",
    "- `__exit__` - код, который нужно в любом случае выполнить при выходе из блока"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set DB to read-write mode\n",
      "Set DB to read-only mode\n",
      "(1,)\n"
     ]
    }
   ],
   "source": [
    "class SomeDataBaseDao:\n",
    "    def __init__(self): self._db = ()\n",
    "    \n",
    "    def append(self, value): self._db.append(value)\n",
    "    \n",
    "    def __enter__(self):\n",
    "        self._db = list(self._db)\n",
    "        print('Set DB to read-write mode')\n",
    "        return self\n",
    "\n",
    "    def __exit__(self, exception_type, exception_val, trace):\n",
    "        self._db = tuple(self._db)\n",
    "        print('Set DB to read-only mode')\n",
    "        return True\n",
    "\n",
    "dao = SomeDataBaseDao()\n",
    "#dao.append(1)  # AttributeError: 'tuple' object has no attribute 'append'\n",
    "with dao:\n",
    "    dao.append(1)\n",
    "print(dao._db)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Наследование в Python</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 10 10\n",
      "{'value': 10}\n",
      "{'value': 10, 'new_value': 20}\n"
     ]
    }
   ],
   "source": [
    "class Parent:\n",
    "    def __init__(self):\n",
    "        self.value = 10\n",
    "    \n",
    "    def get_value(self):\n",
    "        return self.value\n",
    "\n",
    "class Child(Parent):\n",
    "    pass\n",
    "\n",
    "class NewChild(Parent):\n",
    "    def __init__(self):\n",
    "        super().__init__()  # without it we will not have `value` field\n",
    "        self.new_value = 20\n",
    "    \n",
    "print(Parent().get_value(), Child().get_value(), NewChild().get_value())\n",
    "\n",
    "print(Child().__dict__)\n",
    "print(NewChild().__dict__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Перегрузка родительских методов</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "20\n",
      "10\n",
      "Value: 10\n"
     ]
    }
   ],
   "source": [
    "class Parent:\n",
    "    def __init__(self, value):\n",
    "        self._value = value\n",
    "    \n",
    "    def get_value(self):\n",
    "        return self._value\n",
    "\n",
    "    def __str__(self):\n",
    "        return f'Value: {self._value}'\n",
    "\n",
    "class Child(Parent):\n",
    "    def __init__(self, value):\n",
    "        Parent.__init__(self, value)  # == super().__init__(value)\n",
    "\n",
    "    def get_value(self):\n",
    "        return Parent.get_value(self) * 2  # == super().get_value() * 2\n",
    "\n",
    "print(Parent(10).get_value())\n",
    "print(Child(10).get_value())\n",
    "print(Child(10)._value)\n",
    "print(Child(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color='lilac'>Искаженные (mangled) атрибуты</font>\n",
    "\n",
    "Главное название такого именования - борьба с коллизией важных полей при наследовании (аналог `final` атрибутов в Java):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'_Parent__variable': 'Parent'}\n",
      "{'_Child__variable': 'Child'}\n"
     ]
    }
   ],
   "source": [
    "class Parent:\n",
    "    def __init__(self):\n",
    "        self.__variable = 'Parent'\n",
    "\n",
    "class Child(Parent):\n",
    "    def __init__(self):\n",
    "        self.__variable = 'Child'\n",
    "\n",
    "print(Parent().__dict__)\n",
    "print(Child().__dict__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Множественное наследование</font>\n",
    "\n",
    "- Даёт возможность классу получить методы и свойства сразу нескольких предков\n",
    "- Позволяет строить сложные иерархии зависимостей\n",
    "- Использовать без необходимости не нужно, поскольку архитектура кода сильно усложняется\n",
    "- В Python поддерживается без ограничений\n",
    "- У класса может быть один и более предков (`object` есть всегда)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Множественное наследование в Python</font>\n",
    "- Методы и атрибуты ищутся в следующем порядке:\n",
    "    1. имя ищется в объекте (т.е. в его `__dict__`)\n",
    "    2. дальше в классе объекта\n",
    "    3. дальше в предках класса\n",
    "- Для поиска по предкам используется MRO (Method resolution order)\n",
    "- У каждого класса в момент создания вычисляется этот порядок и сохраняется в атрибуте `__mro__`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)\n",
      "A\n"
     ]
    }
   ],
   "source": [
    "class A():\n",
    "    def method(self): return 'A'\n",
    "\n",
    "class B():\n",
    "    def method(self): return 'B'\n",
    "\n",
    "class C(A, B): pass\n",
    "\n",
    "print(C.__mro__)\n",
    "print(C().method())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Вызов метода класса-родителя</font>\n",
    "\n",
    "- В Python есть два способа обращения к родительским методам\n",
    "    - через функцию `super` (использует порядок mro)\n",
    "    - напрямую по имени"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)\n",
      "('A', 'B', 'A')\n"
     ]
    }
   ],
   "source": [
    "class A():\n",
    "    def method(self): return 'A'\n",
    "\n",
    "class B():\n",
    "    def method(self): return 'B'\n",
    "\n",
    "class C(A, B):\n",
    "    def method(self):\n",
    "        return (A.method(self), B.method(self), super().method())\n",
    "\n",
    "print(C.__mro__)\n",
    "print(C().method())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Функция isinstance</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "isinstance(1, int) == True\n",
      "isinstance(1.0, int) == False\n",
      "isinstance(True, int) == True\n",
      "isinstance(Cls1(), Cls1) == True\n",
      "isinstance(Cls1(), Interface) == True\n",
      "isinstance(Cls1(), object) == True\n",
      "isinstance(Cls2(), Cls1) == False\n"
     ]
    }
   ],
   "source": [
    "print('isinstance(1, int) == {}'.format(isinstance(1, int)))\n",
    "print('isinstance(1.0, int) == {}'.format(isinstance(1.0, int)))\n",
    "print('isinstance(True, int) == {}'.format(isinstance(True, int)))\n",
    "\n",
    "class Interface:\n",
    "    def get_value(self):\n",
    "        raise NotImplementedError\n",
    "\n",
    "class Cls1(Interface):\n",
    "    pass\n",
    "    \n",
    "class Cls2(Interface):\n",
    "    pass\n",
    "\n",
    "print('isinstance(Cls1(), Cls1) == {}'.format(isinstance(Cls1(), Cls1)))\n",
    "print('isinstance(Cls1(), Interface) == {}'.format(isinstance(Cls1(), Interface)))\n",
    "print('isinstance(Cls1(), object) == {}'.format(isinstance(Cls1(), object)))\n",
    "\n",
    "print('isinstance(Cls2(), Cls1) == {}'.format(isinstance(Cls2(), Cls1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Функция issubclass</font>\n",
    "\n",
    "Очень похожа на `isinstance`, но проверяет только классы, не объекты:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "issubclass(float, int) == False\n",
      "issubclass(bool, int) == True\n",
      "issubclass(Cls1, Interface) == True\n",
      "issubclass(Cls1, object) == True\n",
      "issubclass(Cls2, Cls1) == False\n"
     ]
    }
   ],
   "source": [
    "# print('issubclass(1, int) == {}'.format(issubclass(1, int))) -> TypeError: issubclass() arg 1 must be a class\n",
    "print('issubclass(float, int) == {}'.format(issubclass(float, int)))\n",
    "print('issubclass(bool, int) == {}'.format(issubclass(bool, int)))\n",
    "\n",
    "# print('issubclass(Cls1(), Cls1) == {}'.format(issubclass(Cls1(), Cls1))) -> TypeError\n",
    "print('issubclass(Cls1, Interface) == {}'.format(issubclass(Cls1, Interface)))\n",
    "print('issubclass(Cls1, object) == {}'.format(issubclass(Cls1, object)))\n",
    "print('issubclass(Cls2, Cls1) == {}'.format(issubclass(Cls2, Cls1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Статические методы</font>\n",
    "\n",
    "- Обычные методы класса принимают на вход первым параметром вызывающий объект и работают с ним\n",
    "- Статические методы являются методами класса и к объекту не привязаны\n",
    "- Как следствие, их можно вызывать без объекта\n",
    "- В Python статический метод определяется с помощью декоратора `@staticmethod`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Regular method\n",
      "Static method\n",
      "Static method\n",
      "Regular method\n"
     ]
    }
   ],
   "source": [
    "class A:\n",
    "    def method(self):\n",
    "        print('Regular method')\n",
    "\n",
    "    @staticmethod\n",
    "    def static_method():\n",
    "        print('Static method')\n",
    "\n",
    "# A.method()  # method() missing 1 required positional argument: 'self'\n",
    "\n",
    "A().method()\n",
    "A.static_method()\n",
    "A().static_method()  # object also has his type methods\n",
    "A.method(A())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Методы класса</font>\n",
    "\n",
    "- Метод класса получает на вход объект-класс вместо объекта класса\n",
    "- Используется для доступа к свойствам класса в целом (а не свойствам его экземпляров)\n",
    "- В Python метод класса определяется с помощью декоратора `@classmethod`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "20\n"
     ]
    }
   ],
   "source": [
    "class Cls:\n",
    "    attr = 10\n",
    "\n",
    "    @classmethod\n",
    "    def set_attr(cls, val):\n",
    "        cls.attr = val\n",
    "\n",
    "a = Cls()\n",
    "print(a.attr)\n",
    "\n",
    "b = Cls()\n",
    "b.set_attr(20)\n",
    "print(a.attr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Исключения</font>\n",
    "\n",
    "- Исключение - механизм, который был придуман штатной обработки ошибочных ситуаций\n",
    "- Часто ошибочно относится к ООП, на самом деле это иная концепция\n",
    "- Python поддерживает исключения, и ими надо пользоваться\n",
    "- В языке есть большая иерархия классов исключений на все случаи жизни\n",
    "- Если нужен свой класс, то можно наследовать от какого-то из существующих\n",
    "- Оптимальный вариант - класс `Exception`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Базовый синтаксис</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "ename": "ZeroDivisionError",
     "evalue": "division by zero",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-5-bc757c3fda29>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;36m1\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mZeroDivisionError\u001b[0m: division by zero"
     ]
    }
   ],
   "source": [
    "1 / 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Zero division!\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    1 / 0\n",
    "except:\n",
    "    print('Zero division!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Zero division!\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    raise ZeroDivisionError\n",
    "except:\n",
    "    print('Zero division!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Полный синтаксис</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OK\n",
      "finally\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    # some code\n",
    "    pass\n",
    "\n",
    "except ValueError:  # catch value errors\n",
    "    print('ERROR')  # do something\n",
    "    raise           # continue rising of this exception (or can skip it)\n",
    "\n",
    "except RuntimeError as error:  # catch runtume errors and store object\n",
    "    print(error)               # inspect exception content\n",
    "    raise error                # continue rising\n",
    "\n",
    "except:             # try not to use except without class specification\n",
    "    print('Unknown error')\n",
    "    pass\n",
    "\n",
    "else:            # if there's no exception, execute this branch \n",
    "    print('OK')\n",
    "finally:         # xxactions that chould be done in any case\n",
    "    #some actions (closing files for instance)\n",
    "    print('finally')\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Сохранение объектов: модуль pickle</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Cls:\n",
    "    def __init__(self, value):\n",
    "        self.__value = value\n",
    "\n",
    "    def get_value(self):\n",
    "        return self.__value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "\n",
    "cls = Cls(Cls(10))\n",
    "\n",
    "with open('cls.pkl', 'wb') as fout:\n",
    "    pickle.dump(cls, fout)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('cls.pkl', 'rb') as fin:\n",
    "    cls_2 = pickle.load(fin)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cls_2.get_value().get_value()"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.12.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}