{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# super()\n", "\n", "super() вызывает метод базового класса из подкласса: свой __init__ с дополнительными атрибутами, расширение метода вместо копирования, порядок поиска методов MRO и забытый super().__init__.\n", "\n", "Курс ООП в Python · урок `oop-super` · [урок на сайте](https://ds-edu-trainer.vercel.app/courses/oop/super).\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", "третье: **дополнить** метод базового класса — сделать всё то же самое и ещё немного. Для этого есть `super()`.\n", "\n", "## Свой `__init__` в подклассе\n", "\n", "У выпечки, кроме названия и цены, есть вес. Значит, подклассу `Pastry` нужен свой `__init__` с параметром\n", "`weight`. Но переписывать в нём `self.name = name` и `self.price = price` не стоит: это уже умеет `__init__`\n", "базового класса. Вызов `super().__init__(…)` выполняет `__init__` базового класса для этого же экземпляра:" ], "id": "text-9" }, { "cell_type": "code", "metadata": {}, "source": [ "# Pastry с весом\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", " def cost(self, quantity):\n", " return self.price * quantity\n", "\n", "\n", "class Pastry(Product):\n", " def __init__(self, name, price, weight):\n", " super().__init__(name, price) # name и price записывает Product\n", " self.weight = weight\n", "\n", "\n", "croissant = Pastry(\"Круассан\", 140, 70)\n", "print(croissant.name, croissant.price, croissant.weight)\n", "print(croissant.label())" ], "execution_count": null, "outputs": [], "id": "init" }, { "cell_type": "markdown", "metadata": {}, "source": [ "`super()` — это «тот же `self`, но методы ищутся начиная с класса, следующего за тем, где написан\n", "`super()`»; пока у класса один базовый класс, это и есть базовый класс. Поэтому `self` в скобки не\n", "передают: `super().__init__(name, price)`." ], "id": "text-20" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 1. Напиток с объёмом\n", "\n", "Объявите подкласс `Drink` класса `Product`: `Drink(\"Латте\", 220, 300)` — название, цена и объём `volume`\n", "в миллилитрах. Название и цену пусть записывает `__init__` базового класса. Добавьте метод `per_100ml()` —\n", "цена за 100 мл, округлённая до одного знака.\n", "\n", "
Подсказка 1\n", "\n", "Первая строка `__init__` подкласса — `super().__init__(name, price)`, затем `self.volume = volume`.\n", "\n", "
" ], "id": "drink-task" }, { "cell_type": "code", "metadata": {}, "source": [ "class Drink(Product):\n", " def __init__(self, name, price, volume):\n", " ...\n", "\n", " def per_100ml(self):\n", " ..." ], "execution_count": null, "outputs": [], "id": "drink" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 1 — выполните после своего решения\n", "def _latte():\n", " try:\n", " return Drink(\"Латте\", 220, 300)\n", " except TypeError as e:\n", " assert False, f\"Drink(\\\"Латте\\\", 220, 300) не создаётся: {e}\"\n", "\n", "\n", "def test_attributes():\n", " \"name, price и volume\"\n", " assert issubclass(Drink, Product), \"Drink должен наследовать от Product\"\n", " latte = _latte()\n", " assert hasattr(latte, \"name\") and hasattr(latte, \"price\"), \"у напитка нет name и price — вызовите в __init__ super().__init__(name, price)\"\n", " assert (latte.name, latte.price) == (\"Латте\", 220), f\"name и price = {latte.name!r}, {latte.price!r}\"\n", " assert getattr(latte, \"volume\", None) == 300, \"объём хранится в атрибуте volume\"\n", "\n", "\n", "def test_uses_super():\n", " \"name и price записывает Product.__init__\"\n", " calls = []\n", " original = Product.__init__\n", "\n", " def spy(self, *args, **kwargs):\n", " calls.append(1)\n", " original(self, *args, **kwargs)\n", " Product.__init__ = spy\n", " try:\n", " latte = Drink(\"Латте\", 220, 300)\n", " finally:\n", " Product.__init__ = original\n", " assert calls == [1], \"Product.__init__ не вызывался — используйте super().__init__(name, price), а не копируйте его строки\"\n", " assert (latte.name, latte.price) == (\"Латте\", 220), \"в super().__init__ переданы не те значения — нужны name и price\"\n", "\n", "\n", "def test_per_100ml():\n", " \"per_100ml — цена за 100 мл\"\n", " latte = _latte()\n", " assert hasattr(latte, \"price\"), \"сначала вызовите super().__init__(name, price) — без цены per_100ml не посчитать\"\n", " assert latte.per_100ml() == 73.3, f\"per_100ml() у латте = {latte.per_100ml()!r}, а нужно 73.3\"\n", " assert latte.label() == \"Латте — 220 ₽\", \"label у напитка должен работать как у Product\"\n", "\n", "_check(test_attributes, test_uses_super, test_per_100ml, names=[\"Drink.__init__\",\"Drink.per_100ml\"])" ], "execution_count": null, "outputs": [], "id": "drink-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "class Drink(Product):\n", " def __init__(self, name, price, volume):\n", " super().__init__(name, price)\n", " self.volume = volume\n", "\n", " def per_100ml(self):\n", " return round(self.price / self.volume * 100, 1)\n", "```\n", "\n", "
" ], "id": "drink-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Типичная ошибка: забытый super().__init__.**\n", ">\n", "> Если в `__init__` подкласса не вызвать `super().__init__(…)`, `__init__` базового класса не выполнится вовсе:\n", "> свой метод **заменяет** метод базового класса. Экземпляр получится без `name` и `price`, и ошибка всплывёт\n", "> позже — `AttributeError` при первом обращении к ним." ], "id": "component-33" }, { "cell_type": "code", "metadata": {}, "source": [ "# super().__init__ не вызвали\n", "# Эта ячейка показывает ошибку AttributeError: она перехвачена, чтобы «Выполнить всё» не останавливалось.\n", "try:\n", " class Cake(Product):\n", " def __init__(self, name, price, slices):\n", " self.slices = slices # забыли super().__init__\n", "\n", "\n", " cake = Cake(\"Медовик\", 1200, 8)\n", " print(cake.slices)\n", " print(cake.label())\n", "except Exception as error:\n", " print(f\"{type(error).__name__}: {error}\")" ], "execution_count": null, "outputs": [], "id": "forgot" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Расширить, а не скопировать\n", "\n", "Так же `super()` работает в любом методе: подкласс вызывает версию базового класса и что-то добавляет к её\n", "результату. Если потом формат строки в `Product.label` поменяется, подкласс подхватит изменение сам:" ], "id": "text-40" }, { "cell_type": "code", "metadata": {}, "source": [ "# label с весом\n", "class Pastry(Product):\n", " def __init__(self, name, price, weight):\n", " super().__init__(name, price)\n", " self.weight = weight\n", "\n", " def label(self):\n", " return f\"{super().label()}, {self.weight} г\"\n", "\n", "\n", "print(Pastry(\"Круассан\", 140, 70).label())" ], "execution_count": null, "outputs": [], "id": "extend" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 2. Пометка без копирования\n", "\n", "Объявите подкласс `SeasonalProduct` класса `Product`, в котором `label()` возвращает строку базового класса\n", "и пометку: `\"Глинтвейн — 300 ₽ (до 31 декабря)\"`. Дату окончания сезона передают при создании:\n", "`SeasonalProduct(\"Глинтвейн\", 300, \"31 декабря\")`, она хранится в атрибуте `until`.\n", "\n", "
Подсказка 1\n", "\n", "Название и цену запишет `__init__` базового класса; подклассу остаётся `until`.\n", "\n", "
\n", "
Подсказка 2\n", "\n", "В `label` — результат `super().label()` плюс пометка в скобках.\n", "\n", "
" ], "id": "seasonal-task" }, { "cell_type": "code", "metadata": {}, "source": [ "class SeasonalProduct(Product):\n", " def __init__(self, name, price, until):\n", " ...\n", "\n", " def label(self):\n", " ..." ], "execution_count": null, "outputs": [], "id": "seasonal" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 2 — выполните после своего решения\n", "def _item():\n", " try:\n", " return SeasonalProduct(\"Глинтвейн\", 300, \"31 декабря\")\n", " except TypeError as e:\n", " assert False, f\"SeasonalProduct(\\\"Глинтвейн\\\", 300, \\\"31 декабря\\\") не создаётся: {e}\"\n", "\n", "\n", "def test_init():\n", " \"name, price и until\"\n", " item = _item()\n", " assert hasattr(item, \"name\"), \"у товара нет name — вызовите в __init__ super().__init__(name, price)\"\n", " assert getattr(item, \"until\", None) == \"31 декабря\", \"дата хранится в атрибуте until\"\n", "\n", "\n", "def test_label():\n", " \"строка базового класса + пометка\"\n", " item = _item()\n", " assert hasattr(item, \"name\"), \"сначала вызовите super().__init__\"\n", " got = item.label()\n", " assert got == \"Глинтвейн — 300 ₽ (до 31 декабря)\", f\"label() вернул {got!r}\"\n", "\n", "\n", "def test_extends():\n", " \"label берёт строку у Product\"\n", " original = Product.label\n", " Product.label = lambda self: f\"[{self.name}]\"\n", " try:\n", " got = _item().label()\n", " finally:\n", " Product.label = original\n", " assert got == \"[Глинтвейн] (до 31 декабря)\", \"label подкласса не использует label базового класса — вызовите super().label() вместо того, чтобы собирать строку заново\"\n", "\n", "_check(test_init, test_label, test_extends, names=[\"SeasonalProduct.__init__\",\"SeasonalProduct.label\"])" ], "execution_count": null, "outputs": [], "id": "seasonal-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "class SeasonalProduct(Product):\n", " def __init__(self, name, price, until):\n", " super().__init__(name, price)\n", " self.until = until\n", "\n", " def label(self):\n", " return f\"{super().label()} (до {self.until})\"\n", "```\n", "\n", "
" ], "id": "seasonal-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 3. Оптовая цена\n", "\n", "У `Product` есть метод `cost(quantity)` — стоимость `quantity` штук. Объявите подкласс `WholesaleProduct`:\n", "его `cost` от 10 штук даёт скидку 15 % (округление до целых), а меньше 10 штук считает так же, как\n", "`Product`. Используйте `super().cost(quantity)`, а не повторяйте умножение.\n", "\n", "
Подсказка 1\n", "\n", "Сначала получите полную стоимость у базового класса, потом решите, нужна ли скидка.\n", "\n", "
\n", "
Подсказка 2\n", "\n", "`full = super().cost(quantity)`; от 10 штук — `round(full * 85 / 100)`.\n", "\n", "
" ], "id": "wholesale-task" }, { "cell_type": "code", "metadata": {}, "source": [ "class WholesaleProduct(Product):\n", " def cost(self, quantity):\n", " ..." ], "execution_count": null, "outputs": [], "id": "wholesale" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 3 — выполните после своего решения\n", "def test_small():\n", " \"меньше 10 штук — без скидки\"\n", " beans = WholesaleProduct(\"Зёрна, 250 г\", 120)\n", " got = beans.cost(9)\n", " assert got is not None, \"cost ничего не возвращает — нужен return\"\n", " assert got == 1080, f\"cost(9) = {got!r}, а 9 пачек по 120 ₽ без скидки — 1080\"\n", "\n", "\n", "def test_bulk():\n", " \"от 10 штук — скидка 15 %\"\n", " beans = WholesaleProduct(\"Зёрна, 250 г\", 120)\n", " assert beans.cost(10) != 1200, \"от 10 штук должна быть скидка 15 %\"\n", " assert beans.cost(10) == 1020, f\"cost(10) = {beans.cost(10)!r}, а нужно 1020\"\n", " got = WholesaleProduct(\"Сироп\", 133).cost(12)\n", " assert got == 1357, f\"12 бутылок сиропа по 133 ₽ = {got!r}, а со скидкой нужно 1357 (1356.6, округлите)\"\n", "\n", "\n", "def test_extends():\n", " \"оптовая цена опирается на Product.cost\"\n", " original = Product.cost\n", " Product.cost = lambda self, quantity: 1000\n", " try:\n", " got = WholesaleProduct(\"Сироп\", 133).cost(12)\n", " finally:\n", " Product.cost = original\n", " assert got == 850, \"cost подкласса не использует cost базового класса — вызовите super().cost(quantity) вместо умножения\"\n", "\n", "_check(test_small, test_bulk, test_extends, names=[\"WholesaleProduct.cost\"])" ], "execution_count": null, "outputs": [], "id": "wholesale-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "class WholesaleProduct(Product):\n", " def cost(self, quantity):\n", " full = super().cost(quantity)\n", " if quantity >= 10:\n", " return round(full * 85 / 100)\n", " return full\n", "```\n", "\n", "
" ], "id": "wholesale-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Порядок поиска методов: MRO\n", "\n", "Куда именно смотрит `super()`? У каждого класса есть **порядок разрешения методов** (method resolution order,\n", "MRO) — список классов, в котором Python ищет атрибуты: сам класс, его базовый класс, базовый класс базового и\n", "так далее. В конце всегда стоит `object` — базовый класс всех классов. MRO хранится в атрибуте `__mro__`:" ], "id": "text-65" }, { "cell_type": "code", "metadata": {}, "source": [ "# MRO подкласса\n", "print([cls.__name__ for cls in Pastry.__mro__])\n", "print([cls.__name__ for cls in WholesaleProduct.__mro__])" ], "execution_count": null, "outputs": [], "id": "mro" }, { "cell_type": "markdown", "metadata": {}, "source": [ "`super()` берёт следующий класс в MRO после текущего. Пока у класса один базовый класс, MRO — просто цепочка\n", "вверх. У класса может быть и несколько базовых — **множественное наследование** (multiple inheritance), —\n", "тогда MRO решает, чей метод найдётся первым. В этом курсе оно не понадобится; для начала хватает правила:\n", "один базовый класс, остальное — композицией (модуль 6)." ], "id": "text-73" }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Вопрос.** Каким классом заканчивается `Product.__mro__` у класса, объявленного как `class Product:` — без базового класса?\n", "\n", "- `Product`\n", "- `object`\n", "- `type`\n", "\n", "
Ответ\n", "\n", "`object`\n", "\n", "Класс без базового класса в скобках всё равно наследует от `object` — от него приходят `__repr__` с адресом, `__eq__` по тождественности и другие методы по умолчанию. `type` — класс самих классов, а не их базовый класс.\n", "\n", "
" ], "id": "quiz-79" } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "name": "python" }, "colab": { "provenance": [] } }, "nbformat": 4, "nbformat_minor": 5 }