{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# __init__ и self\n", "\n", "Метод __init__ заполняет атрибуты нового экземпляра сразу при создании, а self — это сам этот экземпляр. Параметры, значения по умолчанию и забытый self.\n", "\n", "Курс ООП в Python · урок `oop-init` · [урок на сайте](https://ds-edu-trainer.vercel.app/courses/oop/init).\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", "них — внутри класса, в специальном методе `__init__`.\n", "\n", "## Метод `__init__`\n", "\n", "Функция, объявленная внутри класса, называется **методом**. У метода с именем `__init__` особая роль:\n", "Python вызывает его сам, сразу после создания экземпляра. В `__init__` экземпляр заполняют атрибутами:" ], "id": "text-9" }, { "cell_type": "code", "metadata": {}, "source": [ "# Product с __init__\n", "class Product:\n", " def __init__(self, name, price):\n", " self.name = name\n", " self.price = price\n", "\n", "\n", "latte = Product(\"Латте\", 220)\n", "tea = Product(\"Чай\", 120)\n", "print(latte.name, latte.price)\n", "print(tea.name, tea.price)" ], "execution_count": null, "outputs": [], "id": "init" }, { "cell_type": "markdown", "metadata": {}, "source": [ "Разберём по шагам, что делает `Product(\"Латте\", 220)`:\n", "\n", "1. Python создаёт новый пустой экземпляр `Product`.\n", "2. Вызывает `__init__`, передавая **этот экземпляр первым аргументом**, а `\"Латте\"` и `220` — следом.\n", " Первый параметр метода по соглашению называют `self` — «сам экземпляр».\n", "3. Строки `self.name = name` записывают атрибуты в этот экземпляр — так же, как `cup.name = …` снаружи.\n", "4. Готовый экземпляр возвращается и попадает в переменную.\n", "\n", "Порядок легко увидеть, если напечатать что-нибудь внутри `__init__`:" ], "id": "text-19" }, { "cell_type": "code", "metadata": {}, "source": [ "# Когда вызывается __init__\n", "class Cup:\n", " def __init__(self, volume):\n", " print(f\"__init__: заполняю экземпляр, volume = {volume}\")\n", " self.volume = volume\n", "\n", "\n", "print(\"до вызова Cup\")\n", "big = Cup(400)\n", "print(\"после вызова Cup:\", big.volume)" ], "execution_count": null, "outputs": [], "id": "steps" }, { "cell_type": "markdown", "metadata": {}, "source": [ "Метод `__init__` называют **инициализатором** (initializer): он не создаёт объект — объект к этому моменту\n", "уже есть, — а заполняет его. Имена с двумя подчёркиваниями с обеих сторон Python зарезервировал для таких\n", "особых методов; их будет много, и у них есть общее название — **магические методы** (special methods;\n", "их ещё называют dunder — от double underscore). Подробно о них — в модуле 4.\n", "\n", "Теперь забыть атрибут не получится: аргументы `__init__` обязательны, и без них экземпляр не создастся:" ], "id": "text-31" }, { "cell_type": "code", "metadata": {}, "source": [ "# Забыли аргумент\n", "# Эта ячейка показывает ошибку TypeError: она перехвачена, чтобы «Выполнить всё» не останавливалось.\n", "try:\n", " Product(\"Чай\")\n", "except Exception as error:\n", " print(f\"{type(error).__name__}: {error}\")" ], "execution_count": null, "outputs": [], "id": "missing" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 1. Напиток с __init__\n", "\n", "Допишите класс `Drink`: метод `__init__(self, name, price)` должен записывать в экземпляр атрибуты `name`\n", "и `price`.\n", "\n", "
Подсказка 1\n", "\n", "Две строки внутри метода: `self.name = name` и `self.price = price`.\n", "\n", "
" ], "id": "drink-init-task" }, { "cell_type": "code", "metadata": {}, "source": [ "class Drink:\n", " def __init__(self, name, price):\n", " ... # запишите атрибуты name и price" ], "execution_count": null, "outputs": [], "id": "drink-init" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 1 — выполните после своего решения\n", "def _make(*args):\n", " \"создаёт Drink; если вызов не удался — None и текст ошибки\"\n", " try:\n", " return Drink(*args), \"\"\n", " except TypeError as e:\n", " return None, str(e)\n", "\n", "\n", "def test_create():\n", " \"Drink(\\\"Раф\\\", 260) создаёт экземпляр\"\n", " drink, error = _make(\"Раф\", 260)\n", " assert drink is not None, f\"Drink(\\\"Раф\\\", 260) не создаётся: {error}. Первый параметр __init__ — self, за ним name и price\"\n", "\n", "\n", "def test_attributes():\n", " \"атрибуты name и price — из аргументов\"\n", " drink, error = _make(\"Раф\", 260)\n", " assert drink is not None, \"сначала исправьте создание экземпляра (проверка выше)\"\n", " assert hasattr(drink, \"name\") and hasattr(drink, \"price\"), \"у экземпляра нет атрибутов name и price — внутри __init__ пишите self.name = name, а не name = name\"\n", " assert drink.name == \"Раф\" and drink.price == 260, f\"у Drink(\\\"Раф\\\", 260) name = {drink.name!r}, price = {drink.price!r}\"\n", "\n", "\n", "def test_independent():\n", " \"у двух экземпляров — свои атрибуты\"\n", " a, _ = _make(\"Раф\", 260)\n", " b, _ = _make(\"Чай\", 120)\n", " assert a is not None and b is not None, \"сначала исправьте создание экземпляра (проверка выше)\"\n", " assert getattr(a, \"price\", None) == 260 and getattr(b, \"price\", None) == 120, \"у Drink(\\\"Раф\\\", 260) и Drink(\\\"Чай\\\", 120) должны быть разные цены — берите их из параметров\"\n", "\n", "_check(test_create, test_attributes, test_independent, names=[\"Drink.__init__\"])" ], "execution_count": null, "outputs": [], "id": "drink-init-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "class Drink:\n", " def __init__(self, name, price):\n", " self.name = name\n", " self.price = price\n", "```\n", "\n", "
" ], "id": "drink-init-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Забытый `self.`" ], "id": "text-47" }, { "cell_type": "code", "metadata": {}, "source": [ "# Атрибут без self.\n", "# Эта ячейка показывает ошибку AttributeError: она перехвачена, чтобы «Выполнить всё» не останавливалось.\n", "try:\n", " class Bun:\n", " def __init__(self, name):\n", " name = name # забыли self.\n", "\n", "\n", " bun = Bun(\"Круассан\")\n", " print(bun.name)\n", "except Exception as error:\n", " print(f\"{type(error).__name__}: {error}\")" ], "execution_count": null, "outputs": [], "id": "no-self" }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Типичная ошибка: забыли self. — атрибут не сохранился.**\n", ">\n", "> Строка `name = name` внутри `__init__` создаёт обычную переменную метода, и она исчезает, когда метод\n", "> закончился. Атрибутом экземпляра значение становится только через `self.`: `self.name = name`. Ошибка\n", "> проявится позже — `AttributeError` при чтении атрибута." ], "id": "component-52" }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Вопрос.** Сколько раз выполнится `__init__` в этом коде?\n", "\n", "```python\n", "a = Cup()\n", "b = Cup()\n", "c = a\n", "```\n", "\n", "- `3`\n", "- `2`\n", "- `1`\n", "\n", "
Ответ\n", "\n", "`2`\n", "\n", "`__init__` вызывается при каждом создании экземпляра, то есть при каждом вызове `Cup()`. Строка `c = a` нового экземпляра не создаёт: переменная `c` получает тот же объект, что и `a`.\n", "\n", "
" ], "id": "quiz-58" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Значения по умолчанию\n", "\n", "Параметры `__init__` — обычные параметры функции, и у них могут быть значения по умолчанию. Тогда аргумент\n", "можно не передавать:" ], "id": "text-73" }, { "cell_type": "code", "metadata": {}, "source": [ "# Объём по умолчанию\n", "class Product:\n", " def __init__(self, name, price, volume=250):\n", " self.name = name\n", " self.price = price\n", " self.volume = volume\n", "\n", "\n", "print(Product(\"Капучино\", 220).volume)\n", "print(Product(\"Капучино\", 260, 400).volume)" ], "execution_count": null, "outputs": [], "id": "defaults" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 2. Размер по умолчанию\n", "\n", "Объявите класс `Drink` заново, с тремя атрибутами: `name`, `price` и `size`. Размер по умолчанию — `\"M\"`:\n", "`Drink(\"Чай\", 120)` создаёт средний чай, а `Drink(\"Чай\", 150, \"L\")` — большой.\n", "\n", "
Подсказка 1\n", "\n", "Значение по умолчанию задаётся в списке параметров: `def __init__(self, name, price, size=\"M\"):`.\n", "\n", "
" ], "id": "size-task" }, { "cell_type": "code", "metadata": {}, "source": [ "class Drink:\n", " def __init__(self, name, price): # добавьте параметр size\n", " ..." ], "execution_count": null, "outputs": [], "id": "size" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 2 — выполните после своего решения\n", "def test_default():\n", " \"Drink(\\\"Чай\\\", 120) — размер M\"\n", " try:\n", " tea = Drink(\"Чай\", 120)\n", " except TypeError:\n", " assert False, \"Drink(\\\"Чай\\\", 120) не создаётся без размера — дайте параметру size значение по умолчанию: size=\\\"M\\\"\"\n", " assert hasattr(tea, \"size\"), \"у экземпляра нет атрибута size — запишите его в __init__: self.size = size\"\n", " assert tea.size == \"M\", f\"у Drink(\\\"Чай\\\", 120) size = {tea.size!r}, а по умолчанию нужно \\\"M\\\"\"\n", " assert getattr(tea, \"name\", None) == \"Чай\" and getattr(tea, \"price\", None) == 120, \"name и price по-прежнему берутся из аргументов\"\n", "\n", "\n", "def test_given():\n", " \"Drink(\\\"Чай\\\", 150, \\\"L\\\") — размер L\"\n", " try:\n", " tea = Drink(\"Чай\", 150, \"L\")\n", " except TypeError:\n", " assert False, \"Drink(\\\"Чай\\\", 150, \\\"L\\\") не создаётся — добавьте в __init__ третий параметр size\"\n", " assert getattr(tea, \"size\", None) == \"L\", f\"у Drink(\\\"Чай\\\", 150, \\\"L\\\") size = {getattr(tea, 'size', None)!r}, а нужно \\\"L\\\" — берите размер из параметра\"\n", "\n", "_check(test_default, test_given, names=[\"Drink.__init__\"])" ], "execution_count": null, "outputs": [], "id": "size-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "class Drink:\n", " def __init__(self, name, price, size=\"M\"):\n", " self.name = name\n", " self.price = price\n", " self.size = size\n", "```\n", "\n", "
" ], "id": "size-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Атрибуты не только из аргументов\n", "\n", "В `__init__` можно записать и атрибут, которого нет среди параметров, — начальное значение, одинаковое для\n", "всех новых экземпляров, или значение, вычисленное из аргументов:" ], "id": "text-87" }, { "cell_type": "code", "metadata": {}, "source": [ "# Начальное и вычисленное значение\n", "class Pastry:\n", " def __init__(self, name, price, weight):\n", " self.name = name\n", " self.price = price\n", " self.weight = weight\n", " self.per_100g = round(price / weight * 100) # вычислено из аргументов\n", " self.sold = 0 # начальное значение, одинаковое для всех\n", "\n", "\n", "croissant = Pastry(\"Круассан\", 140, 70)\n", "print(croissant.per_100g, croissant.sold)" ], "execution_count": null, "outputs": [], "id": "computed" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 3. Новый покупатель\n", "\n", "Объявите класс `Customer`: `Customer(\"Анна\", \"+7 900 111-22-33\")` создаёт покупателя с атрибутами `name`\n", "и `phone` из аргументов и `points` — баллами лояльности. У нового покупателя их 0, и передавать их при\n", "создании не нужно.\n", "\n", "
Подсказка 1\n", "\n", "`points` нет среди параметров: в `__init__` просто `self.points = 0`.\n", "\n", "
" ], "id": "customer-task" }, { "cell_type": "code", "metadata": {}, "source": [ "class Customer:\n", " def __init__(self, name, phone):\n", " ..." ], "execution_count": null, "outputs": [], "id": "customer" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 3 — выполните после своего решения\n", "def test_create():\n", " \"Customer(имя, телефон) создаётся с двумя аргументами\"\n", " try:\n", " Customer(\"Анна\", \"+7 900 111-22-33\")\n", " except TypeError as e:\n", " assert False, f\"Customer(\\\"Анна\\\", \\\"+7 900 111-22-33\\\") не создаётся: {e}. Баллы не передаются при создании — их нет среди параметров\"\n", "\n", "\n", "def test_attributes():\n", " \"name, phone и points = 0\"\n", " try:\n", " anna = Customer(\"Анна\", \"+7 900 111-22-33\")\n", " except TypeError:\n", " assert False, \"сначала исправьте создание экземпляра (проверка выше)\"\n", " assert getattr(anna, \"name\", None) == \"Анна\", \"name берётся из первого аргумента\"\n", " assert getattr(anna, \"phone\", None) == \"+7 900 111-22-33\", \"phone берётся из второго аргумента\"\n", " assert hasattr(anna, \"points\"), \"у покупателя нет атрибута points — запишите в __init__ self.points = 0\"\n", " assert anna.points == 0, f\"у нового покупателя points = {anna.points!r}, а нужно 0\"\n", "\n", "_check(test_create, test_attributes, names=[\"Customer.__init__\"])" ], "execution_count": null, "outputs": [], "id": "customer-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "class Customer:\n", " def __init__(self, name, phone):\n", " self.name = name\n", " self.phone = phone\n", " self.points = 0\n", "```\n", "\n", "
" ], "id": "customer-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Много экземпляров\n", "\n", "Экземпляры удобно создавать в цикле: класс вызывается с разными аргументами, а объекты складываются\n", "в список." ], "id": "text-102" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 4. Меню из списка\n", "\n", "В `data` — пары «название, цена». Создайте список `menu` из экземпляров `Drink` (из упражнения про размер)\n", "по этим данным — в том же порядке, размер у всех по умолчанию.\n", "\n", "
Подсказка 1\n", "\n", "Генератор списка: `[Drink(name, price) for name, price in data]`.\n", "\n", "
" ], "id": "menu-task" }, { "cell_type": "code", "metadata": {}, "source": [ "data = [(\"Эспрессо\", 150), (\"Капучино\", 220), (\"Раф\", 260)]\n", "menu = ..." ], "execution_count": null, "outputs": [], "id": "menu" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 4 — выполните после своего решения\n", "def test_menu():\n", " \"menu — список из трёх экземпляров Drink\"\n", " assert isinstance(menu, list), f\"menu — это {type(menu).__name__}, а нужен список\"\n", " assert len(menu) == 3, f\"в menu {len(menu)} элементов, а пар в data три\"\n", " assert all(isinstance(d, Drink) for d in menu), \"в menu должны быть экземпляры Drink, а не пары из data: Drink(name, price)\"\n", "\n", "\n", "def test_values():\n", " \"названия и цены — из data, по порядку\"\n", " assert isinstance(menu, list) and all(isinstance(d, Drink) for d in menu), \"сначала исправьте список (проверка выше)\"\n", " names = [d.name for d in menu]\n", " assert names == [\"Эспрессо\", \"Капучино\", \"Раф\"], f\"названия в menu: {names}\"\n", " assert [d.price for d in menu] == [150, 220, 260], f\"цены в menu: {[d.price for d in menu]}\"\n", " assert len(set(map(id, menu))) == 3, \"в menu один и тот же экземпляр несколько раз — создавайте новый для каждой пары\"\n", "\n", "_check(test_menu, test_values, names=[\"menu\"])" ], "execution_count": null, "outputs": [], "id": "menu-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "data = [(\"Эспрессо\", 150), (\"Капучино\", 220), (\"Раф\", 260)]\n", "menu = [Drink(name, price) for name, price in data]\n", "```\n", "\n", "
" ], "id": "menu-solution" } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "name": "python" }, "colab": { "provenance": [] } }, "nbformat": 4, "nbformat_minor": 5 }