{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Мини-проект: калькулятор цен\n",
    "\n",
    "Собрать прайс-лист «товар × количество» из себестоимости, наценок по товарам и скидок за объём — таблица всех пар, строки и столбцы в одном выражении.\n",
    "\n",
    "Курс NumPy · урок `np-project-prices` · [урок на сайте](https://ds-edu-trainer.vercel.app/courses/numpy/project-prices).\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",
    "for _name, _min in {\"numpy\":\"2.0\"}.items():\n",
    "    try:\n",
    "        _have = __import__(_name).__version__\n",
    "    except ImportError:\n",
    "        print(f\"Нет пакета {_name}: выполните %pip install {_name} и перезапустите ядро\")\n",
    "        continue\n",
    "    if tuple(int(x) for x in _have.split(\".\")[:2]) < tuple(int(x) for x in _min.split(\".\")):\n",
    "        print(f\"Урок написан для {_name} {_min} и новее, у вас {_have}: выполните %pip install -U {_name} и перезапустите ядро\")\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",
    "1, 5, 10 и 50 штук. Таблица — товары × количества, и у каждого набора исходных чисел своя «форма»:\n",
    "\n",
    "- **себестоимость** — у каждого товара своя: столбец (по строке на товар);\n",
    "- **количество штук** `amounts` — 1, 5, 10, 50: строка (по столбцу на количество);\n",
    "- **скидка за объём** — своя у каждого количества: тоже строка;\n",
    "- **наценка** — своя у каждого товара: снова столбец."
   ],
   "id": "text-10"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Исходные данные\n",
    "import numpy as np\n",
    "\n",
    "goods = [\"эспрессо-смесь 1 кг\", \"колумбия 250 г\", \"эфиопия 250 г\", \"чёрный чай 100 г\", \"фильтры\"]\n",
    "cost = np.array([870, 380, 430, 150, 250])              # себестоимость штуки, ₽\n",
    "markup = np.array([1.5, 1.6, 1.6, 2.0, 2.2])            # наценка товара\n",
    "amounts = np.array([1, 5, 10, 50])                      # варианты количества\n",
    "volume_discount = np.array([0, 0.05, 0.10, 0.20])       # скидка за объём\n",
    "print(cost.shape, markup.shape, amounts.shape, volume_discount.shape)"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "data"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Шаг 1. Себестоимость партии"
   ],
   "id": "text-20"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 1. Товар × количество\n",
    "\n",
    "Сохраните в `base` таблицу себестоимости партии: строка — товар, столбец — количество из `amounts`.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Себестоимость — столбцом: `cost[:, np.newaxis]`; количество — строкой.\n",
    "\n",
    "</details>"
   ],
   "id": "base-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "base = ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "base"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 1 — выполните после своего решения\n",
    "def test_base():\n",
    "    \"base — таблица 5 товаров × 4 количества\"\n",
    "    assert isinstance(base, np.ndarray), f\"base — это {type(base).__name__}, а нужна таблица\"\n",
    "    assert base.shape != (4, 5), \"товары оказались в столбцах: себестоимость должна быть столбцом\"\n",
    "    assert base.shape == (5, 4), f\"форма base — {base.shape}, а нужно (5, 4)\"\n",
    "    assert base[0].tolist() == [870, 4350, 8700, 43500], f\"первая строка — {base[0].tolist()}: в строке — себестоимость 1, 5, 10 и 50 штук первого товара\"\n",
    "\n",
    "_check(test_base, names=[\"base\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "base-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "base = cost[:, np.newaxis] * amounts\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "base-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Шаг 2. Скидка за объём"
   ],
   "id": "text-28"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 2. Скидки за объём\n",
    "\n",
    "Скидки за объём — в `volume_discount` (0.05 — 5 %). Сохраните в `discounted` таблицу `base` со скидками:\n",
    "каждый столбец умножается на `1 - скидка` своего количества.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Скидки — одна на столбец, это строка: транслируется сама, без `np.newaxis`.\n",
    "\n",
    "</details>"
   ],
   "id": "volume-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "discounted = ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "volume"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 2 — выполните после своего решения\n",
    "def test_discounted():\n",
    "    \"discounted — себестоимость со скидками за объём\"\n",
    "    assert isinstance(discounted, np.ndarray) and discounted.shape == (5, 4), \"discounted — таблица 5 × 4\"\n",
    "    assert not np.allclose(discounted[0], [0, 217.5, 870, 8700]), \"получилась сама скидка; нужна цена после скидки\"\n",
    "    assert np.allclose(discounted[0], [870, 4132.5, 7830, 34800]), f\"первая строка — {discounted[0].tolist()}: скидка за объём применена неверно\"\n",
    "\n",
    "_check(test_discounted, names=[\"discounted\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "volume-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "discounted = base * (1 - volume_discount)\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "volume-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Шаг 3. Наценка"
   ],
   "id": "text-37"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 3. Цена для покупателя\n",
    "\n",
    "Наценка каждого товара — множитель в `markup`. Сохраните в `price` цену для покупателя: `discounted`, умноженная\n",
    "на наценку своего товара.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Наценка — одна на строку: нужен столбец, `markup[:, np.newaxis]`.\n",
    "\n",
    "</details>"
   ],
   "id": "markup-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "price = ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "markup"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 3 — выполните после своего решения\n",
    "def test_price():\n",
    "    \"price — цена с наценкой своего товара\"\n",
    "    assert isinstance(price, np.ndarray) and price.shape == (5, 4), \"price — таблица 5 × 4\"\n",
    "    assert np.allclose(price[:, 0], [1305, 608, 688, 300, 550]), f\"цены одной штуки — {price[:, 0].tolist()}: у каждого товара (строки) своя наценка\"\n",
    "    assert np.allclose(price[4], [550, 2612.5, 4950, 22000]), f\"строка фильтров — {price[4].tolist()}\"\n",
    "\n",
    "_check(test_price, names=[\"price\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "markup-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "price = discounted * markup[:, np.newaxis]\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "markup-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Шаг 4. Целые рубли"
   ],
   "id": "text-46"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 4. Прайс-лист в рублях\n",
    "\n",
    "Округлите `price` до целых рублей и сохраните в `price_list` массивом целого типа.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "`np.round(price)` — округление, `astype(int)` — целый тип.\n",
    "\n",
    "</details>"
   ],
   "id": "rubles-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "price_list = ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "rubles"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 4 — выполните после своего решения\n",
    "def test_int():\n",
    "    \"price_list — целые рубли\"\n",
    "    assert isinstance(price_list, np.ndarray) and price_list.shape == (5, 4), \"price_list — таблица 5 × 4\"\n",
    "    assert price_list.dtype.kind == \"i\", f\"тип price_list — {price_list.dtype}, а нужен целый\"\n",
    "    assert price_list[0, 1] != 6198, \"6198.75 превратилось в 6198: astype(int) без округления отбрасывает дробь — сначала округлите\"\n",
    "    assert price_list[0, 1] == 6199, f\"цена 5 штук первого товара — {price_list[0, 1]}: проверьте округление\"\n",
    "\n",
    "_check(test_int, names=[\"price_list\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "rubles-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "price_list = np.round(price).astype(int)\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "rubles-solution"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Вспомним про половинки\n",
    "print(price[4, 1], \"→\", price_list[4, 1])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "half"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*После решения упражнения выше:*\n",
    "\n",
    "Цена 2612.5 превратилась в 2612, а не в 2613: половинки округляются к чётному, как в уроке о статистике.\n",
    "Для прайс-листа это приемлемо, но в бухгалтерии правило округления задают явно."
   ],
   "id": "component-57"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Шаг 5. Цена за штуку"
   ],
   "id": "text-61"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 5. Выгода от объёма\n",
    "\n",
    "Сохраните в `per_unit` цену одной штуки в каждой ячейке прайс-листа: `price_list`, делённый на количество\n",
    "своего столбца.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Количества — строка `amounts`: деление транслируется само.\n",
    "\n",
    "</details>"
   ],
   "id": "per-unit-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "per_unit = ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "per-unit"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 5 — выполните после своего решения\n",
    "def test_per_unit():\n",
    "    \"per_unit — цена одной штуки в каждой ячейке\"\n",
    "    assert isinstance(per_unit, np.ndarray) and per_unit.shape == (5, 4), \"per_unit — таблица 5 × 4\"\n",
    "    assert np.allclose(per_unit[3], [300, 285, 270, 240]), f\"для чая получилось {np.round(per_unit[3], 1).tolist()}, а цена одной штуки — это цена партии, делённая на число штук в ней\"\n",
    "\n",
    "_check(test_per_unit, names=[\"per_unit\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "per-unit-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "per_unit = price_list / amounts\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "per-unit-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Шаг 6. Что влезает в бюджет"
   ],
   "id": "text-70"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 6. Бюджет 5000 ₽\n",
    "\n",
    "У покупателя 5000 ₽. Сохраните в `affordable` для каждого товара число вариантов количества, которые стоят\n",
    "не больше 5000 ₽ (по `price_list`).\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Маска `price_list <= 5000` — таблица того же размера.\n",
    "\n",
    "</details>\n",
    "<details><summary>Подсказка 2</summary>\n",
    "\n",
    "Сколько `True` в каждой строке — сумма по `axis=1`.\n",
    "\n",
    "</details>"
   ],
   "id": "budget-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "affordable = ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "budget"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 6 — выполните после своего решения\n",
    "def test_affordable():\n",
    "    \"affordable — сколько вариантов влезает в бюджет у каждого товара\"\n",
    "    assert isinstance(affordable, np.ndarray), f\"affordable — это {type(affordable).__name__}, а нужен массив из 5 чисел\"\n",
    "    assert affordable.shape != (4,), \"получилось 4 числа — по количеству; нужно по товару\"\n",
    "    assert affordable.tolist() == [1, 2, 2, 3, 3], f\"affordable = {affordable.tolist()}: посчитайте для каждого товара, сколько цен не выше 5000\"\n",
    "\n",
    "_check(test_affordable, names=[\"affordable\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "budget-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "affordable = (price_list <= 5000).sum(axis=1)\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "budget-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Шаг 7. Сколько экономит скидка"
   ],
   "id": "text-80"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 7. Экономия на десяти штуках\n",
    "\n",
    "Без скидок за объём цена была бы `base * наценка`. Сохраните в `savings` экономию покупателя при покупке\n",
    "**10 штук** каждого товара (столбец с индексом 2): цена без скидки минус `price`.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Цена без скидки: `base * markup[:, np.newaxis]`.\n",
    "\n",
    "</details>\n",
    "<details><summary>Подсказка 2</summary>\n",
    "\n",
    "Столбец для 10 штук — `[:, 2]`.\n",
    "\n",
    "</details>"
   ],
   "id": "savings-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "savings = ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "savings"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 7 — выполните после своего решения\n",
    "def test_savings():\n",
    "    \"savings — экономия на 10 штуках каждого товара\"\n",
    "    assert isinstance(savings, np.ndarray), f\"savings — это {type(savings).__name__}, а нужен массив из 5 чисел\"\n",
    "    assert savings.shape == (5,), f\"у savings форма {savings.shape}, а нужно 5 чисел — по одному на товар\"\n",
    "    assert np.allclose(savings, [1305, 608, 688, 300, 550]), f\"savings = {np.round(savings, 1).tolist()} — это не экономия на 10 штуках\"\n",
    "\n",
    "_check(test_savings, names=[\"savings\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "savings-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "full = base * markup[:, np.newaxis]\n",
    "savings = (full - price)[:, 2]\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "savings-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Выводы"
   ],
   "id": "text-90"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Прайс-лист\n",
    "print(\"количество:\", amounts)\n",
    "for name, row in zip(goods, price_list):\n",
    "    print(f\"{name:>20}: {row}\")     # :>20 — выровнять название по правому краю на 20 символов\n",
    "print(\"экономия на 10 штуках всего ассортимента:\", round(savings.sum()), \"₽\")"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "summary"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*После решения всех упражнений урока:*\n",
    "\n",
    "Весь прайс-лист — четыре массива (два столбца и две строки) и одно выражение\n",
    "`cost[:, np.newaxis] * amounts * (1 - volume_discount) * markup[:, np.newaxis]`. Добавится товар или новый\n",
    "вариант количества — формула не изменится."
   ],
   "id": "component-95"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Подробнее в справочнике:** [numpy/broadcasting](https://ds-edu-trainer.vercel.app/reference/numpy/broadcasting)"
   ],
   "id": "more"
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python"
  },
  "colab": {
   "provenance": []
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}