{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Наследование\n", "\n", "class B(A): подкласс получает атрибуты и методы базового класса, может добавить свои и переопределить чужие. isinstance и issubclass в иерархии и проверки не в том порядке.\n", "\n", "Курс ООП в Python · урок `oop-inheritance` · [урок на сайте](https://ds-edu-trainer.vercel.app/courses/oop/inheritance).\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": [ "В меню «Кофейной лавки» есть обычные товары, сезонные напитки и выпечка. Всё это товары: у всех название,\n", "цена, строка для меню. Но у сезонных напитков своя пометка, а выпечку предлагают в комплекте с кофе.\n", "Копировать класс `Product` три раза и менять по строчке — плохая идея: исправление пришлось бы вносить\n", "в три места. Вместо этого классы строят **на основе** другого класса.\n", "\n", "## `class B(A)`\n", "\n", "Если в скобках после имени класса указать другой класс, новый класс **наследует** (inheritance) всё, что есть\n", "у того: атрибуты класса и методы, включая `__init__`. Класс в скобках называют **базовым** (base class,\n", "«родитель»), а новый — **подклассом** (subclass, «дочерний класс»):" ], "id": "text-9" }, { "cell_type": "code", "metadata": {}, "source": [ "# Подкласс без единой строки\n", "class Product:\n", " def __init__(self, name, price):\n", " self.name = name\n", " self.price = price\n", "\n", " def __repr__(self):\n", " return f\"{type(self).__name__}({self.name!r}, {self.price})\"\n", "\n", " def label(self):\n", " return f\"{self.name} — {self.price} ₽\"\n", "\n", "\n", "class Snack(Product):\n", " pass\n", "\n", "\n", "cookie = Snack(\"Овсяное печенье\", 90)\n", "print(cookie.label())\n", "print(cookie)" ], "execution_count": null, "outputs": [], "id": "inherit" }, { "cell_type": "markdown", "metadata": {}, "source": [ "У `Snack` нет своего тела, кроме `pass`, но экземпляр создаётся с названием и ценой и умеет `label()` —\n", "всё это пришло из `Product`. Поиск атрибута продолжается вверх по иерархии: сначала экземпляр, потом его\n", "класс, потом базовый класс.\n", "\n", "## Свои методы и переопределение\n", "\n", "Подкласс может **добавить** методы, которых нет у базового класса, и **переопределить** (override)\n", "существующие — объявить метод с тем же именем. Тогда для экземпляров подкласса работает новая версия, а для\n", "экземпляров базового класса — старая:" ], "id": "text-22" }, { "cell_type": "code", "metadata": {}, "source": [ "# Свой метод и своя версия label\n", "class Tea(Product):\n", " def brew_minutes(self): # новый метод\n", " return 4\n", "\n", " def label(self): # своя версия метода базового класса\n", " return f\"{self.name} — {self.price} ₽, заваривать {self.brew_minutes()} мин\"\n", "\n", "\n", "print(Tea(\"Улун\", 180).label())\n", "print(Product(\"Улун\", 180).label())" ], "execution_count": null, "outputs": [], "id": "override" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 1. Сезонный товар\n", "\n", "Объявите подкласс `SeasonalProduct` класса `Product` из демонстрации. Переопределите в нём `label()`:\n", "к обычной строке добавляется пометка — `\"Тыквенный латте — 290 ₽ (сезонное)\"`.\n", "\n", "
Подсказка 1\n", "\n", "`class SeasonalProduct(Product):` и метод `label(self)`, который собирает строку из `self.name` и `self.price`.\n", "\n", "
" ], "id": "seasonal-task" }, { "cell_type": "code", "metadata": {}, "source": [ "class SeasonalProduct: # укажите базовый класс\n", " def label(self):\n", " ..." ], "execution_count": null, "outputs": [], "id": "seasonal" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 1 — выполните после своего решения\n", "def test_subclass():\n", " \"SeasonalProduct — подкласс Product\"\n", " assert isinstance(SeasonalProduct, type), \"SeasonalProduct должен быть классом\"\n", " assert issubclass(SeasonalProduct, Product), \"SeasonalProduct не наследует от Product — укажите базовый класс в скобках: class SeasonalProduct(Product):\"\n", "\n", "\n", "def test_label():\n", " \"label — с пометкой «сезонное»\"\n", " assert issubclass(SeasonalProduct, Product), \"сначала укажите базовый класс Product\"\n", " try:\n", " item = SeasonalProduct(\"Тыквенный латте\", 290)\n", " except TypeError as e:\n", " assert False, f\"SeasonalProduct(\\\"Тыквенный латте\\\", 290) не создаётся: {e}. Свой __init__ не нужен — он наследуется\"\n", " got = item.label()\n", " assert got == \"Тыквенный латте — 290 ₽ (сезонное)\", f\"label() вернул {got!r}, а нужно \\\"Тыквенный латте — 290 ₽ (сезонное)\\\"\"\n", "\n", "\n", "def test_base_unchanged():\n", " \"у обычного товара label прежний\"\n", " got = Product(\"Латте\", 220).label()\n", " assert got == \"Латте — 220 ₽\", f\"у Product label() стал {got!r} — меняйте метод только в подклассе\"\n", "\n", "_check(test_subclass, test_label, test_base_unchanged, names=[\"SeasonalProduct.label\"])" ], "execution_count": null, "outputs": [], "id": "seasonal-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "class SeasonalProduct(Product):\n", " def label(self):\n", " return f\"{self.name} — {self.price} ₽ (сезонное)\"\n", "```\n", "\n", "
" ], "id": "seasonal-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 2. Выпечка к кофе\n", "\n", "Объявите подкласс `Pastry` класса `Product` с новым методом `combo_price(drink)`: цена комплекта «выпечка +\n", "напиток» со скидкой 10 %, округлённая до целых рублей. `drink` — любой товар с атрибутом `price`.\n", "\n", "
Подсказка 1\n", "\n", "Сумма цен — `self.price + drink.price`; со скидкой 10 % — умножить на 90 и разделить на 100, затем `round`.\n", "\n", "
" ], "id": "pastry-task" }, { "cell_type": "code", "metadata": {}, "source": [ "class Pastry(Product):\n", " def combo_price(self, drink):\n", " ..." ], "execution_count": null, "outputs": [], "id": "pastry" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 2 — выполните после своего решения\n", "def test_combo():\n", " \"комплект со скидкой 10 %\"\n", " croissant = Pastry(\"Круассан\", 140)\n", " got = croissant.combo_price(Product(\"Латте\", 220))\n", " assert got is not None, \"combo_price ничего не возвращает — нужен return\"\n", " assert got != 360, \"360 — сумма без скидки, а комплект дешевле на 10 %\"\n", " assert got != 36, \"36 — это сама скидка, а нужна цена комплекта\"\n", " assert got == 324, f\"круассан + латте = {got!r}, а со скидкой 10 % нужно 324\"\n", "\n", "\n", "def test_round():\n", " \"цена округляется до целых\"\n", " got = Pastry(\"Маффин\", 133).combo_price(Product(\"Чай\", 120))\n", " assert got == 228, f\"маффин за 133 + чай за 120 = {got!r}, а нужно 228 (227.7 после скидки, округлите)\"\n", "\n", "\n", "def test_inherits():\n", " \"Pastry — товар с label\"\n", " assert issubclass(Pastry, Product), \"Pastry должен наследовать от Product\"\n", " assert Pastry(\"Круассан\", 140).label() == \"Круассан — 140 ₽\", \"label у выпечки должен остаться от Product\"\n", "\n", "_check(test_combo, test_round, test_inherits, names=[\"Pastry.combo_price\"])" ], "execution_count": null, "outputs": [], "id": "pastry-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "class Pastry(Product):\n", " def combo_price(self, drink):\n", " return round((self.price + drink.price) * 90 / 100)\n", "```\n", "\n", "
" ], "id": "pastry-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## `isinstance` и `issubclass` в иерархии\n", "\n", "Экземпляр подкласса — это **и** экземпляр базового класса: круассан — тоже товар. Поэтому `isinstance` для\n", "него возвращает `True` с обоими классами. А `issubclass(A, B)` проверяет классы: построен ли `A` на основе `B`:" ], "id": "text-48" }, { "cell_type": "code", "metadata": {}, "source": [ "# Круассан — тоже товар\n", "croissant = Pastry(\"Круассан\", 140)\n", "print(isinstance(croissant, Pastry), isinstance(croissant, Product))\n", "print(isinstance(Product(\"Чай\", 120), Pastry))\n", "print(issubclass(Pastry, Product), issubclass(SeasonalProduct, Pastry))\n", "print(issubclass(bool, int))" ], "execution_count": null, "outputs": [], "id": "isinstance" }, { "cell_type": "markdown", "metadata": {}, "source": [ "Вспомните вопрос из урока «Всё в Python — объект»: `isinstance(True, int)` — `True`, потому что `bool` — подкласс `int`." ], "id": "text-55" }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Типичная ошибка: проверки isinstance не в том порядке.**\n", ">\n", "> В цепочке `if/elif` с `isinstance` базовый класс должен проверяться **последним**. Если первой стоит проверка\n", "> `isinstance(x, Product)`, она сработает и для `Pastry`, и для `SeasonalProduct` — до проверок подклассов дело\n", "> не дойдёт." ], "id": "component-58" }, { "cell_type": "code", "metadata": {}, "source": [ "# Все стали «товарами»\n", "def shelf_of(item):\n", " if isinstance(item, Product): # ошибка: базовый класс первым\n", " return \"общая полка\"\n", " elif isinstance(item, Pastry):\n", " return \"витрина с выпечкой\"\n", " return \"?\"\n", "\n", "\n", "for item in [Product(\"Чай\", 120), Pastry(\"Круассан\", 140)]:\n", " print(item.name, \"→\", shelf_of(item))" ], "execution_count": null, "outputs": [], "id": "wrong-order" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 3. Что это за товар\n", "\n", "Напишите функцию `kind_of(item)`: она возвращает `\"сезонное\"` для `SeasonalProduct`, `\"выпечка\"` для `Pastry`\n", "и `\"товар\"` для любого другого `Product`.\n", "\n", "
Подсказка 1\n", "\n", "Сначала проверки подклассов, `isinstance(item, Product)` — или просто `return \"товар\"` — в конце.\n", "\n", "
" ], "id": "kind-task" }, { "cell_type": "code", "metadata": {}, "source": [ "def kind_of(item):\n", " ..." ], "execution_count": null, "outputs": [], "id": "kind" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 3 — выполните после своего решения\n", "def test_kinds():\n", " \"сезонное, выпечка и обычный товар\"\n", " got = [kind_of(SeasonalProduct(\"Глинтвейн\", 300)), kind_of(Pastry(\"Круассан\", 140)), kind_of(Product(\"Чай\", 120))]\n", " assert got != [\"товар\", \"товар\", \"товар\"], \"для всех вернулось «товар» — проверка isinstance(item, Product) стоит раньше проверок подклассов\"\n", " assert got == [\"сезонное\", \"выпечка\", \"товар\"], f\"kind_of вернула {got}, а нужно ['сезонное', 'выпечка', 'товар']\"\n", "\n", "_check(test_kinds)" ], "execution_count": null, "outputs": [], "id": "kind-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "def kind_of(item):\n", " if isinstance(item, SeasonalProduct):\n", " return \"сезонное\"\n", " if isinstance(item, Pastry):\n", " return \"выпечка\"\n", " return \"товар\"\n", "```\n", "\n", "
" ], "id": "kind-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Вопрос.** Что вернёт `issubclass(Product, Pastry)`?\n", "\n", "- `True` — они связаны наследованием\n", "- `False`\n", "- ошибку `TypeError`\n", "\n", "
Ответ\n", "\n", "`False`\n", "\n", "`issubclass` смотрит в одну сторону: `Pastry` построен на основе `Product`, а не наоборот. Выпечка — товар, но не всякий товар — выпечка.\n", "\n", "
" ], "id": "quiz-73" }, { "cell_type": "markdown", "metadata": {}, "source": [ "Наследование хорошо, когда подкласс **является** разновидностью базового класса: сезонный товар — товар,\n", "выпечка — товар. В следующем уроке подкласс научится не заменять метод базового класса целиком, а расширять\n", "его." ], "id": "text-82" } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "name": "python" }, "colab": { "provenance": [] } }, "nbformat": 4, "nbformat_minor": 5 }