lectures/03-classes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# `Практикум по программированию на языке Python`\n",
    "<br>\n",
    "\n",
    "## `Занятие 3: Основы ООП: особенности языка, атрибуты, наследование`\n",
    "<br><br>\n",
    "\n",
    "### `Мурат Апишев (mel-lain@yandex.ru)`\n",
    "\n",
    "#### `Москва, 2022`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Парадигмы проектирования кода`"
   ]
  },
  {
   "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": [
    "### `Объектно-ориентированное программирование`\n",
    "\n",
    "- Программа, как и окружающий мир, состоит из сущностей<br><br>\n",
    "- Сущности имеют какое-то внутренее состояние<br><br>\n",
    "- Также сущности взаимодействуют друг с другом<br><br>\n",
    "- ООП нужно для описания программы в виде сущностей и их взаимоотношений<br><br>\n",
    "- При этом и на сущности, и на отношения накладываются ограничения<br><br>\n",
    "- Это позволяет писать более короткий, простой и переиспользуемый код"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Базовые понятия: класс и объект`\n",
    "\n",
    "- __Класс__ представляет собой тип данных (как int или str)<br><br>\n",
    "- Это способ описания некоторой сущности, её состояния и возможного поведения<br><br>\n",
    "- Поведение при этом зависит от состояния и может его изменять<br><br>\n",
    "- __Объект__ - это конретный представитель класса (как переменная этого типа)<br><br>\n",
    "- У объекта своё состояние, изменяемое поведением<br><br>\n",
    "- Поведение полностью определяется правилами, описанными в классе"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Базовые понятия: интерфейс`\n",
    "\n",
    "- __Интерфейс__ - это класс, описывающий только поведение<br><br>\n",
    "- У интерфейса нет состояния<br><br>\n",
    "- Как следствие, создать объект типа интерфейса невозможно<br><br>\n",
    "- Вместо этого описываются классы, которые реализуют этот интерфейс и, в то же время, имеют состояние<br><br>\n",
    "- С помощью интерфейсов реализуется полиморфизм (будет далее)<br><br>\n",
    "- Программирование на уровне интерфейсов делает код читаемее и проще<br><br>\n",
    "- Интерфейсы в некоторых языках (например, Java) решают проблему отсутствия множественного наследования"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Интерфейс: пример`\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",
    "- не содержит информации о состоянии автомобиля<br><br>\n",
    "- не содержит информации о том, как выполнять описанные команды<br><br>\n",
    "- он только описывает то, какие операции должны быть доступны над объектом, который претендует на то, чтобы быть автомобилем"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Реализация интерфейса`\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",
    "- Обычно данные класса называют _полями_ (или _атрибутами_), а функции - _методами_ <br><br>\n",
    "- **Абстрактный класс** - промежуточный вариант между интерфейсом и обычным классом"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Принципы ООП`\n",
    "\n",
    "- **Абстракция** - выделение важных свойств объекта и игнорирование прочих<br><br>\n",
    "\n",
    "- **Инкапсуляция** - хранение данных и методов работы с ними внутри одного класса с доступом к данным только через методы<br><br>\n",
    "\n",
    "- **Наследование** - возможность создания наследников, получающих все свойства родителей с возможностью их переопределения и расширения<br><br>\n",
    "\n",
    "- **Полиморфизм** - возможность использования объектов разных типов с общим интерфейсом без информации об их внутреннем устройстве"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `ООП в Python`\n",
    "\n",
    "- Python - это полностью объектно-ориентированный язык<br><br>\n",
    "\n",
    "- В Python абсолютно всё является объектами, включая классы<br><br>\n",
    "\n",
    "- Полностью поддерживаются все принципы ООП, кроме инкапсуляции<br><br>\n",
    "\n",
    "- Инкапсуляция поддерживается частично: нет ограничения на доступ к полям класса<br><br>\n",
    "\n",
    "- Поэтому для инкапсуляции используют договорные соглашения"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Так выглядят классы в Python`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class '__main__.ConcreteCar'> <class '__main__.ConcreteCar'>\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "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": [
    "### `Функция __init__`\n",
    "\n",
    "- Главное: `__init__` - не конструктор! Она ничего не создаёт и не возвращает\n",
    "\n",
    "- Созданием объекта занимается функция `__new__`, переопределять которую без необходимости не надо\n",
    "\n",
    "- `__init__` получает на вход готовый объект и инициализирует его атрибуты<br>\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": [
    "### `Параметр self`\n",
    "\n",
    "- Метод класса отличается от обычной функции только наличием объекта `self` в качестве первого аргумента <br><br>\n",
    "\n",
    "- Это то же самое, что происходит в C++/Java (там аналогом `self` является указатель/ссылка `this`) <br><br>\n",
    "\n",
    "- Название `self` является общим соглашением, но можно использовать и другое (не надо!)<br><br>\n",
    "\n",
    "- Метод класса, не получающий на вход `self` является _статическим_<br><br>\n",
    "\n",
    "- Статические методы часто используются для специализированного создания объектов класса<br><br>\n",
    "\n",
    "- Еще есть _методы класса_, входом у них является класс как объект<br><br>\n",
    "\n",
    "- В Python `__new__` является статическим методом"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Как быть с инкапсуляцией`\n",
    "\n",
    "- Приватное поле прежде всего должно быть обозначено таковым\n",
    "- В Python для этого есть соглашения:<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "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)",
      "\u001b[0;32m<ipython-input-1-7323e174dcc4>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcls\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpublic_field\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcls\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_private_field\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 10\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcls\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__mangled_field\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: 'Cls' object has no attribute '__mangled_field'"
     ]
    }
   ],
   "source": [
    "class Cls:\n",
    "    def __init__(self):\n",
    "        self.public_field = 'Ok'\n",
    "        self._private_field = \"You're shouldn't see it\"\n",
    "        self.__mangled_field = \"YOU REALLY SHOULDN'T SEE IT!!!\"\n",
    "\n",
    "cls = Cls()\n",
    "print(cls.public_field)\n",
    "print(cls._private_field)\n",
    "print(cls.__mangled_field)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "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": [
    "### `Атрибуты объекта и класса`"
   ]
  },
  {
   "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": [
    "### `Переменная __dict__`\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": [
    "### `Доступ к атрибутам`\n",
    "\n",
    "- Для работы с атрибутами есть функции `getattr`, `setattr` и `delattr`\n",
    "- Их основное преимущество - оперирование именами атрибутов в виде строк"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "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)",
      "\u001b[0;32m<ipython-input-13-7a637e97d7b9>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0mdelattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcls\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'some_attr'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgetattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcls\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'some_attr'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: 'Cls' object has no attribute 'some_attr'"
     ]
    }
   ],
   "source": [
    "cls = Cls()\n",
    "\n",
    "setattr(cls, 'some_attr', 'some')\n",
    "\n",
    "print(getattr(cls, 'some_attr'))\n",
    "\n",
    "delattr(cls, 'some_attr')\n",
    "\n",
    "print(getattr(cls, 'some_attr'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Class magic methods`\n",
    "\n",
    "- Магические методы придают объекту класса определённые свойства\n",
    "\n",
    "- Такие методы получают `self` вызываются интерпретатором неявно\n",
    "\n",
    "- Например, операторы - это магические методы<bf>\n",
    "\n",
    "Рассмотрим несколько примеров:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Class: Some class\n",
      "Some classSome class\n"
     ]
    }
   ],
   "source": [
    "class Cls:\n",
    "    def __init__(self):  # initialize object\n",
    "        self.name = 'Some class'\n",
    "    \n",
    "    def __repr__(self):  # str for printing object\n",
    "        return 'Class: {}'.format(self.name)\n",
    "    \n",
    "    def __call__(self, counter):  # call == operator() in C++\n",
    "        return self.name * counter\n",
    "\n",
    "cls = Cls()\n",
    "print(cls.__repr__())  # == print(cls)\n",
    "print(cls(2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Class magic methods`\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": [
    "### `Как на самом деле устроен доступ к атрибутам`\n",
    "\n",
    "При работе с атрибутами вызываются магические методы `__getattr__`, `__getattribute__`, `__setattr__` и `__delattr__`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "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": [
    "### `Как на самом деле устроен доступ к атрибутам`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "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)",
      "\u001b[0;32m<ipython-input-5-e2e4cd9a9b98>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;32mdel\u001b[0m \u001b[0mcls\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msome_attr\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0mb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcls\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msome_attr\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m \u001b[0mcls\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnon_exists_attr\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-4-303001eee23f>\u001b[0m in \u001b[0;36m__getattr__\u001b[0;34m(self, attr)\u001b[0m\n\u001b[1;32m      6\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__getattr__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mattr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m         \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf'WE WILL ENTER IT ONLY IN CASE OF ERROR!'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__dict__\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mattr\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      9\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__getattribute__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mattr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyError\u001b[0m: 'non_exists_attr'"
     ]
    }
   ],
   "source": [
    "cls = Cls()\n",
    "\n",
    "cls.some_attr = 'some'\n",
    "a = cls.some_attr\n",
    "\n",
    "del cls.some_attr\n",
    "b = cls.some_attr\n",
    "cls.non_exists_attr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Магические методы и менеджер контекста`\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": [
    "### `Наследование в Python`"
   ]
  },
  {
   "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": [
    "### `Перегрузка родительских методов`"
   ]
  },
  {
   "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": [
    "### Искаженные (mangled) атрибуты\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": [
    "### `Множественное наследование`\n",
    "\n",
    "- Даёт возможность классу получить методы и свойства сразу нескольких предков<br><br>\n",
    "- Позволяет строить сложные иерархии зависимостей<br><br>\n",
    "- Использовать без необходимости не нужно, поскольку архитектура кода сильно усложняется<br><br>\n",
    "- В Python поддерживается без ограничений<br><br>\n",
    "- У класса может быть один и более предков (`object` есть всегда)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Множественное наследование в Python`\n",
    "- Методы и атрибуты ищутся в следующем порядке:<br><br>\n",
    "    1. имя ищется в объекте (т.е. в его `__dict__`)\n",
    "    2. дальше в классе объекта\n",
    "    3. дальше в предках класса<br><br>\n",
    "- Для поиска по предкам используется MRO (Method resolution order)<br><br>\n",
    "- У каждого класса в момент создания вычисляется этот порядок и сохраняется в атрибуте `__mro__`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 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": [
    "### `Вызов метода класса-родителя`\n",
    "\n",
    "- В Python есть два способа обращения к родительским методам<br><br>\n",
    "    - через функцию `super` (использует порядок mro)\n",
    "    - напрямую по имени<br><br>"
   ]
  },
  {
   "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": [
    "### `Функция isinstance`"
   ]
  },
  {
   "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": [
    "### `Функция issubclass`\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": [
    "### `Декораторы в Python`\n",
    "\n",
    "- Декоратор - шаблон проектирования, о котором речь пойдет позже\n",
    "- Декораторы в языке Python - это иная сущность, а именно способ изменения определения функции, класса или метода\n",
    "\n",
    "__Пример__: декоратор `@property`, превращающий get-метод класса в неизменяемое поле для чтения:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "value\n"
     ]
    }
   ],
   "source": [
    "class A:\n",
    "    def __init__(self):\n",
    "        self._field = 'value'\n",
    "\n",
    "    @property\n",
    "    def field(self):\n",
    "        return self._field\n",
    "\n",
    "a = A()\n",
    "print(a.field)\n",
    "\n",
    "#a.field() -> TypeError: 'str' object is not callable\n",
    "#a.field = 5 -> AttributeError: can't set attribute"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- В языке и библиотеках определено множество декораторов, используем далее некоторые\n",
    "- Определять декораторы можно самостоятельно, об этом речь пойдёт позже"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Статические методы`\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": [
    "### `Методы класса`\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": [
    "### `Исключения`\n",
    "\n",
    "- Исключение - механизм, который был придуман штатной обработки ошибочных ситуаций<br><br>\n",
    "- Часто ошибочно относится к ООП, на самом деле это иная концепция<br><br>\n",
    "- Python поддерживает исключения, и ими надо пользоваться<br><br>\n",
    "- В языке есть большая иерархия классов исключений на все случаи жизни<br><br>\n",
    "- Если нужен свой класс, то можно наследовать от какого-то из существующих<br><br>\n",
    "- Оптимальный вариант - класс `Exception`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Базовый синтаксис`"
   ]
  },
  {
   "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": [
    "### `Полный синтаксис`"
   ]
  },
  {
   "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": [
    "### `Сохранение объектов: модуль pickle`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "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": 14,
   "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": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('cls.pkl', 'rb') as fin:\n",
    "    cls_2 = pickle.load(fin)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cls_2.get_value().get_value()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Спасибо за внимание!`"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}