{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Мини-проект: корзина\n", "\n", "Класс Cart хранит товары в списке: добавить, убрать, посчитать сумму, найти самый дорогой. Две независимые корзины и товар, который лежит в обеих.\n", "\n", "Курс ООП в Python · урок `oop-p2-cart` · [урок на сайте](https://ds-edu-trainer.vercel.app/courses/oop/p2-cart).\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", "В проекте пригодится всё из модуля: свой список у каждого экземпляра, ссылки на объекты и `is`.\n", "\n", "## Что у нас уже есть\n", "\n", "Товар — уже знакомый класс с названием и ценой:" ], "id": "text-10" }, { "cell_type": "code", "metadata": {}, "source": [ "# Класс Product\n", "class Product:\n", " def __init__(self, name, price):\n", " self.name = name\n", " self.price = price\n", "\n", "\n", "latte = Product(\"Латте\", 220)\n", "print(latte.name, latte.price)" ], "execution_count": null, "outputs": [], "id": "product" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Шаг 1. Корзина" ], "id": "text-20" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 1. Класс Cart\n", "\n", "Допишите класс `Cart`. У новой корзины — пустой список `items`, свой у каждой корзины. Метод `add(product)`\n", "кладёт товар в корзину, метод `total()` возвращает сумму цен всех товаров (у пустой корзины — 0).\n", "\n", "
Подсказка 1\n", "\n", "`self.items = []` — в `__init__`; `add` — `self.items.append(product)`.\n", "\n", "
\n", "
Подсказка 2\n", "\n", "`total` — сумма `p.price` по всем товарам: циклом или `sum(p.price for p in self.items)`.\n", "\n", "
" ], "id": "cart-task" }, { "cell_type": "code", "metadata": {}, "source": [ "class Cart:\n", " def __init__(self):\n", " ...\n", "\n", " def add(self, product):\n", " ...\n", "\n", " def total(self):\n", " ..." ], "execution_count": null, "outputs": [], "id": "cart" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 1 — выполните после своего решения\n", "def _cart():\n", " try:\n", " return Cart()\n", " except TypeError as e:\n", " assert False, f\"Cart() не создаётся: {e}. У __init__ корзины только параметр self\"\n", "\n", "\n", "def test_empty():\n", " \"новая корзина пустая, сумма 0\"\n", " cart = _cart()\n", " assert hasattr(cart, \"items\"), \"у корзины нет атрибута items — создайте в __init__ self.items = []\"\n", " assert cart.items == [], f\"в новой корзине items = {cart.items}, а нужен пустой список\"\n", " assert cart.total() == 0, f\"у пустой корзины total() = {cart.total()!r}, а нужно 0\"\n", "\n", "\n", "def test_add_total():\n", " \"add кладёт товары, total считает сумму\"\n", " cart = _cart()\n", " assert hasattr(cart, \"items\"), \"сначала создайте items в __init__\"\n", " tea, raf = Product(\"Чай\", 120), Product(\"Раф\", 260)\n", " cart.add(tea)\n", " cart.add(raf)\n", " assert len(cart.items) == 2 and cart.items[0] is tea, \"add должен класть в items сам товар\"\n", " got = cart.total()\n", " assert got is not None, \"total() ничего не возвращает — нужен return\"\n", " assert got == 380, f\"total() = {got!r}, а чай и раф стоят 380\"\n", "\n", "\n", "def test_independent():\n", " \"у двух корзин — свои списки\"\n", " a, b = _cart(), _cart()\n", " assert hasattr(a, \"items\"), \"сначала создайте items в __init__\"\n", " a.add(Product(\"Чай\", 120))\n", " assert b.items == [], \"товар из одной корзины появился в другой — список должен создаваться в __init__, а не в теле класса\"\n", "\n", "_check(test_empty, test_add_total, test_independent, names=[\"Cart.__init__\",\"Cart.add\",\"Cart.total\"])" ], "execution_count": null, "outputs": [], "id": "cart-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "class Cart:\n", " def __init__(self):\n", " self.items = []\n", "\n", " def add(self, product):\n", " self.items.append(product)\n", "\n", " def total(self):\n", " return sum(p.price for p in self.items)\n", "```\n", "\n", "
" ], "id": "cart-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Шаг 2. Убрать и найти" ], "id": "text-30" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 2. remove и most_expensive\n", "\n", "Добавьте в класс два метода — скопируйте класс из шага 1 целиком и допишите их:\n", "\n", "- `remove(name)` убирает из корзины **первый** товар с таким названием и возвращает `True`; если такого\n", " товара нет — ничего не меняет и возвращает `False`;\n", "- `most_expensive()` возвращает самый дорогой товар корзины (сам объект), а у пустой корзины — `None`.\n", "\n", "
Подсказка 1\n", "\n", "В `remove`: цикл по `self.items`; нашли товар — `self.items.remove(p)` и сразу `return True`. После цикла — `return False`.\n", "\n", "
\n", "
Подсказка 2\n", "\n", "В `most_expensive`: если список пуст — `return None`; иначе запомните первый товар и сравнивайте с ним остальные по цене.\n", "\n", "
" ], "id": "more-task" }, { "cell_type": "code", "metadata": {}, "source": [ "class Cart:\n", " # скопируйте сюда __init__, add и total из шага 1\n", "\n", " def remove(self, name):\n", " ...\n", "\n", " def most_expensive(self):\n", " ..." ], "execution_count": null, "outputs": [], "id": "more" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 2 — выполните после своего решения\n", "def _filled():\n", " \"корзина: чай, раф, чай\"\n", " try:\n", " cart = Cart()\n", " except TypeError:\n", " assert False, \"Cart() не создаётся — скопируйте в класс __init__ из шага 1\"\n", " for method in [\"add\", \"total\"]:\n", " assert hasattr(cart, method), f\"в классе нет метода {method} — скопируйте класс из шага 1 целиком\"\n", " assert getattr(cart, \"items\", None) == [], \"у новой корзины должен быть пустой список items — в скопированном классе ошибка из шага 1\"\n", " tea1, raf, tea2 = Product(\"Чай\", 120), Product(\"Раф\", 260), Product(\"Чай\", 120)\n", " for p in [tea1, raf, tea2]:\n", " cart.add(p)\n", " assert len(cart.items) == 3 and cart.total() == 500, \"add и total работают не так, как в шаге 1 — в скопированном классе ошибка из шага 1\"\n", " return cart, tea1, raf, tea2\n", "\n", "\n", "def test_remove():\n", " \"remove убирает первый товар с этим названием\"\n", " cart, tea1, raf, tea2 = _filled()\n", " got = cart.remove(\"Чай\")\n", " assert got is True, f\"remove(\\\"Чай\\\") вернул {got!r}, а товар был в корзине — нужно True\"\n", " assert len(cart.items) == 2, f\"после remove(\\\"Чай\\\") в корзине {len(cart.items)} товаров, а должно остаться 2 — уберите только первый чай\"\n", " assert cart.items[0] is raf and cart.items[1] is tea2, \"убрать нужно первый чай, остальные товары — на своих местах\"\n", "\n", "\n", "def test_remove_missing():\n", " \"нет товара — False, корзина не меняется\"\n", " cart, *_ = _filled()\n", " got = cart.remove(\"Какао\")\n", " assert got is False, f\"remove(\\\"Какао\\\") вернул {got!r}, а какао в корзине нет — нужно False\"\n", " assert len(cart.items) == 3, \"remove несуществующего товара изменил корзину\"\n", "\n", "\n", "def test_most_expensive():\n", " \"most_expensive — сам самый дорогой товар\"\n", " cart, tea1, raf, tea2 = _filled()\n", " got = cart.most_expensive()\n", " assert not isinstance(got, (int, float)), f\"most_expensive() вернул число {got!r}, а нужен сам товар\"\n", " assert got is raf, \"most_expensive() вернул не тот товар: самый дорогой — раф\"\n", " assert Cart().most_expensive() is None, \"у пустой корзины most_expensive() должен вернуть None\"\n", "\n", "_check(test_remove, test_remove_missing, test_most_expensive, names=[\"Cart.remove\",\"Cart.most_expensive\"])" ], "execution_count": null, "outputs": [], "id": "more-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "class Cart:\n", " def __init__(self):\n", " self.items = []\n", "\n", " def add(self, product):\n", " self.items.append(product)\n", "\n", " def total(self):\n", " return sum(p.price for p in self.items)\n", "\n", " def remove(self, name):\n", " for p in self.items:\n", " if p.name == name:\n", " self.items.remove(p)\n", " return True\n", " return False\n", "\n", " def most_expensive(self):\n", " if not self.items:\n", " return None\n", " best = self.items[0]\n", " for p in self.items:\n", " if p.price > best.price:\n", " best = p\n", " return best\n", "```\n", "\n", "
" ], "id": "more-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Шаг 3. Две корзины" ], "id": "text-43" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 3. Анна и Борис\n", "\n", "Создайте две корзины: `anna` — с латте и круассаном, `boris` — с чаем и латте. Латте — **один и тот же**\n", "товар `latte` из заготовки: в меню он один. Сохраните суммы корзин в `anna_total` и `boris_total`.\n", "\n", "
Подсказка 1\n", "\n", "`anna = Cart()`, затем `anna.add(latte)` и `anna.add(croissant)`; так же для `boris`.\n", "\n", "
" ], "id": "two-carts-task" }, { "cell_type": "code", "metadata": {}, "source": [ "latte = Product(\"Латте\", 220)\n", "croissant = Product(\"Круассан\", 140)\n", "tea = Product(\"Чай\", 120)\n", "\n", "anna = ...\n", "boris = ...\n", "anna_total = ...\n", "boris_total = ..." ], "execution_count": null, "outputs": [], "id": "two-carts" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 3 — выполните после своего решения\n", "def test_carts():\n", " \"anna и boris — две разные корзины\"\n", " assert isinstance(anna, Cart) and isinstance(boris, Cart), \"anna и boris должны быть экземплярами Cart: anna = Cart()\"\n", " assert anna is not boris, \"anna и boris — одна и та же корзина; создайте две: два раза Cart()\"\n", "\n", "\n", "def test_contents():\n", " \"товары в корзинах — те самые объекты\"\n", " assert isinstance(anna, Cart) and isinstance(boris, Cart), \"сначала создайте корзины\"\n", " assert [p.name for p in anna.items] == [\"Латте\", \"Круассан\"], f\"в корзине Анны {[p.name for p in anna.items]}\"\n", " assert [p.name for p in boris.items] == [\"Чай\", \"Латте\"], f\"в корзине Бориса {[p.name for p in boris.items]}\"\n", " assert anna.items[0] is latte and boris.items[1] is latte, \"в обеих корзинах должен лежать один и тот же товар latte — не создавайте новый Product(\\\"Латте\\\", …)\"\n", "\n", "\n", "def test_totals():\n", " \"anna_total и boris_total\"\n", " assert anna_total == 360, f\"anna_total = {anna_total!r}, а латте и круассан стоят 360\"\n", " assert boris_total == 340, f\"boris_total = {boris_total!r}, а чай и латте стоят 340\"\n", "\n", "_check(test_carts, test_contents, test_totals, names=[\"anna\",\"boris\",\"anna_total\",\"boris_total\"])" ], "execution_count": null, "outputs": [], "id": "two-carts-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "latte = Product(\"Латте\", 220)\n", "croissant = Product(\"Круассан\", 140)\n", "tea = Product(\"Чай\", 120)\n", "\n", "anna = Cart()\n", "anna.add(latte)\n", "anna.add(croissant)\n", "boris = Cart()\n", "boris.add(tea)\n", "boris.add(latte)\n", "anna_total = anna.total()\n", "boris_total = boris.total()\n", "```\n", "\n", "
" ], "id": "two-carts-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Шаг 4. Цена изменилась\n", "\n", "Пока покупатели стоят в очереди, кофейня поднимает цену латте до 250 ₽." ], "id": "text-52" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 4. Новая цена латте\n", "\n", "Измените цену товара `latte` на 250 и сохраните новые суммы корзин в `anna_new` и `boris_new`. Товары\n", "в корзины заново не добавляйте.\n", "\n", "
Подсказка 1\n", "\n", "Достаточно `latte.price = 250`: в обеих корзинах лежит этот же объект.\n", "\n", "
" ], "id": "new-price-task" }, { "cell_type": "code", "metadata": {}, "source": [ "anna_new = ...\n", "boris_new = ..." ], "execution_count": null, "outputs": [], "id": "new-price" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 4 — выполните после своего решения\n", "def test_price():\n", " \"цена latte — 250\"\n", " assert latte.price == 250, f\"latte.price = {latte.price!r}, а нужно 250\"\n", " assert anna.items and anna.items[0] is latte, \"в latte теперь не тот товар, что лежит в корзинах: похоже, latte присвоили новый объект. Нажмите «Выполнить все выше» и меняйте цену у существующего товара\"\n", "\n", "\n", "def test_totals():\n", " \"суммы обеих корзин выросли\"\n", " assert anna_new == 390, f\"anna_new = {anna_new!r}, а после подорожания латте корзина Анны стоит 390\"\n", " assert boris_new == 370, f\"boris_new = {boris_new!r}, а корзина Бориса стоит 370\"\n", " assert anna.total() == 390, \"в корзине Анны должна быть новая цена — меняйте цену у самого latte, а не создавайте новый товар\"\n", "\n", "_check(test_price, test_totals, names=[\"anna_new\",\"boris_new\"])" ], "execution_count": null, "outputs": [], "id": "new-price-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "latte.price = 250\n", "anna_new = anna.total()\n", "boris_new = boris.total()\n", "```\n", "\n", "
" ], "id": "new-price-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Шаг 5. Борис передумал" ], "id": "text-63" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 5. Чай на раф\n", "\n", "Борис передумал: уберите из его корзины чай и добавьте раф `raf`. Результат `remove` для чая сохраните\n", "в `removed`, а в `missing` — результат попытки убрать какао, которого в корзине нет. Самый дорогой товар\n", "корзины Бориса после замены сохраните в `boris_top`.\n", "\n", "
Подсказка 1\n", "\n", "`removed = boris.remove(\"Чай\")`, `missing = boris.remove(\"Какао\")`, затем `boris.add(raf)` и `boris_top = boris.most_expensive()`.\n", "\n", "
" ], "id": "swap-task" }, { "cell_type": "code", "metadata": {}, "source": [ "raf = Product(\"Раф\", 260)\n", "removed = ...\n", "missing = ...\n", "boris_top = ..." ], "execution_count": null, "outputs": [], "id": "swap" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 5 — выполните после своего решения\n", "def test_results():\n", " \"removed — True, missing — False\"\n", " names = [p.name for p in boris.items]\n", " if removed is False and \"Чай\" not in names:\n", " assert False, \"removed = False, а чая в корзине уже нет: похоже, его убрал прошлый запуск ячейки. Нажмите «Выполнить все выше» и выполните ячейку один раз\"\n", " assert removed is True, f\"removed = {removed!r}: чай в корзине был, remove должен вернуть True\"\n", " assert missing is False, f\"missing = {missing!r}: какао в корзине нет, remove должен вернуть False\"\n", "\n", "\n", "def test_contents():\n", " \"в корзине Бориса латте и раф\"\n", " names = [p.name for p in boris.items]\n", " assert \"Чай\" not in names, \"чай всё ещё в корзине Бориса — уберите его: boris.remove(\\\"Чай\\\")\"\n", " assert names == [\"Латте\", \"Раф\"], f\"в корзине Бориса {names}, а нужно латте и раф\"\n", "\n", "\n", "def test_top():\n", " \"boris_top — раф\"\n", " assert not isinstance(boris_top, (int, float, str)), f\"boris_top = {boris_top!r}, а нужен сам товар\"\n", " assert boris_top is raf, \"самый дорогой в корзине Бориса — раф: boris.most_expensive() после добавления\"\n", "\n", "_check(test_results, test_contents, test_top, names=[\"removed\",\"missing\",\"boris_top\"])" ], "execution_count": null, "outputs": [], "id": "swap-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "raf = Product(\"Раф\", 260)\n", "removed = boris.remove(\"Чай\")\n", "missing = boris.remove(\"Какао\")\n", "boris.add(raf)\n", "boris_top = boris.most_expensive()\n", "```\n", "\n", "
" ], "id": "swap-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Итог" ], "id": "text-73" }, { "cell_type": "code", "metadata": {}, "source": [ "# Корзины на кассе\n", "for name, cart in [(\"Анна\", anna), (\"Борис\", boris)]:\n", " names = \", \".join(p.name for p in cart.items)\n", " print(f\"{name}: {names} — {cart.total()} ₽\")\n", "print(\"латте в обеих корзинах — один объект:\", anna.items[0] is boris.items[0])" ], "execution_count": null, "outputs": [], "id": "summary" }, { "cell_type": "markdown", "metadata": {}, "source": [ "*После решения всех упражнений урока:*\n", "\n", "Цена латте поменялась один раз — и сразу в обеих корзинах: корзины хранят не копии товаров, а ссылки на один\n", "объект `latte`. В кассе это удобно (новая цена видна везде), но значит и обратное: изменить товар «только для\n", "одной корзины» нельзя — для этого нужен отдельный объект." ], "id": "component-78" }, { "cell_type": "markdown", "metadata": {}, "source": [ "Корзина — первый пример **композиции** (composition): объект хранит другие объекты и работает с ними через их атрибуты\n", "и методы. Подробно о композиции — в модуле 6. А в следующем модуле научимся защищать состояние объекта:\n", "чтобы цену нельзя было случайно сделать отрицательной." ], "id": "text-83" } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "name": "python" }, "colab": { "provenance": [] } }, "nbformat": 4, "nbformat_minor": 5 }