oop/oop.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 🤹 Введение в объектно-ориентированное программирование (ООП) на Python\n",
    "\n",
    "[Объектно-ориентированное программирование (ООП)](https://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D0%BD%D0%BE-%D0%BE%D1%80%D0%B8%D0%B5%D0%BD%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5) – это метод структурирования программ путем объединения связанных свойств и методов в отдельные объекты. В этом руководстве мы познакомимся с основами объектно-ориентированного программирования на языке Python.\n",
    "\n",
    "Текст публикации представляет собой сокращенный перевод статьи Дэвида Амоса [Object-Oriented Programming (OOP) in Python 3](https://realpython.com/python3-object-oriented-programming/). Перевод подготовлен для проекта [Библиотека программиста](https://proglib.io/).\n",
    "\n",
    "\n",
    "# Что собой представляет объектно-ориентированное программирование в Python?\n",
    "\n",
    "Объектно-ориентированное программирование – это парадигма программирования, которая предоставляет средства структурирования программ таким образом, чтобы их свойства и поведение были объединены в отдельные объекты.\n",
    "\n",
    "Например, объект может представлять человека **свойствами** «имя», «возраст», «адрес» и **методами** (поведением) «ходьба», «разговор», «дыхание» и «бег». Или электронное письмо со свойствами «список получателей», «тема» и «текст», а также методы «добавление вложений» и «отправка».\n",
    "\n",
    "Иными словами, объектно-ориентированное программирование – это подход для моделирования вещей, а также отношений между вещами. ООП моделирует сущности реального мира, как программные **объекты**, с которыми связаны некоторые данные и которые могут выполнять определенные функции.\n",
    "\n",
    "Другой распространенной парадигмой программирования является [процедурное программирование](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%BE%D1%86%D0%B5%D0%B4%D1%83%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5), которое структурирует программу подобно рецепту. То есть программа предоставляет набор шагов в виде функций и блоков кода, которые последовательно выполняются для выполнения задачи.\n",
    "\n",
    "\n",
    "# Определим класс в Python\n",
    "\n",
    "Примитивные структуры данных, такие как числа, строки и списки, предназначены для представления простых фрагментов информации: стоимость яблока, название стихотворения, список любимых цветов. Но бывает, что информация имеет более сложную структуру.\n",
    "\n",
    "Допустим, вы хотите отслеживать работу сотрудников. Необходимо хранить основную информацию о каждом сотруднике: Ф.И.О., возраст, должность, год начала работы. Один из способов это сделать – представить каждого сотрудника в виде списка:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "kirk = [\"James Kirk\", 34, \"Captain\", 2265]\n",
    "spock = [\"Spock\", 35, \"Science Officer\", 2254]\n",
    "mccoy = [\"Leonard McCoy\", \"Chief Medical Officer\", 2266]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "У этого подхода есть ряд проблем.\n",
    "\n",
    "Во-первых, ухудшается [читаемость кода](https://proglib.io/p/kak-napisat-kod-kotoryy-polyubyat-vse-2020-03-17). Чтобы понять, что `kirk[0]` ссылается на имя сотрудника, нужно перемотать код к объявлению списка.\n",
    "\n",
    "Во-вторых, возрастает вероятность ошибки. В приведенном коде в списке `mccoy` не указан возраст, поэтому `mccoy[1]` вместо возраста вернет `\"Chief Medical Officer\"`.\n",
    "\n",
    "Отличный способ сделать такой тип кода более удобным – использовать классы.\n",
    "\n",
    "\n",
    "## Классы и экземпляры\n",
    "\n",
    "Итак, для создания пользовательских структур данных используются классы. Классы определяют функции, называемые методами класса. Методы описывают поведение – те действия, которые объект, созданный с помощью класса, может выполнять с данными.\n",
    "\n",
    "В этом туториале в качестве примера мы создадим класс `Dog`, который будет хранить информацию о характеристиках собак.\n",
    "\n",
    "Нужно понимать, что класс – это только план того, как что-то должно быть определено. Сам класс не содержит никаких данных. Класс `Dog` *указывает*, что для описания собаки необходимы кличка и возраст, но он не содержит ни клички, ни возраста какой-либо *конкретной* собаки.\n",
    "\n",
    "Если класс является планом, то экземпляр – это объект, который построен по этому плану. Он содержит реальные данные, это настоящая собака. Например, 🐕 Майлз, которому недавно исполнилось четыре года.\n",
    "\n",
    "Другая аналогия: класс – это бланк анкеты. Экземпляр – анкета, которую заполнили 📝. Подобно тому как люди заполняют одну и ту же форму своей уникальной информацией, так из одного класса может быть создано множество экземпляров. Обычно бланк анкеты сам по себе не нужен, он используется для удобства оформления информации.\n",
    "\n",
    "## Как определить класс\n",
    "\n",
    "Все определения классов начинаются с ключевого слова `class`, за которым следует имя класса и двоеточие. Весь следующий после двоеточия код составляет тело класса:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dog:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Тело класса `Dog` пока состоит из одного оператора – ключевого слова-заполнителя `pass`. Заполнитель позволяет запустить этот код без вызова исключений.\n",
    "\n",
    "**Примечание**. Имена классов Python принято записывать в нотации [`CamelCase`](https://ru.wikipedia.org/wiki/CamelCase).\n",
    "\n",
    "Определим свойства, которые должны иметь все объекты `Dog`. Для простоты будем описывать собак с помощью клички и возраста.\n",
    "\n",
    "Свойства, которые должны иметь все объекты класса `Dog`, определяются в специальном методе с именем `__init__()`. Каждый раз, когда создается новый объект `Dog`, `__init __()` присваивает свойствам объекта значения. То есть `__init__()` инициализирует каждый новый экземпляр класса.\n",
    "\n",
    "Методу `__init__()` можно передать любое количество параметров, но первым параметром всегда является автоматически создаваемая переменная с именем `self`. Переменная `self` ссылается на только что созданный экземпляр класса, за счет чего метод `__init__()` сразу может определить новые атрибуты.\n",
    "\n",
    "Обновим класс `Dog` с помощью метода `__init__()`, который создает атрибуты `name` и `age`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dog:\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В теле `__init__()` две инструкции, задействующие переменную `self`:\n",
    "\n",
    "* `self.name = name` создает атрибут с именем `name` и присваивает ему значение параметра `name`.\n",
    "* `self.age` = `age` создает атрибут `age` и присваивает ему значение параметра `age`.\n",
    "\n",
    "Атрибуты, созданные в `__init__()` называются **атрибутами экземпляра**. Значение атрибута экземпляра зависит от конкретного экземпляра класса. Все объекты `Dog` имеют имя и возраст, но значения атрибутов `name` и `age` будут различаться в зависимости от экземпляра Dog.\n",
    "\n",
    "С другой стороны, можно создать **атрибуты класса** – это атрибуты, которые имеют одинаковое значение для всех экземпляров класса. Вы можете определить атрибут класса, присвоив значение имени переменной вне `__init__()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dog:\n",
    "    # Атрибут класса\n",
    "    species = \"Canis familiaris\"\n",
    "\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Атрибуты класса определяются после имени класса. Им всегда должно быть присвоено начальное значение. Используйте атрибуты класса для определения свойств, которые должны иметь одинаковое значение для каждого экземпляра класса, а атрибуты экземпляров – для тех данных, которые отличают один экземпляр от другого.\n",
    "\n",
    "Теперь, когда у нас есть класс `Dog`, создадим нескольких собак! 🐶"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Создание экземпляра класса в Python\n",
    "\n",
    "Временно воспользуемся простейшим описанием класса, с которого мы начали: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dog:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Создание нового экземпляра класса похоже на вызов функции:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.Dog at 0x7fa7084190d0>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Dog()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В памяти компьютера по указанному после `at` адресу был создан новый объект типа `__main__.Dog`.\n",
    "\n",
    "Важно, что новый экземпляр `Dog` будет создан уже по другому адресу. Это совершенно новый экземпляр и он полностью уникален:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.Dog at 0x7fa7083da450>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Dog()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = Dog()\n",
    "b = Dog()\n",
    "a == b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Хотя `a` и `b` являются экземплярами класса Dog, они представляют собой два разных объекта."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Атрибуты класса и экземпляра\n",
    "\n",
    "Теперь возьмем последнюю рассмотренную нами структуру класса:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dog:\n",
    "    species = \"Canis familiaris\"\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для создания экземпляров объектов класса необходимо указать кличку и возраст собаки. Если мы этого не сделаем, то Python вызовет ошибку `TypeError`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "__init__() missing 2 required positional arguments: 'name' and 'age'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-10-2dced99f65a6>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mDog\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: __init__() missing 2 required positional arguments: 'name' and 'age'"
     ]
    }
   ],
   "source": [
    "Dog()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Чтобы передать аргументы, помещаем значения в скобки после имени класса:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "buddy = Dog(\"Buddy\", 9)\n",
    "miles = Dog(\"Miles\", 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Но ведь в описании класса `__init__()` перечислены три параметра – почему в этом примере передаются только два аргумента?\n",
    "\n",
    "При создании экземпляра Python сам передает новый экземпляр в виде параметра `self` в метод `__init__()`. Так что нам нужно беспокоиться только об аргументах `name` и `age`.\n",
    "\n",
    "После того как экземпляры созданы, записанные данные доступны в виде атрибутов экземпляра:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Buddy'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "buddy.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "buddy.age"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Miles'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "miles.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "miles.age"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Canis familiaris'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "buddy.species"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Canis familiaris'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "miles.species"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Одним из важных преимуществ использования классов для организации данных является то, что экземпляры гарантированно имеют ожидаемые атрибуты. У всех экземпляров Dog гарантировано есть атрибуты `species`, `name` и `age`.\n",
    "\n",
    "Значения атрибутов могут изменяться динамически:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "buddy.age = 10\n",
    "buddy.age"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Felis silvestris'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "miles.species = \"Felis silvestris\"\n",
    "miles.species"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Экземпляры не зависят друг от друга. Изменение атрибута класса у одного экземпляра не меняет его у остальных экземпляров:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Canis familiaris'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "buddy.species"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Методы экземпляра\n",
    "\n",
    "Методы экземпляра – это определенные внутри класса функции, которые могут вызываться из экземпляра этого класса. Также, как и у метода `__init__()`, первым параметром метода экземпляра всегда является `self`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dog:\n",
    "    species = \"Canis familiaris\"\n",
    "\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "\n",
    "    # Метод экземпляра\n",
    "    def description(self):\n",
    "        return f\"{self.name} is {self.age} years old\"\n",
    "\n",
    "    # Другой метод экземпляра\n",
    "    def speak(self, sound):\n",
    "        return f\"{self.name} says {sound}\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Мы добавили два метода экземпляра, возвращающих строковые значения. Метод `description` возвращает строку с описанием собаки, метод `speak` принимает аргумент `sound`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Miles is 4 years old'"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "miles = Dog(\"Miles\", 4)\n",
    "miles.description()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Miles says Woof Woof'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "miles.speak(\"Woof Woof\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Miles says Bow Wow'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "miles.speak(\"Bow Wow\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В приведенном примере `description()` возвращает строку, содержащую информацию об экземпляре. При написании собственных классов такие методы, описывающие экземпляры, и правда полезны. Однако `description()` – не самый элегантный способ это сделать.\n",
    "\n",
    "К примеру, когда вы создаете объект списка, вы можете использовать для отображения функцию `print()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Fletcher', 'David', 'Dan']\n"
     ]
    }
   ],
   "source": [
    "names = [\"Fletcher\", \"David\", \"Dan\"]\n",
    "print(names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Посмотрим, что произойдет, когда мы попробуем применить `print()` к объекту `miles`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Miles is 4 years old\n"
     ]
    }
   ],
   "source": [
    "print(miles)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В большинстве практических приложений информация о расположении объекта в памяти не очень полезна.  Поведение объекта при взаимодействии с функцией `print()` можно изменить, определив специальный метод `__str__()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dog:\n",
    "    species = \"Canis familiaris\"\n",
    "\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "\n",
    "    def __str__(self):\n",
    "        return f\"{self.name} is {self.age} years old\"\n",
    "\n",
    "    def speak(self, sound):\n",
    "        return f\"{self.name} says {sound}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Miles is 4 years old\n"
     ]
    }
   ],
   "source": [
    "miles = Dog(\"Miles\", 4)\n",
    "print(miles)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Двойные символы подчеркивания в таких методах, как `__init__()` и `__str__()` указывают на то, что они имеют предопределенное поведение. Есть [множество более сложных методов](https://docs.python.org/3/reference/datamodel.html), которые вы можете использовать для настройки классов в Python, но это тема отдельной публикации."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Наследование от других классов в Python\n",
    "\n",
    "Наследование – это процесс, при котором один класс принимает атрибуты и методы другого. Вновь созданные классы называются дочерними классами, а классы, от которых происходят дочерние классы, называются родительскими. Дочерние классы могут переопределять или расширять атрибуты и методы родительских классов.\n",
    "\n",
    "## Пример: место для выгула собак\n",
    "\n",
    "Представьте, что вы в парке, где разрешено гулять с собаками. В парке много собак разных пород, и все они ведут себя по-разному. Предположим, что вы хотите смоделировать парк собак с классами Python. Класс `Dog`, который мы написали в предыдущем разделе, может различать собак по имени и возрасту, но не по породе.\n",
    "\n",
    "Мы можем изменить класс `Dog`, добавив атрибут `breed` (англ. порода):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dog:\n",
    "    species = \"Canis familiaris\"\n",
    "\n",
    "    def __init__(self, name, age, breed):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        self.breed = breed\n",
    "\n",
    "    def __str__(self):\n",
    "        return f\"{self.name} is {self.age} years old\"\n",
    "\n",
    "    def speak(self, sound):\n",
    "        return f\"{self.name} says {sound}\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Смоделируем несколько псов разных пород:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "miles = Dog(\"Miles\", 4, \"Jack Russell Terrier\")\n",
    "buddy = Dog(\"Buddy\", 9, \"Dachshund\")\n",
    "jack = Dog(\"Jack\", 3, \"Bulldog\")\n",
    "jim = Dog(\"Jim\", 5, \"Bulldog\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "У каждой породы собак поведение несколько отличаются. Например, разные породы  по-разному лают: одни говорят «гав», другие делают «вуф». Используя только класс `Dog`, мы были бы должны указывать строку для аргумента sound метода `speak()` каждый раз, когда вызываем его в экземпляре `Dog`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Buddy says Yap'"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "buddy.speak(\"Yap\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Jim says Woof'"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "jim.speak(\"Woof\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Jack says Woof'"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "jack.speak(\"Woof\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Передавать строку в каждый вызов метод `speak()` неудобно. Более того, строка, соответствующая звуку, который издает экземпляр, должна определяться его атрибутом `breed`.\n",
    "\n",
    "Один из вариантов упростить взаимодействие с классом `Dog` – создать дочерний класс для каждой породы. Это позволит расширить функциональные возможности наследующих дочерних классов. В том числе можно будет указать аргумент по умолчанию для `speak`.\n",
    "\n",
    "# Создаём дочерние классы\n",
    "\n",
    "Создадим дочерние классы для каждой из перечисленных пород. Так как порода теперь будет определяться дочерним классом, её нет смысла указывать в родительском классе:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dog:\n",
    "    species = \"Canis familiaris\"\n",
    "\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "\n",
    "    def __str__(self):\n",
    "        return f\"{self.name} is {self.age} years old\"\n",
    "\n",
    "    def speak(self, sound):\n",
    "        return f\"{self.name} says {sound}\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Связь между родительским и дочерним классом определяется тем, что наследуемый класс (`Dog`) передается в качестве аргумента, принимаемого дочерним классом:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "class JackRussellTerrier(Dog):\n",
    "    pass\n",
    "\n",
    "class Dachshund(Dog):\n",
    "    pass\n",
    "\n",
    "class Bulldog(Dog):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Дочерние классы действуют так же, как родительский класс:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "miles = JackRussellTerrier(\"Miles\", 4)\n",
    "buddy = Dachshund(\"Buddy\", 9)\n",
    "jack = Bulldog(\"Jack\", 3)\n",
    "jim = Bulldog(\"Jim\", 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Экземпляры дочерних классов наследуют все атрибуты и методы родительского класса:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Canis familiaris'"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "miles.species"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Buddy'"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "buddy.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jack is 3 years old\n"
     ]
    }
   ],
   "source": [
    "print(jack)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Jim says Woof'"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "jim.speak(\"Woof\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Чтобы определить, к какому классу принадлежит определенный объект, используйте встроенную функцию `type()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "__main__.JackRussellTerrier"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(miles)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как определить, является ли `miles` также экземпляром класса `Dog`? Для этого есть встроенная функция `isinstance()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(miles, Dog)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Объекты `miles`, `buddy`, `jack` и `jim` являются экземплярами Dog, но `miles` не является экземпляром `Bulldog`, а `jack` не является экземпляром `Dachshund`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(miles, Bulldog)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(jack, Dachshund)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Все объекты дочернего класса являются экземплярами родительского класса, но не других дочерних классов.\n",
    "\n",
    "Теперь дадим нашим собакам немного полаять."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Расширяем функциональность родительского класса\n",
    "\n",
    "Что мы хотим сделать: переопределить в дочерних классах пород метод `speak()`. Чтобы переопределить метод, определенный в родительском классе, достаточно создать метод с тем же именем в дочернем классе:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "class JackRussellTerrier(Dog):\n",
    "    def speak(self, sound=\"Arf\"):\n",
    "        return f\"{self.name} says {sound}\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Мы переопределили метод `speak`, добавив для породы `JackRussellTerrier` значение по умолчанию."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Miles says Arf'"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "miles = JackRussellTerrier(\"Miles\", 4)\n",
    "miles.speak()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Мы по-прежнему можем передать какой-то иной звук:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Miles says Grrr'"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "miles.speak(\"Grrr\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Изменения в родительском классе автоматически распространяются на дочерние классы. Если только изменяемый атрибут или метод не был переопределен в дочернем классе."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dog:\n",
    "    species = \"Canis familiaris\"\n",
    "\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "\n",
    "    def __str__(self):\n",
    "        return f\"{self.name} is {self.age} years old\"\n",
    "\n",
    "    def speak(self, sound):\n",
    "        return f\"{self.name} barks {sound}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Miles says Arf'"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "miles = JackRussellTerrier(\"Miles\", 4)\n",
    "miles.speak()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Иногда бывает необходимо учесть и поведение родительского класса, и дочернего, например, вызвать аналогичный метод родительского класса, но модифицировать его поведение. Для вызова методов родительского класса есть специальная функция `super`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "class JackRussellTerrier(Dog):\n",
    "    def speak(self, sound=\"Arf\"):\n",
    "        return super().speak(sound)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Miles barks Arf'"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "miles = JackRussellTerrier(\"Miles\", 4)\n",
    "miles.speak()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Здесь при вызове `super().speak(sound)` внутри класса `JackRussellTerrier`, Python ищет родительский класс `Dog` (на это указывает функция `super()`), и вызывает его метод `speak()` с переданной переменной `sound`. Именно поэтому выводится глагол `barks`, а не `says`, но с нужным нам звуком `Arf`, который определен в дочернем классе.\n",
    "\n",
    "**Обратите внимание**. В приведенных примерах иерархия классов очень проста. Класс `JackRussellTerrier` имеет единственный родительский класс `Dog`. В реальных примерах иерархия классов может быть довольно сложной.\n",
    "\n",
    "Функция `super()` делает гораздо больше, чем просто ищет в родительском классе метод или атрибут. В поисках искомого метода или атрибута функция проходит по всей иерархии классов. Поэтому без должной осторожности использование `super()` может привести к неожиданным результатам.\n",
    "\n",
    "\n",
    "# Заключение\n",
    "\n",
    "Итак, в этом туториале мы разобрали базовые понятия объектно-ориентированного программирования (ООП) в Python. Мы узнали:\n",
    "\n",
    "* в чём отличия классов и экземпляров,\n",
    "* как определить класс,\n",
    "* как инициализировать экземпляр класса,\n",
    "* как определить методы класса и методы экземпляра,\n",
    "* как одни классы наследуются от других.\n",
    "\n",
    "Если вам понравилась эта публикация, обратите внимание на другие материалы в [README-файле репозитория lessons]()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}