{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Полиморфизм и утиная типизация\n",
    "\n",
    "Один и тот же вызов — разное поведение у разных классов. Функция, которой неважен класс объекта, утиная типизация и новый класс, который встраивается в готовый код.\n",
    "\n",
    "Курс ООП в Python · урок `oop-polymorphism` · [урок на сайте](https://ds-edu-trainer.vercel.app/courses/oop/polymorphism).\n",
    "\n",
    "Выполняйте ячейки по порядку (Shift+Enter), начиная с первой — она готовит урок. После каждого упражнения идёт\n",
    "ячейка проверки: она печатает ✓ / ✗ и итог."
   ],
   "id": "intro"
  },
  {
   "cell_type": "code",
   "metadata": {
    "cellView": "form",
    "jupyter": {
     "source_hidden": true
    }
   },
   "source": [
    "# @title Подготовка урока — выполните эту ячейку первой\n",
    "# Проверяет версии пакетов, записывает файлы данных в папку data/ и определяет _check — проверку упражнений.\n",
    "import base64, os, zlib\n",
    "\n",
    "import sys\n",
    "\n",
    "if sys.version_info < (3, 10):\n",
    "    print(f\"Урок написан для Python 3.10 и новее, у вас {sys.version.split()[0]} — часть кода может не работать\")\n",
    "\n",
    "# ─── Проверка упражнений: тот же раннер, что у задач на сайте ───\n",
    "# ─── Запуск тестов ───────────────────────────────────────────────────────────\n",
    "\n",
    "_TIMEOUT = 2.0  # секунд на тест; отдельный тест может задать свой: test_x.timeout = 10\n",
    "\n",
    "\n",
    "def _call_with_timeout(target, seconds: float) -> bool:\n",
    "    \"\"\"Запускает target() в отдельном потоке. Возвращает False, если за seconds он не завершился.\"\"\"\n",
    "    import sys\n",
    "    import threading\n",
    "\n",
    "    if sys.platform == \"emscripten\":  # Python в браузере: потоков нет, таймаут обеспечивает страница\n",
    "        target()\n",
    "        return True\n",
    "    # Большой стек нужен, чтобы глубокая рекурсия давала RecursionError, а не аварийное завершение Python.\n",
    "    for megabytes in (256, 64, 0):\n",
    "        try:\n",
    "            threading.stack_size(megabytes * 1024 * 1024)\n",
    "            worker = threading.Thread(target=target, daemon=True)\n",
    "            worker.start()\n",
    "        except (ValueError, RuntimeError, MemoryError):\n",
    "            continue\n",
    "        worker.join(seconds)\n",
    "        return not worker.is_alive()\n",
    "    target()  # потоки недоступны — запускаем без таймаута\n",
    "    return True\n",
    "\n",
    "\n",
    "def _test_info(fn) -> dict:\n",
    "    \"\"\"Описание теста, его лимит времени и сообщение на случай зависания.\"\"\"\n",
    "    limit = getattr(fn, \"timeout\", _TIMEOUT)\n",
    "    hint = getattr(fn, \"timeout_hint\", \"\")\n",
    "    message = (\n",
    "        f\"тест не завершился за {limit:g} с — возможно, бесконечный цикл или рекурсия: \"\n",
    "        \"проверьте, что границы/аргументы изменяются на каждом шаге\" + (f\". {hint}\" if hint else \"\")\n",
    "    )\n",
    "    return {\"title\": (fn.__doc__ or fn.__name__).strip(), \"timeout\": limit, \"timeout_message\": message}\n",
    "\n",
    "\n",
    "def _error_result(title: str, error: BaseException, user_file: str | None) -> dict:\n",
    "    \"\"\"Результат упавшего теста: статус, сообщение, тип исключения и строка в коде решения.\"\"\"\n",
    "    line = None\n",
    "    if user_file:  # самый глубокий кадр в коде решения; ошибка внутри самих тестов — без номера строки\n",
    "        tb = error.__traceback__\n",
    "        while tb is not None:\n",
    "            if tb.tb_frame.f_code.co_filename == user_file:\n",
    "                line = tb.tb_lineno\n",
    "            tb = tb.tb_next\n",
    "    status, message = \"error\", f\"{type(error).__name__}: {error}\"\n",
    "    if isinstance(error, NotImplementedError):\n",
    "        status, message, line = \"not_written\", \"функция ещё не написана\", None\n",
    "    elif isinstance(error, AssertionError):\n",
    "        status, message = \"failed\", str(error) or \"проверка не прошла\"\n",
    "    elif isinstance(error, RecursionError):\n",
    "        message = \"RecursionError: слишком глубокая рекурсия — проверьте базовый случай и то, что задача уменьшается\"\n",
    "    elif isinstance(error, MemoryError) or (isinstance(error, OverflowError) and \"index-sized\" in str(error)):\n",
    "        message = f\"{type(error).__name__}: не хватило памяти — возможно, создаётся слишком большая структура данных\"\n",
    "    return {\"title\": title, \"status\": status, \"message\": message, \"error_type\": type(error).__name__, \"line\": line}\n",
    "\n",
    "\n",
    "def _run_tests(verbose: bool = True, on_start=None, on_result=None, user_file: str | None = None) -> list[dict]:\n",
    "    \"\"\"Запускает тесты задачи (_TESTS — функции из tests.py) по порядку, каждый — с таймаутом.\n",
    "\n",
    "    Возвращает список результатов: {\"title\", \"status\", \"message\", \"error_type\", \"line\"}, где status —\n",
    "    passed · failed · error · not_written · timeout · not_run. Если тест завис, при verbose=True печатает\n",
    "    итог и завершает процесс: зависший поток остановить нельзя. on_start(i) и on_result(i, результат)\n",
    "    вызываются по мере выполнения; user_file — имя файла с кодом решения для номеров строк в ошибках.\n",
    "    \"\"\"\n",
    "    import os\n",
    "    import sys\n",
    "\n",
    "    if verbose:\n",
    "        try:  # ✓ и кириллица в консоли Windows со старой кодировкой\n",
    "            sys.stdout.reconfigure(encoding=\"utf-8\")\n",
    "        except Exception:  # noqa: BLE001 — reconfigure может не быть (перенаправленный вывод, браузер)\n",
    "            pass\n",
    "\n",
    "    tests = list(_TESTS)\n",
    "    results: list[dict] = []\n",
    "    not_written = hung = False\n",
    "    for index, fn in enumerate(tests):\n",
    "        info = _test_info(fn)\n",
    "        outcome: dict = {}\n",
    "\n",
    "        def target(fn=fn, outcome=outcome):\n",
    "            try:\n",
    "                fn()\n",
    "            except BaseException as e:\n",
    "                outcome[\"error\"] = e\n",
    "\n",
    "        if on_start:\n",
    "            on_start(index)\n",
    "        if not _call_with_timeout(target, info[\"timeout\"]):\n",
    "            results.append({\"title\": info[\"title\"], \"status\": \"timeout\", \"message\": info[\"timeout_message\"], \"error_type\": None, \"line\": None})\n",
    "            for other in tests[index + 1:]:\n",
    "                results.append({\"title\": _test_info(other)[\"title\"], \"status\": \"not_run\", \"message\": \"не запускался: предыдущий тест завис\", \"error_type\": None, \"line\": None})\n",
    "            hung = True\n",
    "            break\n",
    "        error = outcome.get(\"error\")\n",
    "        if error is None:\n",
    "            result = {\"title\": info[\"title\"], \"status\": \"passed\", \"message\": \"\", \"error_type\": None, \"line\": None}\n",
    "        else:\n",
    "            result = _error_result(info[\"title\"], error, user_file)\n",
    "            not_written = not_written or result[\"status\"] == \"not_written\"\n",
    "        results.append(result)\n",
    "        if on_result:\n",
    "            on_result(index, result)\n",
    "\n",
    "    if not_written:  # пока функция не написана, «даром» пройденные тесты не засчитываются\n",
    "        for r in results:\n",
    "            if r[\"status\"] == \"passed\":\n",
    "                r.update(status=\"not_written\", message=\"не засчитан, пока функция не написана\")\n",
    "    for r in results:\n",
    "        if len(r[\"message\"]) > 300:\n",
    "            r[\"message\"] = r[\"message\"][:300] + \"…\"\n",
    "\n",
    "    if verbose:\n",
    "        if not_written:\n",
    "            print(\"Функция ещё не написана — замените raise NotImplementedError своим кодом.\\n\")\n",
    "        for r in results:\n",
    "            mark = {\"passed\": \"✓\", \"not_run\": \"–\"}.get(r[\"status\"], \"✗\")\n",
    "            print(f\"{mark} {r['title']}\")\n",
    "            if r[\"message\"]:\n",
    "                print(f\"    {r['message']}\")\n",
    "        passed = sum(r[\"status\"] == \"passed\" for r in results)\n",
    "        print(\"─\" * 40)\n",
    "        print(f\"Прошло {passed} из {len(results)}\" + (\" — всё верно!\" if passed == len(results) else \"\"))\n",
    "        if hung:\n",
    "            print(\"Выполнение остановлено: один из тестов завис.\")\n",
    "            sys.stdout.flush()\n",
    "            os._exit(1)\n",
    "    return results\n",
    "\n",
    "\n",
    "def _check(*tests, names=()):\n",
    "    \"\"\"Запускает проверки упражнения и печатает ✓ / ✗ и итог — как на сайте.\"\"\"\n",
    "    for name in names:\n",
    "        if \".\" in name:  # «Класс.метод» из заготовки: класс должен быть объявлен\n",
    "            if not isinstance(globals().get(name.split(\".\")[0]), type):\n",
    "                print(f\"✗ класс {name.split('.')[0]} не объявлен — выполните ячейку упражнения\")\n",
    "                return\n",
    "            continue\n",
    "        if name not in globals():\n",
    "            print(f\"✗ переменная {name} не создана — выполните ячейку упражнения\")\n",
    "            return\n",
    "        if globals()[name] is Ellipsis:\n",
    "            print(f\"✗ {name} пока равна ... — замените многоточие своим кодом\")\n",
    "            return\n",
    "    globals()[\"_TESTS\"] = list(tests)\n",
    "    _run_tests()"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "setup"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В прошлых уроках подклассы переопределяли `label`, и код вида `item.label()` давал для каждого класса свою\n",
    "строку. У этого есть имя: **полиморфизм** (polymorphism) — один вызов, разное поведение у разных классов.\n",
    "Главная польза полиморфизма в том, что код, который *вызывает* метод, не нужно менять, когда появляется новый\n",
    "класс.\n",
    "\n",
    "## Один вызов — разные классы\n",
    "\n",
    "Касса предлагает несколько способов доставки. Каждый способ — свой класс со своим расчётом, но у всех есть\n",
    "метод `cost(km)`. Код, который выбирает доставку, не проверяет классы — он просто вызывает `cost`:"
   ],
   "id": "text-9"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Три доставки, один вызов\n",
    "class Pickup:\n",
    "    name = \"самовывоз\"\n",
    "\n",
    "    def cost(self, km):\n",
    "        return 0\n",
    "\n",
    "\n",
    "class Courier:\n",
    "    name = \"курьер\"\n",
    "\n",
    "    def cost(self, km):\n",
    "        return 150 + 30 * km\n",
    "\n",
    "\n",
    "class Partner:\n",
    "    name = \"служба доставки\"\n",
    "\n",
    "    def cost(self, km):\n",
    "        return 290\n",
    "\n",
    "\n",
    "for option in [Pickup(), Courier(), Partner()]:\n",
    "    print(f\"{option.name}: 3 км — {option.cost(3)} ₽, 10 км — {option.cost(10)} ₽\")"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "delivery"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Без полиморфизма функция выглядела бы как цепочка `if isinstance(...) elif isinstance(...)`, и каждый новый\n",
    "способ доставки требовал бы правки этой цепочки."
   ],
   "id": "text-21"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 1. Самая дешёвая доставка\n",
    "\n",
    "Напишите функцию `cheapest(options, km)`: она возвращает тот способ доставки из списка `options`, у которого\n",
    "`cost(km)` меньше всех. Функция не должна зависеть от того, какие классы в списке.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "`min(options, key=...)` с функцией, которая для способа доставки возвращает его `cost(km)`.\n",
    "\n",
    "</details>"
   ],
   "id": "cheapest-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "def cheapest(options, km):\n",
    "    ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "cheapest"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 1 — выполните после своего решения\n",
    "class _Taxi:\n",
    "    \"класс, которого функция заранее не знает\"\n",
    "    name = \"такси\"\n",
    "\n",
    "    def cost(self, km):\n",
    "        return 100 + 40 * km\n",
    "\n",
    "\n",
    "def test_choice():\n",
    "    \"выбирает способ с наименьшей стоимостью\"\n",
    "    courier, partner = Courier(), Partner()\n",
    "    got = cheapest([courier, partner], 3)\n",
    "    assert got is not None, \"функция ничего не возвращает — нужен return\"\n",
    "    assert not isinstance(got, (int, float)), f\"функция вернула число {got!r}, а нужен сам способ доставки\"\n",
    "    assert got is courier, f\"на 3 км дешевле курьер (240 ₽), а функция выбрала {getattr(got, 'name', got)}\"\n",
    "    assert cheapest([courier, partner], 10) is partner, \"на 10 км дешевле служба доставки (290 ₽ против 450 ₽)\"\n",
    "\n",
    "\n",
    "def test_any_class():\n",
    "    \"работает с незнакомым классом\"\n",
    "    taxi, partner = _Taxi(), Partner()\n",
    "    got = cheapest([partner, taxi], 2)\n",
    "    assert got is taxi, \"на 2 км такси (180 ₽) дешевле службы доставки — функция должна сравнивать cost(km) любых объектов, без проверок класса\"\n",
    "\n",
    "_check(test_choice, test_any_class)"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "cheapest-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "def cheapest(options, km):\n",
    "    return min(options, key=lambda option: option.cost(km))\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "cheapest-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Утиная типизация\n",
    "\n",
    "Обратите внимание: классы доставки в демонстрации даже не связаны наследованием. Python не проверяет, от\n",
    "какого класса объект, — ему достаточно, что у объекта есть нужный метод. Это называется **утиная типизация**\n",
    "(duck typing): «если что-то ходит как утка и крякает как утка — это утка»."
   ],
   "id": "text-31"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Подарочный сертификат в чеке\n",
    "class Product:\n",
    "    def __init__(self, name, price):\n",
    "        self.name = name\n",
    "        self.price = price\n",
    "\n",
    "\n",
    "class GiftCertificate:  # не наследует от Product\n",
    "    def __init__(self, amount):\n",
    "        self.name = f\"Сертификат на {amount} ₽\"\n",
    "        self.price = amount\n",
    "\n",
    "\n",
    "def receipt(items):\n",
    "    for item in items:\n",
    "        print(f\"{item.name:<24}{item.price:>6} ₽\")\n",
    "\n",
    "\n",
    "receipt([Product(\"Латте\", 220), GiftCertificate(1000)])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "duck"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Функции `receipt` нужны только `name` и `price`. Сертификат — не товар и не наследует от `Product`, но в чек\n",
    "попадает так же."
   ],
   "id": "text-39"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 2. Сумма чего угодно\n",
    "\n",
    "Напишите функцию `total(items)`: сумма атрибутов `price` всех объектов списка — товаров, сертификатов,\n",
    "услуг, чего угодно с атрибутом `price`.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Функции нужен только атрибут `price` — класс объекта проверять не нужно.\n",
    "\n",
    "</details>\n",
    "<details><summary>Подсказка 2</summary>\n",
    "\n",
    "`sum(item.price for item in items)`.\n",
    "\n",
    "</details>"
   ],
   "id": "total-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "def total(items):\n",
    "    ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "total"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 2 — выполните после своего решения\n",
    "class _Service:\n",
    "    \"услуга — не товар, но с ценой\"\n",
    "\n",
    "    def __init__(self, price):\n",
    "        self.price = price\n",
    "\n",
    "\n",
    "def test_products():\n",
    "    \"сумма товаров\"\n",
    "    got = total([Product(\"Латте\", 220), Product(\"Круассан\", 140)])\n",
    "    assert got is not None, \"функция ничего не возвращает — нужен return\"\n",
    "    assert got == 360, f\"total для латте и круассана = {got!r}, а нужно 360\"\n",
    "\n",
    "\n",
    "def test_anything():\n",
    "    \"сумма объектов разных классов\"\n",
    "    got = total([Product(\"Латте\", 220), GiftCertificate(1000), _Service(300)])\n",
    "    assert got != 220, \"в сумму попал только товар — не проверяйте класс, у сертификата и услуги тоже есть price\"\n",
    "    assert got == 1520, f\"total = {got!r}, а латте, сертификат и услуга стоят 1520\"\n",
    "    assert total([]) == 0, \"сумма пустого списка — 0\"\n",
    "\n",
    "_check(test_products, test_anything)"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "total-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "def total(items):\n",
    "    return sum(item.price for item in items)\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "total-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Типичная ошибка: лишняя проверка класса.**\n",
    ">\n",
    "> Проверка `isinstance(item, Product)` в такой функции не защищает, а мешает: сертификат или услуга с ценой\n",
    "> будут молча пропущены, и сумма окажется меньше. Проверяйте класс, только когда поведение действительно\n",
    "> зависит от него."
   ],
   "id": "component-51"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Новый класс в готовом коде\n",
    "\n",
    "Сила полиморфизма видна, когда к готовому коду добавляют новый класс. Функция `notify` рассылает сообщение\n",
    "о готовности заказа по всем каналам — ей нужен только метод `send(text)`:"
   ],
   "id": "text-56"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# СМС и почта\n",
    "class SmsChannel:\n",
    "    def __init__(self, phone):\n",
    "        self.phone = phone\n",
    "\n",
    "    def send(self, text):\n",
    "        return f\"смс на {self.phone}: {text}\"\n",
    "\n",
    "\n",
    "class EmailChannel:\n",
    "    def __init__(self, address):\n",
    "        self.address = address\n",
    "\n",
    "    def send(self, text):\n",
    "        return f\"письмо на {self.address}: {text}\"\n",
    "\n",
    "\n",
    "def notify(channels, text):\n",
    "    return [channel.send(text) for channel in channels]\n",
    "\n",
    "\n",
    "sms = SmsChannel(\"+7 900 111-22-33\")\n",
    "email = EmailChannel(\"anna@example.com\")\n",
    "for line in notify([sms, email], \"заказ №17 принят\"):\n",
    "    print(line)"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "channels"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 3. Пуш-уведомление\n",
    "\n",
    "Объявите класс `PushChannel`: `PushChannel(\"Анна\")` хранит имя получателя `user`, а метод `send(text)`\n",
    "возвращает строку `\"пуш для Анна: <текст>\"`. Затем сохраните в `sent` результат `notify` для списка из трёх\n",
    "каналов: `sms`, `email` из демонстрации и нового пуш-канала для Анны — с текстом `\"заказ готов\"`.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Класс — как `SmsChannel`, только с другим текстом в `send`. Функцию `notify` менять не нужно.\n",
    "\n",
    "</details>"
   ],
   "id": "push-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "class PushChannel:\n",
    "    def __init__(self, user):\n",
    "        ...\n",
    "\n",
    "    def send(self, text):\n",
    "        ...\n",
    "\n",
    "\n",
    "sent = ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "push"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 3 — выполните после своего решения\n",
    "def test_channel():\n",
    "    \"PushChannel.send\"\n",
    "    try:\n",
    "        push = PushChannel(\"Анна\")\n",
    "    except TypeError as e:\n",
    "        assert False, f\"PushChannel(\\\"Анна\\\") не создаётся: {e}\"\n",
    "    assert getattr(push, \"user\", None) == \"Анна\", \"имя получателя хранится в атрибуте user\"\n",
    "    got = push.send(\"заказ готов\")\n",
    "    assert got == \"пуш для Анна: заказ готов\", f\"send(\\\"заказ готов\\\") вернул {got!r}\"\n",
    "\n",
    "\n",
    "def test_sent():\n",
    "    \"sent — результат notify для трёх каналов\"\n",
    "    assert isinstance(sent, list), f\"sent — это {type(sent).__name__}, а нужен список — результат notify(...)\"\n",
    "    assert len(sent) == 3, f\"в sent {len(sent)} сообщений, а каналов три: sms, email и пуш\"\n",
    "    assert sent[2] == \"пуш для Анна: заказ готов\", f\"третье сообщение: {sent[2]!r}\"\n",
    "    assert sent[0] == \"смс на +7 900 111-22-33: заказ готов\", \"первым должен идти канал sms\"\n",
    "\n",
    "_check(test_channel, test_sent, names=[\"PushChannel.__init__\",\"PushChannel.send\",\"sent\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "push-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "class PushChannel:\n",
    "    def __init__(self, user):\n",
    "        self.user = user\n",
    "\n",
    "    def send(self, text):\n",
    "        return f\"пуш для {self.user}: {text}\"\n",
    "\n",
    "\n",
    "sent = notify([sms, email, PushChannel(\"Анна\")], \"заказ готов\")\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "push-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `hasattr`: проверить, есть ли метод\n",
    "\n",
    "Иногда нужно узнать заранее, умеет ли объект что-то. Встроенная `hasattr(объект, \"имя\")` возвращает `True`,\n",
    "если у объекта есть атрибут или метод с таким именем:"
   ],
   "id": "text-71"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Есть ли у объекта send\n",
    "for thing in [sms, Product(\"Чай\", 120)]:\n",
    "    print(type(thing).__name__, hasattr(thing, \"send\"))"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "hasattr"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Вопрос.** Что вернёт `hasattr(GiftCertificate(1000), \"price\")` для сертификата из демонстрации о чеке?\n",
    "\n",
    "- `True`\n",
    "- `False` — сертификат не наследует от `Product`\n",
    "- ошибку `AttributeError`\n",
    "\n",
    "<details><summary>Ответ</summary>\n",
    "\n",
    "`True`\n",
    "\n",
    "`hasattr` смотрит, есть ли у объекта атрибут, а не от какого он класса: у сертификата `price` записан в `__init__`. Поэтому `receipt` и `total` с ним и работают.\n",
    "\n",
    "</details>"
   ],
   "id": "quiz-79"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Вопрос.** В кассу добавили класс `Taxi` с методом `cost(km)`. Что нужно изменить в функции `cheapest`?\n",
    "\n",
    "- ничего\n",
    "- добавить `isinstance(option, Taxi)`\n",
    "- сделать `Taxi` подклассом другого способа доставки\n",
    "\n",
    "<details><summary>Ответ</summary>\n",
    "\n",
    "ничего\n",
    "\n",
    "`cheapest` вызывает только `cost(km)`, а у `Taxi` этот метод есть. Наследование тут не обязательно — достаточно утиной типизации. Так и выглядит полиморфизм: новый класс встраивается, а старый код не меняется.\n",
    "\n",
    "</details>"
   ],
   "id": "quiz-89"
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python"
  },
  "colab": {
   "provenance": []
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}