{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Системы уравнений\n", "\n", "Найти неизвестные по нескольким суммам — цены по чекам, состав смеси. Система линейных уравнений в виде A @ x = b и её решение np.linalg.solve.\n", "\n", "Курс NumPy · урок `np-solve` · [урок на сайте](https://ds-edu-trainer.vercel.app/courses/numpy/solve).\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", "когда встретится такая задача. Он короткий и опирается на матричное умножение из урока\n", "[«Матричное умножение»](https://ds-edu-trainer.vercel.app/courses/numpy/matmul).\n", "\n", "## От умножения — к обратной задаче\n", "\n", "В уроке о матричном умножении мы знали количества и цены и считали суммы чеков: `orders @ prices`. Теперь\n", "наоборот: суммы чеков известны, а цены — нет. Два чека: 3 пачки кофе и 2 кружки — 690 ₽; 1 пачка и 4 кружки —\n", "730 ₽. Сколько стоит пачка и кружка? Это система двух уравнений:\n", "\n", "```\n", "3x + 2y = 690\n", "1x + 4y = 730\n", "```\n", "\n", "Коэффициенты — таблица `A` (строка — чек, столбец — товар), правые части — вектор `b`. Вся система записывается\n", "одной строкой: `A @ [x, y] = b`. Функция `np.linalg.solve(A, b)` находит `[x, y]`. Проверить ответ легко —\n", "умножить обратно и сравнить с `b`:" ], "id": "text-10" }, { "cell_type": "code", "metadata": {}, "source": [ "# Цены из двух чеков\n", "import numpy as np\n", "\n", "A_demo = np.array([[3, 2], [1, 4]])\n", "b_demo = np.array([690, 730])\n", "x = np.linalg.solve(A_demo, b_demo)\n", "print(np.round(x, 2)) # пачка кофе и кружка\n", "print(np.round(A_demo @ x, 2)) # умножили обратно — получили суммы чеков\n", "print(np.allclose(A_demo @ x, b_demo))" ], "execution_count": null, "outputs": [], "id": "solve" }, { "cell_type": "markdown", "metadata": {}, "source": [ "Ответ дробного типа, даже если числа целые: внутри `solve` делит. Поэтому сравнивать результат с ожидаемым\n", "лучше через `np.allclose`, а не `==`." ], "id": "text-31" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 1. Латте и круассан\n", "\n", "Два чека из кафе: 2 латте и 1 круассан — 520 ₽; 1 латте и 3 круассана — 560 ₽. Сохраните в `A` таблицу\n", "коэффициентов (строка — чек, столбцы — латте, круассан), в `b` — суммы чеков, а в `cafe_prices` — цены латте\n", "и круассана.\n", "\n", "
Подсказка 1\n", "\n", "Строки `A` — сколько чего в чеке: `[2, 1]` и `[1, 3]`; `b` — `[520, 560]`.\n", "\n", "
\n", "
Подсказка 2\n", "\n", "`np.linalg.solve(A, b)`.\n", "\n", "
" ], "id": "two-task" }, { "cell_type": "code", "metadata": {}, "source": [ "A = ...\n", "b = ...\n", "cafe_prices = ..." ], "execution_count": null, "outputs": [], "id": "two" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 1 — выполните после своего решения\n", "def test_system():\n", " \"A и b — система из двух чеков\"\n", " assert np.shape(A) == (2, 2), f\"у A форма {np.shape(A)}, а нужна (2, 2): два чека × два товара\"\n", " assert np.shape(b) == (2,), f\"у b форма {np.shape(b)}, а чеков два\"\n", "\n", "\n", "def test_prices():\n", " \"cafe_prices — цены латте и круассана\"\n", " assert np.shape(cafe_prices) == (2,), \"cafe_prices — две цены\"\n", " assert not np.allclose(cafe_prices, [120, 200]), \"цены в обратном порядке: столбцы A — сначала латте, потом круассан\"\n", " assert np.allclose(cafe_prices, [200, 120]), f\"cafe_prices = {np.round(cafe_prices, 2)}: проверьте строки A\"\n", "\n", "_check(test_system, test_prices, names=[\"A\",\"b\",\"cafe_prices\"])" ], "execution_count": null, "outputs": [], "id": "two-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "A = np.array([[2, 1], [1, 3]])\n", "b = np.array([520, 560])\n", "cafe_prices = np.linalg.solve(A, b)\n", "```\n", "\n", "
" ], "id": "two-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "Неизвестных может быть сколько угодно — нужно столько же уравнений:" ], "id": "text-43" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 2. Три чека\n", "\n", "Три чека: 2 кофе, 1 чай и 1 пирожное — 690 ₽; 1 кофе и 3 чая — 720 ₽; 2 чая и 2 пирожных — 900 ₽. Сохраните\n", "в `A3` таблицу коэффициентов (строка — чек, столбцы — кофе, чай, пирожное), в `b3` — суммы чеков, а в\n", "`unit_prices` — цены трёх позиций.\n", "\n", "
Подсказка 1\n", "\n", "Если позиции в чеке нет, её коэффициент — 0: строки `[2, 1, 1]`, `[1, 3, 0]`, `[0, 2, 2]`.\n", "\n", "
\n", "
Подсказка 2\n", "\n", "`np.linalg.solve(A3, b3)`.\n", "\n", "
" ], "id": "receipts-task" }, { "cell_type": "code", "metadata": {}, "source": [ "A3 = ...\n", "b3 = ...\n", "unit_prices = ..." ], "execution_count": null, "outputs": [], "id": "receipts" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 2 — выполните после своего решения\n", "def test_system():\n", " \"A3 и b3 — система из трёх чеков\"\n", " assert np.shape(A3) == (3, 3), f\"у A3 форма {np.shape(A3)}, а нужна (3, 3): три чека × три позиции\"\n", " assert np.shape(b3) == (3,), f\"у b3 форма {np.shape(b3)}, а чеков три\"\n", "\n", "\n", "def test_prices():\n", " \"unit_prices — цены кофе, чая и пирожного\"\n", " assert np.shape(unit_prices) == (3,), \"unit_prices — три цены\"\n", " assert np.allclose(unit_prices, [120, 200, 250]), f\"unit_prices = {np.round(unit_prices, 2)}: проверьте строки A3 — если позиции нет в чеке, её количество 0\"\n", "\n", "_check(test_system, test_prices, names=[\"A3\",\"b3\",\"unit_prices\"])" ], "execution_count": null, "outputs": [], "id": "receipts-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "A3 = np.array([[2, 1, 1], [1, 3, 0], [0, 2, 2]])\n", "b3 = np.array([690, 720, 900])\n", "unit_prices = np.linalg.solve(A3, b3)\n", "```\n", "\n", "
" ], "id": "receipts-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Типичная ошибка: столбцы в разном порядке.**\n", ">\n", "> Каждый столбец `A` — одно неизвестное, и порядок должен быть одинаковым во всех строках: если в первой строке\n", "> «кофе, чай, пирожное», то и в остальных так же. Перепутанный порядок не вызывает ошибки — просто получаются\n", "> неправильные цены. Поэтому ответ всегда стоит проверить: `A @ x` должно дать `b`." ], "id": "component-55" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Не только чеки\n", "\n", "Системой уравнений записывается любая задача «несколько неизвестных, несколько известных сумм». Например, смесь:\n", "уравнение о весе и уравнение о стоимости." ], "id": "text-60" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 3. Кофейная смесь\n", "\n", "Нужно 10 кг смеси по 950 ₽ за килограмм из двух сортов: один стоит 800 ₽/кг, другой — 1200 ₽/кг. Сохраните\n", "в `blend` массив из двух чисел — сколько килограммов каждого сорта взять (сначала дешёвого, потом дорогого).\n", "\n", "
Подсказка 1\n", "\n", "Два уравнения: `x + y = 10` (вес) и `800x + 1200y = 9500` (стоимость всей смеси: 10 × 950).\n", "\n", "
\n", "
Подсказка 2\n", "\n", "`np.linalg.solve(np.array([[1, 1], [800, 1200]]), np.array([10, 9500]))`.\n", "\n", "
" ], "id": "blend-task" }, { "cell_type": "code", "metadata": {}, "source": [ "blend = ..." ], "execution_count": null, "outputs": [], "id": "blend" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 3 — выполните после своего решения\n", "def test_blend():\n", " \"blend — килограммы дешёвого и дорогого сорта\"\n", " assert np.shape(blend) == (2,), \"blend — два числа: сколько килограммов каждого сорта\"\n", " assert abs(np.sum(blend) - 10) < 1e-9, f\"в сумме {np.sum(blend):.2f} кг, а смеси нужно 10 кг: первое уравнение — про общий вес смеси\"\n", " assert not np.allclose(blend, [3.75, 6.25]), \"сорта в обратном порядке: сначала дешёвый (800 ₽/кг), потом дорогой\"\n", " assert np.allclose(blend, [6.25, 3.75]), f\"blend = {np.round(blend, 2)}: проверьте второе уравнение — про стоимость всей смеси\"\n", "\n", "_check(test_blend, names=[\"blend\"])" ], "execution_count": null, "outputs": [], "id": "blend-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "blend = np.linalg.solve(np.array([[1, 1], [800, 1200]]), np.array([10, 9500]))\n", "```\n", "\n", "
" ], "id": "blend-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Когда однозначного решения нет\n", "\n", "Решение существует и единственно, если ни одно уравнение не получается из других — умножением на число\n", "и сложением. Если второй чек — это первый, умноженный на два, новой информации в нём нет: подходит сколько\n", "угодно пар цен, и однозначно их не найти. Ячейка ниже перехватывает ошибку\n", "через `try` / `except`, чтобы показать её текст:" ], "id": "text-73" }, { "cell_type": "code", "metadata": {}, "source": [ "# Второй чек повторяет первый\n", "same = np.array([[3, 2], [6, 4]]) # второй чек — первый, умноженный на два\n", "try:\n", " print(np.linalg.solve(same, np.array([690, 1380])))\n", "except np.linalg.LinAlgError as error:\n", " print(\"LinAlgError:\", error)" ], "execution_count": null, "outputs": [], "id": "singular" }, { "cell_type": "markdown", "metadata": {}, "source": [ "В Jupyter на компьютере `solve` сообщает об ошибке `LinAlgError: Singular matrix`. Python в браузере устроен\n", "немного иначе и вместо ошибки возвращает `[nan nan]` — «не числа» из модуля о пропусках. Смысл один: однозначного ответа нет." ], "id": "text-82" }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Типичная ошибка: Singular matrix или nan в ответе.**\n", ">\n", "> «Вырожденная матрица»: какое-то уравнение выводится из остальных (или уравнений с настоящей информацией\n", "> меньше, чем неизвестных). Нужны другие данные — например, чек с другим набором товаров. Раз в браузере ошибки\n", "> может не быть, проверяйте ответ: `np.isnan(x).any()` и `np.allclose(A @ x, b)`." ], "id": "component-86" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Итоги\n", "\n", "- Система линейных уравнений — это `A @ x = b`: строка `A` — уравнение, столбец — неизвестное.\n", "- `np.linalg.solve(A, b)` находит `x`; уравнений должно быть столько же, сколько неизвестных.\n", "- Проверка — умножить обратно: `np.allclose(A @ x, b)`.\n", "- `Singular matrix` (в браузере — `nan` в ответе) — какое-то уравнение получается из других, однозначного решения нет." ], "id": "text-91" }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Подробнее в справочнике:** [numpy/linalg](https://ds-edu-trainer.vercel.app/reference/numpy/linalg) · [numpy/matmul](https://ds-edu-trainer.vercel.app/reference/numpy/matmul)" ], "id": "more" } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "name": "python" }, "colab": { "provenance": [] } }, "nbformat": 4, "nbformat_minor": 5 }