{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Мини-проект: прайс-лист\n", "\n", "Два прайса поставщика сводятся в один: товары с __repr__, __eq__ и __hash__, дубли убирает set, сортировка по цене и по названию, товары, у которых изменилась цена.\n", "\n", "Курс ООП в Python · урок `oop-p4-price-list` · [урок на сайте](https://ds-edu-trainer.vercel.app/courses/oop/p4-price-list).\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", "товары с новой ценой. Всё это делается магическими методами модуля: `__repr__`, `__eq__`, `__hash__` и `__lt__`.\n", "\n", "## Шаг 1. Товар" ], "id": "text-10" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 1. Товар для прайса\n", "\n", "Допишите класс `Product`:\n", "\n", "- `__repr__` возвращает `Product('Латте', 220)`;\n", "- товары равны, если совпадают и название, и цена; сравнение с чужим типом — `NotImplemented`;\n", "- `__hash__` согласован с `__eq__`, чтобы товары можно было класть в `set`.\n", "\n", "
Подсказка 1\n", "\n", "Хеш из тех же атрибутов, что сравнивает `__eq__`: `hash((self.name, self.price))`.\n", "\n", "
" ], "id": "product-task" }, { "cell_type": "code", "metadata": {}, "source": [ "class Product:\n", " def __init__(self, name, price):\n", " self.name = name\n", " self.price = price\n", "\n", " def __repr__(self):\n", " ...\n", "\n", " def __eq__(self, other):\n", " ...\n", "\n", " def __hash__(self):\n", " ..." ], "execution_count": null, "outputs": [], "id": "product" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 1 — выполните после своего решения\n", "def test_repr():\n", " \"repr — Product('Латте', 220)\"\n", " assert \"__repr__\" in Product.__dict__, \"в классе нет __repr__\"\n", " got = Product.__dict__[\"__repr__\"](Product(\"Латте\", 220))\n", " assert got == \"Product('Латте', 220)\", f\"repr товара = {got!r}, а нужно \\\"Product('Латте', 220)\\\" — название с !r\"\n", "\n", "\n", "def test_eq():\n", " \"равны по названию и цене\"\n", " assert \"__eq__\" in Product.__dict__, \"в классе нет __eq__\"\n", " assert Product(\"Латте\", 220) == Product(\"Латте\", 220), \"товары с одинаковыми названием и ценой должны быть равны\"\n", " assert Product(\"Латте\", 220) != Product(\"Латте\", 240), \"у товаров разные цены — они не равны\"\n", " assert Product(\"Латте\", 220) != Product(\"Раф\", 220), \"у товаров разные названия — они не равны\"\n", " try:\n", " got = Product.__dict__[\"__eq__\"](Product(\"Латте\", 220), \"Латте\")\n", " except AttributeError:\n", " assert False, \"сравнение со строкой падает — сначала проверьте тип: isinstance(other, Product)\"\n", " assert got is NotImplemented, f\"для чужого типа __eq__ вернул {got!r}, а нужно NotImplemented\"\n", "\n", "\n", "def test_hash():\n", " \"равные товары — один элемент set\"\n", " try:\n", " group = {Product(\"Латте\", 220), Product(\"Латте\", 220), Product(\"Латте\", 240)}\n", " except TypeError:\n", " assert False, \"товар нельзя положить в set — объявите __hash__\"\n", " assert len(group) == 2, f\"в set из двух одинаковых латте и одного другого {len(group)} элементов, а нужно 2 — хеш из названия и цены\"\n", "\n", "_check(test_repr, test_eq, test_hash, names=[\"Product.__repr__\",\"Product.__eq__\",\"Product.__hash__\"])" ], "execution_count": null, "outputs": [], "id": "product-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\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\"Product({self.name!r}, {self.price})\"\n", "\n", " def __eq__(self, other):\n", " if not isinstance(other, Product):\n", " return NotImplemented\n", " return self.name == other.name and self.price == other.price\n", "\n", " def __hash__(self):\n", " return hash((self.name, self.price))\n", "```\n", "\n", "
" ], "id": "product-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Шаг 2. Порядок в прайсе\n", "\n", "В уроке о сортировке был совет: если у товаров несколько равноправных порядков, `__lt__` не объявляют, а\n", "передают `key=`. Здесь случай другой: прайс поставщика по договорённости всегда идёт от дешёвого к дорогому,\n", "и этот порядок — естественный для прайса. Поэтому зададим его в классе." ], "id": "text-26" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 2. Сначала дешёвые\n", "\n", "Добавьте в класс (скопируйте его из шага 1 целиком) метод `__lt__`: товар «меньше», если он дешевле, а при\n", "равной цене — если его название раньше по алфавиту. Сравнение с чужим типом — `NotImplemented`.\n", "\n", "
Подсказка 1\n", "\n", "Кортежи сравниваются по порядку: `(self.price, self.name) < (other.price, other.name)`.\n", "\n", "
" ], "id": "order-task" }, { "cell_type": "code", "metadata": {}, "source": [ "class Product:\n", " # скопируйте сюда __init__, __repr__, __eq__ и __hash__ из шага 1\n", "\n", " def __lt__(self, other):\n", " ..." ], "execution_count": null, "outputs": [], "id": "order" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 2 — выполните после своего решения\n", "def test_copied():\n", " \"методы шага 1 скопированы и работают\"\n", " for name in [\"__init__\", \"__repr__\", \"__eq__\", \"__hash__\"]:\n", " assert name in Product.__dict__ and Product.__dict__[name] is not None, f\"в классе нет {name} — скопируйте класс из шага 1 целиком\"\n", " step1 = \"в скопированном классе ошибка из шага 1\"\n", " try:\n", " repr(Product(\"Латте\", 220))\n", " hash(Product(\"Латте\", 220))\n", " except TypeError:\n", " assert False, f\"__repr__ или __hash__ не дописан — {step1}\"\n", " assert repr(Product(\"Латте\", 220)) == \"Product('Латте', 220)\", f\"repr товара {Product('Латте', 220)!r} — {step1}\"\n", " assert Product(\"Латте\", 220) == Product(\"Латте\", 220) and Product(\"Латте\", 220) != Product(\"Латте\", 240), f\"равенство работает неверно — {step1}\"\n", " assert len({Product(\"Латте\", 220), Product(\"Латте\", 220), Product(\"Чай\", 120)}) == 2, f\"set не убирает одинаковые товары — {step1}\"\n", "\n", "\n", "def test_lt():\n", " \"дешевле — меньше; при равной цене — по названию\"\n", " assert \"__lt__\" in Product.__dict__, \"в классе нет __lt__\"\n", " try:\n", " tea, raf = Product(\"Чай\", 120), Product(\"Раф\", 260)\n", " except TypeError:\n", " assert False, \"Product(\\\"Чай\\\", 120) не создаётся — скопируйте __init__ из шага 1\"\n", " assert tea < raf and not raf < tea, \"чай за 120 ₽ должен быть меньше рафа за 260 ₽\"\n", " assert Product(\"Капучино\", 220) < Product(\"Латте\", 220), \"при равной цене меньше тот, чьё название раньше по алфавиту\"\n", " assert not Product(\"Латте\", 220) < Product(\"Латте\", 220), \"товар не меньше равного ему — сравнение строгое\"\n", " try:\n", " got = Product.__dict__[\"__lt__\"](tea, 100)\n", " except AttributeError:\n", " assert False, \"сравнение с числом падает — сначала проверьте тип: isinstance(other, Product)\"\n", " assert got is NotImplemented, f\"для чужого типа __lt__ вернул {got!r}, а нужно NotImplemented\"\n", "\n", "_check(test_copied, test_lt, names=[\"Product.__lt__\"])" ], "execution_count": null, "outputs": [], "id": "order-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\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\"Product({self.name!r}, {self.price})\"\n", "\n", " def __eq__(self, other):\n", " if not isinstance(other, Product):\n", " return NotImplemented\n", " return self.name == other.name and self.price == other.price\n", "\n", " def __hash__(self):\n", " return hash((self.name, self.price))\n", "\n", " def __lt__(self, other):\n", " if not isinstance(other, Product):\n", " return NotImplemented\n", " return (self.price, self.name) < (other.price, other.name)\n", "```\n", "\n", "
" ], "id": "order-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Шаг 3. Два прайса в один" ], "id": "text-39" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 3. Без повторов\n", "\n", "По спискам пар `morning` и `evening` создайте товары и сохраните в `all_items` общий список — сначала утренние,\n", "потом вечерние. В `unique` сохраните множество (`set`) товаров без повторов, а в `n_dupes` — сколько позиций\n", "оказались повторами.\n", "\n", "
Подсказка 1\n", "\n", "`[Product(n, p) for n, p in morning + evening]` — оба списка подряд.\n", "\n", "
\n", "
Подсказка 2\n", "\n", "Повторов столько, на сколько `all_items` длиннее `unique`.\n", "\n", "
" ], "id": "merge-task" }, { "cell_type": "code", "metadata": {}, "source": [ "morning = [(\"Латте\", 220), (\"Чай\", 120), (\"Раф\", 260), (\"Какао\", 190), (\"Эспрессо\", 150)]\n", "evening = [(\"Чай\", 120), (\"Латте\", 240), (\"Эспрессо\", 150), (\"Капучино\", 220), (\"Раф\", 260)]\n", "all_items = ...\n", "unique = ...\n", "n_dupes = ..." ], "execution_count": null, "outputs": [], "id": "merge" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 3 — выполните после своего решения\n", "def test_all():\n", " \"all_items — десять товаров по порядку\"\n", " assert isinstance(all_items, list), f\"all_items — это {type(all_items).__name__}, а нужен список\"\n", " assert len(all_items) == 10, f\"в all_items {len(all_items)} товаров, а в двух прайсах 10 позиций\"\n", " assert all(isinstance(p, Product) for p in all_items), \"в all_items должны быть товары Product — создайте их заново после ячейки с классом\"\n", " assert all_items[0] == Product(\"Латте\", 220) and all_items[5] == Product(\"Чай\", 120), \"сначала утренний прайс, потом вечерний\"\n", "\n", "\n", "def test_unique():\n", " \"unique — set без повторов, n_dupes — сколько повторов\"\n", " assert isinstance(unique, set), f\"unique — это {type(unique).__name__}, а нужно множество: set(all_items)\"\n", " assert len(unique) == 7, f\"в unique {len(unique)} товаров, а разных — 7 (латте за 220 и за 240 — разные товары)\"\n", " assert n_dupes == 3, f\"n_dupes = {n_dupes!r}, а повторов 3: чай, эспрессо и раф\"\n", "\n", "_check(test_all, test_unique, names=[\"all_items\",\"unique\",\"n_dupes\"])" ], "execution_count": null, "outputs": [], "id": "merge-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "morning = [(\"Латте\", 220), (\"Чай\", 120), (\"Раф\", 260), (\"Какао\", 190), (\"Эспрессо\", 150)]\n", "evening = [(\"Чай\", 120), (\"Латте\", 240), (\"Эспрессо\", 150), (\"Капучино\", 220), (\"Раф\", 260)]\n", "all_items = [Product(name, price) for name, price in morning + evening]\n", "unique = set(all_items)\n", "n_dupes = len(all_items) - len(unique)\n", "```\n", "\n", "
" ], "id": "merge-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Шаг 4. Прайс по цене" ], "id": "text-50" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 4. Сортировка\n", "\n", "Сохраните в `price_list` список товаров из `unique`, отсортированный по естественному порядку товаров\n", "(шаг 2), а в `cheapest3` — названия трёх самых дешёвых.\n", "\n", "
Подсказка 1\n", "\n", "`sorted(unique)` — `set` сортируется так же, как список, результат — список.\n", "\n", "
" ], "id": "price-list-task" }, { "cell_type": "code", "metadata": {}, "source": [ "price_list = ...\n", "cheapest3 = ..." ], "execution_count": null, "outputs": [], "id": "price-list" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 4 — выполните после своего решения\n", "def test_price_list():\n", " \"price_list — по цене, при равной — по названию\"\n", " assert isinstance(price_list, list), f\"price_list — это {type(price_list).__name__}, а нужен список: sorted(unique)\"\n", " assert len(price_list) == 7, f\"в price_list {len(price_list)} товаров, а в unique 7\"\n", " got = [(p.name, p.price) for p in price_list]\n", " assert got == [(\"Чай\", 120), (\"Эспрессо\", 150), (\"Какао\", 190), (\"Капучино\", 220), (\"Латте\", 220), (\"Латте\", 240), (\"Раф\", 260)], f\"порядок price_list: {got}\"\n", "\n", "\n", "def test_cheapest():\n", " \"cheapest3 — три самых дешёвых\"\n", " assert cheapest3 == [\"Чай\", \"Эспрессо\", \"Какао\"], f\"cheapest3 = {cheapest3}, а самые дешёвые — чай, эспрессо и какао\"\n", "\n", "_check(test_price_list, test_cheapest, names=[\"price_list\",\"cheapest3\"])" ], "execution_count": null, "outputs": [], "id": "price-list-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "price_list = sorted(unique)\n", "cheapest3 = [p.name for p in price_list[:3]]\n", "```\n", "\n", "
" ], "id": "price-list-solution" }, { "cell_type": "code", "metadata": {}, "source": [ "# Сводный прайс\n", "for p in price_list:\n", " print(p)" ], "execution_count": null, "outputs": [], "id": "look" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Шаг 5. Что подорожало\n", "\n", "Один и тот же товар с разными ценами — это два **разных** товара для `__eq__`: в `unique` остались оба." ], "id": "text-61" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 5. Товары с новой ценой\n", "\n", "Сохраните в `alphabet` названия всех товаров `unique` по алфавиту (повторяющиеся названия — подряд), а в\n", "`changed` — список названий, которые встречаются в `unique` больше одного раза, то есть товаров, у которых\n", "за день изменилась цена. Каждое название — один раз, по алфавиту.\n", "\n", "
Подсказка 1\n", "\n", "`alphabet = sorted(p.name for p in unique)` — порядок по названию задаётся снаружи, `__lt__` для этого не нужен.\n", "\n", "
\n", "
Подсказка 2\n", "\n", "Посчитайте названия словарём-счётчиком и возьмите те, у которых счётчик больше 1.\n", "\n", "
" ], "id": "changed-task" }, { "cell_type": "code", "metadata": {}, "source": [ "alphabet = ...\n", "changed = ..." ], "execution_count": null, "outputs": [], "id": "changed" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 5 — выполните после своего решения\n", "def test_alphabet():\n", " \"alphabet — все названия по алфавиту\"\n", " assert isinstance(alphabet, list), f\"alphabet — это {type(alphabet).__name__}, а нужен список названий\"\n", " assert alphabet == [\"Какао\", \"Капучино\", \"Латте\", \"Латте\", \"Раф\", \"Чай\", \"Эспрессо\"], f\"alphabet = {alphabet}\"\n", "\n", "\n", "def test_changed():\n", " \"changed — товары с новой ценой\"\n", " assert isinstance(changed, list), f\"changed — это {type(changed).__name__}, а нужен список названий\"\n", " assert changed != [\"Латте\", \"Латте\"], \"латте попал в changed дважды — каждое название нужно один раз\"\n", " assert changed == [\"Латте\"], f\"changed = {changed}, а цена изменилась только у латте\"\n", "\n", "_check(test_alphabet, test_changed, names=[\"alphabet\",\"changed\"])" ], "execution_count": null, "outputs": [], "id": "changed-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "alphabet = sorted(p.name for p in unique)\n", "counts = {}\n", "for name in alphabet:\n", " counts[name] = counts.get(name, 0) + 1\n", "changed = [name for name, n in counts.items() if n > 1]\n", "```\n", "\n", "
" ], "id": "changed-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Итог" ], "id": "text-74" }, { "cell_type": "code", "metadata": {}, "source": [ "# Отчёт по прайсам\n", "print(f\"позиций в двух прайсах: {len(all_items)}, повторов: {n_dupes}\")\n", "print(\"сводный прайс:\", price_list)\n", "for name in changed:\n", " prices = sorted(p.price for p in unique if p.name == name)\n", " print(f\"изменилась цена: {name}, цены в прайсах {prices}\")" ], "execution_count": null, "outputs": [], "id": "summary" }, { "cell_type": "markdown", "metadata": {}, "source": [ "*После решения всех упражнений урока:*\n", "\n", "Из десяти позиций двух прайсов три оказались повторами, в сводном прайсе семь товаров. Цена за день\n", "изменилась только у латте: утром 220 ₽, вечером 240 ₽. Заметьте, как удобно смотреть на такие списки, когда\n", "у товара есть `__repr__`: `print(price_list)` сразу показывает и названия, и цены." ], "id": "component-79" }, { "cell_type": "markdown", "metadata": {}, "source": [ "В проекте два порядка: естественный порядок прайса (по цене) задан в классе, а порядок по алфавиту — снаружи,\n", "ключом. Если бы ни один порядок не был главным, честнее было бы обойтись одним `key=`, как советует урок\n", "о сортировке. В следующем модуле появятся иерархии\n", "классов: разные виды скидок, которые касса применяет одинаково." ], "id": "text-84" } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "name": "python" }, "colab": { "provenance": [] } }, "nbformat": 4, "nbformat_minor": 5 }