{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Мини-проект: склад\n",
"\n",
"Класс Stock ведёт остатки «Кофейной лавки» как встроенный контейнер: len, in, цикл по позициям, stock[\"Молоко\"] и сложение поставок плюсом.\n",
"\n",
"Курс ООП в Python · урок `oop-p7-stock` · [урок на сайте](https://ds-edu-trainer.vercel.app/courses/oop/p7-stock).\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",
"расходует запасы, вечером управляющий смотрит, чего осталось мало. Сделаем класс `Stock`, с которым\n",
"всё это пишется так же коротко, как со словарём: `len(stock)`, `\"Сироп\" in stock`, `stock[\"Молоко\"]`,\n",
"`for name in stock`, а поставка добавляется оператором `+`.\n",
"\n",
"## Шаг 1. Склад-контейнер"
],
"id": "text-10"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Упражнение 1. Класс Stock\n",
"\n",
"Допишите класс `Stock`. `Stock({\"Зёрна\": 8, \"Молоко\": 12})` хранит **копию** словаря «позиция → количество»\n",
"во внутреннем атрибуте `_items`.\n",
"\n",
"- `len(stock)` — число позиций, у которых количество больше нуля;\n",
"- `stock[\"Молоко\"]` — количество позиции; если позиции нет — 0 (склад не ругается, а говорит «ноль»);\n",
"- `\"Молоко\" in stock` — `True`, если позиция есть и её количество больше нуля;\n",
"- `for name in stock` — названия позиций с количеством больше нуля, по алфавиту.\n",
"\n",
"Подсказка 1
\n",
"\n",
"Копию словаря даёт `dict(items)`; количество отсутствующей позиции — метод словаря со значением по умолчанию.\n",
"\n",
"Подсказка 2
\n",
"\n",
"`__iter__` — генератор по `sorted(self._items)` с условием на количество.\n",
"\n",
"Решение
\n",
"\n",
"```python\n",
"class Stock:\n",
" def __init__(self, items):\n",
" self._items = dict(items)\n",
"\n",
" def __len__(self):\n",
" return len([name for name in self._items if self._items[name] > 0])\n",
"\n",
" def __getitem__(self, name):\n",
" return self._items.get(name, 0)\n",
"\n",
" def __contains__(self, name):\n",
" return self[name] > 0\n",
"\n",
" def __iter__(self):\n",
" for name in sorted(self._items):\n",
" if self._items[name] > 0:\n",
" yield name\n",
"```\n",
"\n",
"Подсказка 1
\n",
"\n",
"В `__add__`: начните с `dict(self._items)` и прибавьте к нему количества из `other._items` через `get(name, 0)`.\n",
"\n",
"Решение
\n",
"\n",
"```python\n",
"class Stock:\n",
" def __init__(self, items):\n",
" self._items = dict(items)\n",
"\n",
" def __len__(self):\n",
" return len([name for name in self._items if self._items[name] > 0])\n",
"\n",
" def __getitem__(self, name):\n",
" return self._items.get(name, 0)\n",
"\n",
" def __contains__(self, name):\n",
" return self[name] > 0\n",
"\n",
" def __iter__(self):\n",
" for name in sorted(self._items):\n",
" if self._items[name] > 0:\n",
" yield name\n",
"\n",
" def __add__(self, other):\n",
" if not isinstance(other, Stock):\n",
" return NotImplemented\n",
" result = dict(self._items)\n",
" for name, amount in other._items.items():\n",
" result[name] = result.get(name, 0) + amount\n",
" return Stock(result)\n",
"\n",
" def take(self, name, amount):\n",
" if self[name] < amount:\n",
" raise ValueError(f\"на складе мало: {name}\")\n",
" self._items[name] -= amount\n",
"```\n",
"\n",
"Подсказка 1
\n",
"\n",
"Склад после поставки — ровно то, ради чего писали `__add__`; число позиций и молоко — встроенные операции склада.\n",
"\n",
"Решение
\n",
"\n",
"```python\n",
"leftover = Stock({\"Зёрна\": 3, \"Молоко\": 2, \"Сироп\": 1, \"Стаканы\": 40, \"Сливки\": 0})\n",
"delivery = Stock({\"Зёрна\": 5, \"Молоко\": 10, \"Сироп\": 2, \"Стаканы\": 100})\n",
"stock = leftover + delivery\n",
"n_positions = len(stock)\n",
"milk = stock[\"Молоко\"]\n",
"```\n",
"\n",
"Подсказка 1
\n",
"\n",
"Цикл по парам `(name, amount)` и `try: stock.take(name, amount)`, `except ValueError: short.append(name)`.\n",
"\n",
"Решение
\n",
"\n",
"```python\n",
"stock = Stock({\"Зёрна\": 8, \"Молоко\": 12, \"Сироп\": 3, \"Стаканы\": 140, \"Сливки\": 0}) # склад утром, после поставки\n",
"usage = [\n",
" (\"Молоко\", 5), (\"Стаканы\", 60), (\"Сироп\", 2), (\"Зёрна\", 3),\n",
" (\"Стаканы\", 78), (\"Сироп\", 2), (\"Молоко\", 4), (\"Сироп\", 1),\n",
"]\n",
"short = []\n",
"for name, amount in usage:\n",
" try:\n",
" stock.take(name, amount)\n",
" except ValueError:\n",
" short.append(name)\n",
"```\n",
"\n",
"Подсказка 1
\n",
"\n",
"Цикл по складу выдаёт названия, а количество даёт `stock[name]`.\n",
"\n",
"Подсказка 2
\n",
"\n",
"«Сиропа не осталось» — `\"Сироп\" not in stock`.\n",
"\n",
"Решение
\n",
"\n",
"```python\n",
"low = [name for name in stock if stock[name] < 5]\n",
"out_of_syrup = \"Сироп\" not in stock\n",
"```\n",
"\n",
"