{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Нормализация\n",
    "\n",
    "Как сравнивать величины разного масштаба — отклонение от среднего, z-оценка и приведение к отрезку от 0 до 1, по каждому столбцу одной строкой.\n",
    "\n",
    "Курс NumPy · урок `np-normalize` · [урок на сайте](https://ds-edu-trainer.vercel.app/courses/numpy/normalize).\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",
    "_DATA = {\n",
    "    \"scores.csv\": \"\"\"\n",
    "eNo9kV1uGzEMhN91lnkgKfHvHDpAETSBvUDtBF73IbcPSBcFFgKWGn0cDs/n3/eP+/PX8Y7b2/OKr+v3efw+8fX4vDzebrfjfsH1\n",
    "OJ+fj2983C9/jvM6NjEssLLOEASPTQInmFXJHeFj04QxNOACIziNTQtuMGnVgs+xSeEBz9IGwXNsMpjCHK4tL7xDpXGG5ViFD+iE\n",
    "LahWB19jU3ZJoY5cWHNsJuiCJdaEM0zHZi620T9hqwQxkRPp1ZGJxuZZLkuZ9WmOzQs26413V6uXiiiLDaf2ytbRtAUjqIzN3qzs\n",
    "iRQWY3Mgub1bD1nGsvAVlTSexhaqACtj7Q45tjCCkZ1hZLNE6nJFsxmuY8vsn7Zm6/Wwww9uVrxKCuUKVBma0GIZ/DU5YUlvTWqf\n",
    "XZWaqZKWvtcOx72TkKz9MVEFEtS1Sb2Q/yeNH8ySg9M=\n",
    "\"\"\",\n",
    "}\n",
    "os.makedirs(\"data\", exist_ok=True)\n",
    "for _name, _packed in _DATA.items():\n",
    "    with open(os.path.join(\"data\", _name), \"wb\") as _f:\n",
    "        _f.write(zlib.decompress(base64.b64decode(_packed)))\n",
    "print(\"Файлы данных:\", \", \".join(sorted(_DATA)))\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": [
    "80 баллов по физике — это много или мало? Зависит от того, как написали остальные. Если по физике средний балл\n",
    "67 и все близко к нему, 80 — отличный результат; если средний 80 — обычный. Чтобы сравнивать значения из разных\n",
    "столбцов, их **нормализуют** — приводят к общему масштабу. Благодаря транслированию это одна строка для всей\n",
    "таблицы."
   ],
   "id": "text-10"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Оценки\n",
    "import numpy as np\n",
    "\n",
    "scores = np.loadtxt(\"data/scores.csv\", delimiter=\",\", skiprows=1, usecols=(1, 2, 3, 4, 5))\n",
    "print(np.round(scores.mean(axis=0), 1))\n",
    "print(np.round(scores.std(axis=0), 1))"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "load"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## z-оценка\n",
    "\n",
    "**z-оценка** (z-score, стандартизация) показывает, на сколько стандартных отклонений значение выше или ниже\n",
    "среднего: z = (x − среднее) / std. z = 0 — ровно средне, z = 1 — на одно отклонение лучше, z = −2 — заметно хуже.\n",
    "После стандартизации у данных среднее 0 и std 1, в каких бы единицах они ни были."
   ],
   "id": "text-17"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# z-оценки по математике\n",
    "math_scores = scores[:, 0]\n",
    "z_math = (math_scores - math_scores.mean()) / math_scores.std()\n",
    "print(np.round(z_math[:5], 2))\n",
    "print(round(z_math.mean(), 6) == 0, round(z_math.std(), 6))   # round — чтобы крошечная погрешность не мешала сравнению"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "z-one"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 1. z-оценки по физике\n",
    "\n",
    "Сохраните в `z_phys` z-оценки баллов по физике (столбец 1), а в `best_phys` — индекс студента с самой высокой\n",
    "z-оценкой.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Столбец — `scores[:, 1]`; формула — `(x - x.mean()) / x.std()`.\n",
    "\n",
    "</details>\n",
    "<details><summary>Подсказка 2</summary>\n",
    "\n",
    "Скобки вокруг разности обязательны.\n",
    "\n",
    "</details>"
   ],
   "id": "z-physics-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "z_phys = ...\n",
    "best_phys = ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "z-physics"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 1 — выполните после своего решения\n",
    "def test_z():\n",
    "    \"z_phys — z-оценки по физике\"\n",
    "    assert isinstance(z_phys, np.ndarray) and z_phys.shape == (30,), \"z_phys — 30 чисел, по студенту\"\n",
    "    assert abs(z_phys.mean()) < 1e-9, \"среднее z-оценок должно быть 0: проверьте скобки\"\n",
    "    assert abs(z_phys.std() - 1) < 1e-9, \"std z-оценок должно быть 1: делите на стандартное отклонение\"\n",
    "    assert abs(z_phys[0] - (-1.409)) < 1e-3, f\"у первого студента z = {z_phys[0]:.3f}: это точно физика?\"\n",
    "\n",
    "\n",
    "def test_best():\n",
    "    \"best_phys — лучший по физике\"\n",
    "    assert best_phys == 28, f\"best_phys = {best_phys} — это не индекс лучшего по физике\"\n",
    "\n",
    "_check(test_z, test_best, names=[\"z_phys\",\"best_phys\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "z-physics-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "phys = scores[:, 1]\n",
    "z_phys = (phys - phys.mean()) / phys.std()\n",
    "best_phys = z_phys.argmax()\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "z-physics-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Типичная ошибка: забытые скобки.**\n",
    ">\n",
    "> `x - x.mean() / x.std()` — это не z-оценка: деление выполняется раньше вычитания, и из `x` вычитается\n",
    "> среднее, делённое на std. Разность — в скобки: `(x - x.mean()) / x.std()`."
   ],
   "id": "component-34"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Вся таблица сразу\n",
    "\n",
    "Средние и std по столбцам — строки формы `(5,)`, и они транслируются на таблицу 30 × 5. Каждый столбец\n",
    "стандартизуется по своим среднему и разбросу:"
   ],
   "id": "text-38"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# z-оценки по всем предметам\n",
    "z_demo = (scores - scores.mean(axis=0)) / scores.std(axis=0)\n",
    "print(z_demo.shape)\n",
    "print(np.round(z_demo[:2], 1))\n",
    "print(np.allclose(z_demo.mean(axis=0), 0), np.allclose(z_demo.std(axis=0), 1))"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "z-table"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Чтобы проверить, что средние стали нулями, а отклонения — единицами, используем `np.allclose(a, b)`: она\n",
    "отвечает, **близки** ли все значения `a` к `b`. Сравнивать дробные результаты через `==` нельзя — из-за\n",
    "приближённого хранения там может оказаться 0.0000000000000001 вместо 0."
   ],
   "id": "text-45"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 2. Стандартизовать таблицу\n",
    "\n",
    "Сохраните в `z` таблицу z-оценок: каждый столбец `scores` стандартизован по своему предмету.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Средние и отклонения по столбцам — с `axis=0`.\n",
    "\n",
    "</details>\n",
    "<details><summary>Подсказка 2</summary>\n",
    "\n",
    "`(scores - scores.mean(axis=0)) / scores.std(axis=0)`.\n",
    "\n",
    "</details>"
   ],
   "id": "z-all-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "z = ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "z-all"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 2 — выполните после своего решения\n",
    "def test_shape():\n",
    "    \"z — таблица 30 × 5\"\n",
    "    assert isinstance(z, np.ndarray) and z.shape == (30, 5), f\"z должна быть таблицей 30 × 5\"\n",
    "\n",
    "\n",
    "def test_standard():\n",
    "    \"в каждом столбце среднее 0 и std 1\"\n",
    "    assert isinstance(z, np.ndarray) and z.shape == (30, 5), \"сначала исправьте то, о чём говорит проверка выше\"\n",
    "    assert np.allclose(z.mean(axis=0), 0), \"средние столбцов должны быть 0: вычитайте среднее своего столбца и не забудьте скобки\"\n",
    "    assert not np.allclose(z.std(axis=1), 1), \"стандартизованы строки, а нужно — столбцы\"\n",
    "    assert np.allclose(z.std(axis=0), 1), \"std столбцов должны быть 1: делите на std своего столбца, а не на общий std таблицы\"\n",
    "\n",
    "_check(test_shape, test_standard, names=[\"z\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "z-all-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "z = (scores - scores.mean(axis=0)) / scores.std(axis=0)\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "z-all-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Вопрос.** Какими станут среднее и стандартное отклонение каждого столбца после стандартизации?\n",
    "\n",
    "- среднее 1, std 0\n",
    "- среднее 0, std 1\n",
    "- те же, что были\n",
    "\n",
    "<details><summary>Ответ</summary>\n",
    "\n",
    "среднее 0, std 1\n",
    "\n",
    "Вычитание среднего сдвигает данные так, что их среднее становится 0; деление на std сжимает разброс так, что std становится 1.\n",
    "\n",
    "</details>"
   ],
   "id": "quiz-57"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## От 0 до 1\n",
    "\n",
    "Другой способ — растянуть значения на отрезок от 0 до 1 (min-max-нормализация): минимум становится 0, максимум —\n",
    "1, остальное — пропорционально между ними: (x − min) / (max − min)."
   ],
   "id": "text-66"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 3. Шкала от 0 до 1\n",
    "\n",
    "Сохраните в `scaled` таблицу, где баллы каждого предмета приведены к отрезку от 0 до 1 по минимуму и максимуму\n",
    "этого предмета.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Минимумы и максимумы по столбцам — `min(axis=0)` и `max(axis=0)`.\n",
    "\n",
    "</details>\n",
    "<details><summary>Подсказка 2</summary>\n",
    "\n",
    "`(scores - lo) / (hi - lo)`, где `lo` и `hi` — эти строки.\n",
    "\n",
    "</details>"
   ],
   "id": "minmax-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "scaled = ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "minmax"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 3 — выполните после своего решения\n",
    "def test_scaled():\n",
    "    \"в каждом столбце минимум 0 и максимум 1\"\n",
    "    assert isinstance(scaled, np.ndarray) and scaled.shape == (30, 5), \"scaled — таблица 30 × 5\"\n",
    "    assert np.allclose(scaled.min(axis=0), 0), \"минимум каждого столбца должен стать 0: вычитайте минимум своего столбца\"\n",
    "    assert np.allclose(scaled.max(axis=0), 1), \"максимум каждого столбца должен стать 1: проверьте, на что делите, и скобки\"\n",
    "    assert np.allclose(scaled[0], [0.452, 0.038, 0.463, 0.769, 0.667], atol=1e-3), f\"первая строка — {np.round(scaled[0], 3).tolist()}\"\n",
    "\n",
    "_check(test_scaled, names=[\"scaled\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "minmax-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "lo = scores.min(axis=0)\n",
    "hi = scores.max(axis=0)\n",
    "scaled = (scores - lo) / (hi - lo)\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "minmax-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Общий рейтинг\n",
    "\n",
    "Когда предметы в одном масштабе, их можно честно усреднять: средняя z-оценка студента показывает, насколько он\n",
    "в целом выше группы, и сложные предметы не «топят» результат."
   ],
   "id": "text-79"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 4. Лучший с учётом сложности\n",
    "\n",
    "Сохраните в `overall` среднюю z-оценку каждого студента по пяти предметам (таблица `z` из упражнения выше),\n",
    "а в `top_student` — индекс студента с наибольшей средней z-оценкой.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Среднее по строкам — `z.mean(axis=1)`.\n",
    "\n",
    "</details>"
   ],
   "id": "overall-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "overall = ...\n",
    "top_student = ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "overall"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 4 — выполните после своего решения\n",
    "def test_overall():\n",
    "    \"overall — средняя z-оценка студента\"\n",
    "    assert isinstance(overall, np.ndarray), f\"overall — это {type(overall).__name__}, а нужен массив\"\n",
    "    assert overall.shape != (5,), \"получилось 5 чисел — по предмету, а нужно по числу на студента\"\n",
    "    assert overall.shape == (30,), f\"у overall форма {overall.shape}, а нужно 30 чисел\"\n",
    "\n",
    "\n",
    "def test_top():\n",
    "    \"top_student — лучший по средней z-оценке\"\n",
    "    assert top_student == 11, f\"top_student = {top_student} — это не индекс лучшего по средней z-оценке\"\n",
    "\n",
    "_check(test_overall, test_top, names=[\"overall\",\"top_student\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "overall-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "overall = z.mean(axis=1)\n",
    "top_student = overall.argmax()\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "overall-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Итоги\n",
    "\n",
    "- z = (x − среднее) / std: сравнимые значения из разных шкал; после неё среднее 0, std 1.\n",
    "- min-max: (x − min) / (max − min) — отрезок от 0 до 1.\n",
    "- Для таблицы — агрегаты по `axis=0` транслируются на все строки.\n",
    "- Разность — в скобки: деление выполняется раньше вычитания."
   ],
   "id": "text-91"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Подробнее в справочнике:** [numpy/broadcasting](https://ds-edu-trainer.vercel.app/reference/numpy/broadcasting) · [numpy/statistics](https://ds-edu-trainer.vercel.app/reference/numpy/statistics)"
   ],
   "id": "more"
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python"
  },
  "colab": {
   "provenance": []
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}