{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Меняем форму\n",
    "\n",
    "Те же числа — другая таблица — reshape разложит год по неделям, -1 досчитает размер сам, ravel вытянет обратно в ряд, .T повернёт таблицу.\n",
    "\n",
    "Курс NumPy · урок `np-reshape` · [урок на сайте](https://ds-edu-trainer.vercel.app/courses/numpy/reshape).\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",
    "    \"moscow_2025.csv\": \"\"\"\n",
    "eNplWEmuXDcM3Oss6gdx0HQaw0i88MKBEWSR3D6oIqXuOKv/H5uiyOIo/v71n/rXtx8/v/z4/kf+8/Xv+vPPb799//nlx48i9bWf\n",
    "XV/2aG1PK4rv+f42fDd8T357fYk/Wl/z0SqPl15fos8IAjgGCQ7CImGSsOprPY0E/tvry/PEBm+rL+UBK9Lqa0ApSQY5WnYSpAjV\n",
    "NBwJtcSSwx+pAgIUbVDUHwuWDhbBGQ8ClXYQwDGLTCiGg8+q69lFFo700Ezl0SI7WS5eLVmMQlZRCctf+rRq4NA8os+OIwYCMe5B\n",
    "cNg74l4S+lF7VnmsKDXliVBdJ60jJY+sX4VusvSAhK6kqgsoQuwqJsd367AoD42PQ3ZRC6SNynrYR0L/lTDC1S9liEixeYMsZay4\n",
    "8iprUFbAMojaKt6OJj15XA5lpEedUeBgwc29uNEgDRPJEmHAwFjE0jsjeCeAZAL09uwAmZRJCuMw8PVFDQWipSo03AmnP70KRPdG\n",
    "HgIU0dHl7adZFRQ92dBToW68yyIGJlLKD2Wlv3un5B5mjKeXTpB33O7PLH3eTPXaIXfBnl5fjXG3S9+hfEtAB0Dz6s+o6+llQNdn\n",
    "15OVQ8OlCER9vAyDbNju1cDvF9Tgz1BT3i9l0FMT9/c6n1XGzDxvz6oOCdRQ3nk+9s23TaNmC/+/WobjlBQKV3QQ6GwDR6gxDUKZ\n",
    "TADGymQp2mEcOfrN0ABijrjRDgPSA66YtT+rTNiIgpAX7LixEZde1qlWjc7SsuQUqskKuZSQ44yAn2ULOPWKkrI86ouliavfgK72\n",
    "zLLGKQYjfp9p8UFtrShHyFB/Rln7mCN1PlZ2C/wGAWllM/FaPfVoK302M9Y2zNK6MhW2MyI2tZtlwxB8ZukeVSl6EesNDVo9YbtX\n",
    "7c+uN9H2rshv1hxBfW2NsIondNKE4qVlLZGmdaCkH7SlWUX2MheDAwp21Ov87u9LgjDqCJkOM4q0CVwqU1VIAPqrbgKIOyILVua+\n",
    "SKsIuvedIkgZ6H0IgMSrGH0+i4hVFIe0DBxAmGr1JPQARkDupIzK0txu22MAVlY9pJTIoiNYrKip7LoA5mkDoi00g3MHFFEhNGKn\n",
    "Dari11ZlBPLgMXrwrZsixbWecigKfLWyJAZhMARonpIww0cQiNgpolR8VemMOy+iGQrCVKC/rTHQxI9gQ8wqoD6NHX74dKdZRe9g\n",
    "nQ+CB2QSlWsXsZ6euAbYwAELsINCPVqVTYoUsYVTXhXJYpSTuEmE+yriDZQOiiAOi7hEZMnpFOIa9shJIXELybKY51rEvbLfybg8\n",
    "/cTHjMs9KpAotelFHGG7P7zkK6+ex7fOnxcocNAs0lsg9VavS/ysdw7qxFuhHgJdi3QLNBMc8Djgcpw6lJ4ZtC5lhLNlM5lGkU7X\n",
    "blAMfi3SMyC0sY3sIn1HXMl+Blu/jISBlE6KsMPiaEbBiBr0QbAMa+SD4qrh8bOe1iCjX58nhGMEeqos9lJkTIiQqtB7k2cBvY0B\n",
    "MDqKjA2zaIRWg6GzReRTZUqeEgVgsESAhflDTJEhXmQysrzqOAhOv5drjLGzQwSNYAhDUMJMfRiVM2OZlnbYPhnL48PSuTMDABvT\n",
    "cbVIB41ONIosCSfTgTy1NDPpltdlGWKnH8ryvOuUfVksQP4R3WvcooM5SIqsecMn83itiFK9ZXbtzJsbhrvhFOU0TgiyJeojUQoe\n",
    "vbmeVmwLP6iyT3mR7SFCb53ZmdTaj12bqC+451AmDqyqky2wF9kLPDt4WMT3BqVDzsgXQkvJx83amIJSFcXFHinaNJPydBRtlqF8\n",
    "Oog2jxhTAsBTPe06Ea4tXa793jXDMZSDFNS2oj3IZGyMom0n8srcwSOmRbFSY0+UoiKg9AhNe7yoaGJ4CpKKZeJG5ZtFhTrbOzZU\n",
    "MgdpRVAGeFaAFJQJv8s7m1T48/7AULJ40oOoqaotGrKeYVFVojNG8sAK1Uy5i6pa1CLtSS6qfpnioaR6svA0HdWRDrtvNp1ZboSh\n",
    "ictWJs81THf0pKy9vahlI2Yy67OLmtzQTBVN/+MML2oshetDH/ML6+C4rtEEPbwWPOOmbuqMJnjtUlLWLQpsdVbUWO1GOGBAtFPp\n",
    "HrjGC5ZKa2RYUDSj/ka0MyX9k4e9a0f1DUqP4eatoo+Yu27nVp+3dzpnQvV1K1DnBKC+I+70jJ7aW5Qa9aNzP1lIYXBY1492FTyW\n",
    "zWlxVpxFu+dMcNqe9p7zB71GnnGrVNre55kP06d9ceC+E6T2XZGPct/v0QX3R+oMuUWUnR+LgZyVwx2wYRjHb9rRSPAYoO7Vg8+x\n",
    "yFSCNUbMXJq7Ex2z5oiWUA0M8jQztR05ybMaIvlm4+R/R32dmOQ9KjGeMTo1pu4z6um0mEzPA1+nx2vAYjiH1B6wcX6HqnPkqHKq\n",
    "vc55x4dzM4aPnTUFIM0dF92bV0Nn/yTgOTbuwK9oe4/V84zXxQfmHc9BcXJMPtK8KFregwEtAVojrL1Ln4UIGFEQgrA+3z4g4Mk2\n",
    "Y6RjEd6NWg0Wr150Y+QMMQue3WzkkR4KQzeg7u/Xk26Krmf2091jyXS7wx7cAfTLMPn4u2bwBSefEqGk1VOYrTU+hDm68lu4MDij\n",
    "rzXUFTgkFz18vjV6tT1erOGv1FPWraWGzjI2irXci92FZJvxfvYshtZWvIXvMgnt7Gn1tH8TtssaybiLoZVRR0aNFpN4oQ/OQVZM\n",
    "LJYDmmXAxGNbGS9GnOhnDZU4YJnIVsP9jBeT3Hx0vk1HMYE24TE83QwN7NELvWmL9QzXI0GR2D/dl75hl5ibwrxXLTY+zBnorh66\n",
    "25XCfULAHIRxFyJpns7cL0rWT9N1lwzxOLX3PvEEj2GhmAtUhJAXs/d6JvUzjRWVUo4Vw0LRo9uwSBUzrlPBnxrbe0EzuRYwy11S\n",
    "40oDZyakBIJxhivFcVZYoOyw+xXNH5vLdjexhyLXcM/tpt6dFKqGFnOLfd7dQZl7njrJbVgqonhwr8Kg9P+B7DM3tLFUW8V83WW7\n",
    "cww032d3mOr0lmbdUMRKMcUkXFwpSqxK4zliPRah7Sz8wOV3QXzOdXp0BZKo0dbH3bchaq1Yn7msjwUmeD43zUzRvnOde1EcLbfG\n",
    "Z+tgQ96XHVIsmyWWvhhEDTvGWNeOK8oPl7MsSLHR00fnLfovWM2L8A==\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": [
    "Форма массива — это только способ разложить числа по строкам и столбцам. Сами числа можно разложить\n",
    "по-другому, не меняя их и не меняя порядка. Это делает метод `reshape(строки, столбцы)`:"
   ],
   "id": "text-10"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Двенадцать чисел — три формы\n",
    "import numpy as np\n",
    "\n",
    "nums = np.arange(12)\n",
    "print(nums)\n",
    "print(nums.reshape(3, 4))\n",
    "print(nums.reshape(2, 6))"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "basic"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Числа заполняют новую форму **по строкам**: сначала первая строка слева направо, потом вторая. Общее число\n",
    "элементов должно сохраниться: 12 = 3 × 4 = 2 × 6."
   ],
   "id": "text-15"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 1. Таблица номеров\n",
    "\n",
    "Создайте массив `grid` — числа от 1 до 20, разложенные в таблицу из 4 строк и 5 столбцов.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Сначала ряд `np.arange(1, 21)`, потом `reshape(4, 5)`.\n",
    "\n",
    "</details>"
   ],
   "id": "grid-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "grid = ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "grid"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 1 — выполните после своего решения\n",
    "def test_shape():\n",
    "    \"grid — таблица 4 × 5\"\n",
    "    assert isinstance(grid, np.ndarray), f\"grid — это {type(grid).__name__}, а нужен массив\"\n",
    "    assert grid.shape != (5, 4), \"получилось 5 строк и 4 столбца: в reshape сначала строки\"\n",
    "    assert grid.shape == (4, 5), f\"форма grid — {grid.shape}, а нужно (4, 5)\"\n",
    "\n",
    "\n",
    "def test_values():\n",
    "    \"числа от 1 до 20 по строкам\"\n",
    "    assert isinstance(grid, np.ndarray) and grid.shape == (4, 5), \"сначала исправьте то, о чём говорит проверка выше\"\n",
    "    assert grid[0, 0] != 0, \"таблица начинается с 0, а нужно с 1\"\n",
    "    assert grid.tolist() == [[1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13, 14, 15], [16, 17, 18, 19, 20]], f\"в grid {grid.tolist()}\"\n",
    "\n",
    "_check(test_shape, test_values, names=[\"grid\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "grid-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "grid = np.arange(1, 21).reshape(4, 5)\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "grid-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Год по неделям\n",
    "\n",
    "В 2025 году 365 дней — это 52 полные недели и ещё один день. Возьмём первые 364 дня и разложим их по неделям:\n",
    "52 строки по 7 дней. Тогда столбец таблицы — это один день недели за весь год:"
   ],
   "id": "text-24"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# 364 дня → 52 недели\n",
    "tmax = np.loadtxt(\"data/moscow_2025.csv\", delimiter=\",\", skiprows=1, usecols=2)\n",
    "weeks = tmax[:364].reshape(52, 7)\n",
    "print(weeks.shape)\n",
    "print(weeks[0])            # первая неделя\n",
    "print(weeks[:, 0].shape)   # все среды"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "weeks"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Строка `weeks[0]` — первая неделя года, столбец `weeks[:, 0]` — все среды (год начался в среду). То, что\n",
    "раньше требовало среза с шагом, теперь — просто столбец.\n",
    "\n",
    "Форма должна вмещать ровно столько элементов, сколько есть. 364 числа нельзя разложить в таблицу 5 × 7:"
   ],
   "id": "text-31"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# 364 не делится на 5 × 7\n",
    "# Эта ячейка показывает ошибку ValueError: она перехвачена, чтобы «Выполнить всё» не останавливалось.\n",
    "try:\n",
    "    tmax[:364].reshape(5, 7)\n",
    "except Exception as error:\n",
    "    print(f\"{type(error).__name__}: {error}\")"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "bad-shape"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Типичная ошибка: размеры не сходятся.**\n",
    ">\n",
    "> `cannot reshape array of size 364 into shape (5,7)` — произведение размеров новой формы не равно числу\n",
    "> элементов. Проверьте арифметику: 52 × 7 = 364, а 5 × 7 = 35."
   ],
   "id": "component-39"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## −1: посчитай сам\n",
    "\n",
    "Один из размеров можно не считать, а написать `-1`: NumPy вычислит его из общего числа элементов.\n",
    "`reshape(-1, 7)` — «сколько получится строк по 7»:"
   ],
   "id": "text-43"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# reshape(-1, 7)\n",
    "print(tmax[:364].reshape(-1, 7).shape)\n",
    "print(np.arange(10).reshape(-1, 2))"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "minus-one"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 2. Недели минимальных температур\n",
    "\n",
    "Загрузите минимальные температуры (столбец 1) в `tmin`. Возьмите первые 364 дня и разложите их по неделям\n",
    "в `tmin_weeks` — по 7 дней в строке. Число недель не считайте — пусть посчитает NumPy.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Первые 364 дня — срез `[:364]`.\n",
    "\n",
    "</details>\n",
    "<details><summary>Подсказка 2</summary>\n",
    "\n",
    "`reshape(-1, 7)` — строки по 7, их число NumPy найдёт сам.\n",
    "\n",
    "</details>"
   ],
   "id": "by-week-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "tmin = ...\n",
    "tmin_weeks = ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "by-week"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 2 — выполните после своего решения\n",
    "def test_tmin():\n",
    "    \"tmin — 365 минимальных температур\"\n",
    "    assert isinstance(tmin, np.ndarray) and tmin.shape == (365,), \"tmin — это должен быть один столбец минимальных температур из файла, 365 значений\"\n",
    "    assert tmin.min() == -14.9, \"tmin — не столбец минимальных температур — номера столбцов считают с нуля\"\n",
    "\n",
    "\n",
    "def test_weeks():\n",
    "    \"tmin_weeks — 52 недели по 7 дней\"\n",
    "    assert isinstance(tmin_weeks, np.ndarray), f\"tmin_weeks — это {type(tmin_weeks).__name__}, а нужен массив\"\n",
    "    assert tmin_weeks.shape != (7, 52), \"получилось 7 строк по 52: в строке должна быть неделя\"\n",
    "    assert tmin_weeks.shape == (52, 7), f\"форма tmin_weeks — {tmin_weeks.shape}, а нужно (52, 7)\"\n",
    "    assert tmin_weeks[0].tolist() == tmin[:7].tolist(), \"первая строка должна быть первой неделей года\"\n",
    "\n",
    "_check(test_tmin, test_weeks, names=[\"tmin\",\"tmin_weeks\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "by-week-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "tmin = np.loadtxt(\"data/moscow_2025.csv\", delimiter=\",\", skiprows=1, usecols=1)\n",
    "tmin_weeks = tmin[:364].reshape(-1, 7)\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "by-week-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Вопрос.** Какая форма у `np.arange(24).reshape(-1, 6)`?\n",
    "\n",
    "- `(6, 4)`\n",
    "- `(4, 6)`\n",
    "- `(24, 6)`\n",
    "\n",
    "<details><summary>Ответ</summary>\n",
    "\n",
    "`(4, 6)`\n",
    "\n",
    "Строки по 6 элементов; 24 элемента делятся на 4 такие строки. `-1` превратилось в 4.\n",
    "\n",
    "</details>"
   ],
   "id": "quiz-59"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Обратно в ряд: ravel\n",
    "\n",
    "`ravel()` вытягивает таблицу обратно в одномерный массив — строка за строкой:"
   ],
   "id": "text-68"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Таблица → ряд\n",
    "table = np.arange(6).reshape(2, 3)\n",
    "print(table)\n",
    "print(table.ravel())"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "ravel"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 3. Снова ряд\n",
    "\n",
    "Превратите таблицу `tmin_weeks` обратно в одномерный массив `flat_tmin`. Проверьте себя: напечатайте\n",
    "`flat_tmin[:7]` и `tmin[:7]` — числа должны совпасть.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Метод `ravel()` без аргументов.\n",
    "\n",
    "</details>"
   ],
   "id": "flat-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "flat_tmin = ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "flat"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 3 — выполните после своего решения\n",
    "def test_flat():\n",
    "    \"flat_tmin — снова ряд из 364 значений\"\n",
    "    assert isinstance(flat_tmin, np.ndarray), f\"flat_tmin — это {type(flat_tmin).__name__}, а нужен массив\"\n",
    "    assert flat_tmin.ndim == 1, f\"у flat_tmin форма {flat_tmin.shape}, а нужен одномерный массив\"\n",
    "    assert flat_tmin.tolist() == tmin[:364].tolist(), \"значения должны идти в исходном порядке — первые 364 дня tmin\"\n",
    "\n",
    "_check(test_flat, names=[\"flat_tmin\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "flat-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "flat_tmin = tmin_weeks.ravel()\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "flat-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Повернуть таблицу: .T\n",
    "\n",
    "Атрибут `.T` — **транспонирование** (transpose): строки становятся столбцами, столбцы — строками. У таблицы\n",
    "52 × 7 после поворота форма 7 × 52: теперь строка — день недели:"
   ],
   "id": "text-81"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Недели в столбцах\n",
    "print(weeks.T.shape)\n",
    "print(weeks.T[0][:5])   # первые пять сред года"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "transpose"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Не путайте `.T` с `reshape` на «перевёрнутую» форму. Форма у них получается одна, а таблицы — разные:\n",
    "`reshape` перекладывает числа подряд, строка за строкой, а `.T` поворачивает таблицу — первая строка\n",
    "становится первым столбцом:"
   ],
   "id": "text-88"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# .T и reshape(3, 2) — не одно и то же\n",
    "small = np.arange(6).reshape(2, 3)\n",
    "print(small)\n",
    "print(small.T)\n",
    "print(small.reshape(3, 2))"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "t-vs-reshape"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 4. Дни недели строками\n",
    "\n",
    "Сохраните в `by_day` таблицу `tmin_weeks`, повёрнутую так, чтобы каждая строка была одним днём недели\n",
    "(форма 7 × 52). Затем сохраните в `thursdays` строку четвергов — это второй день в таблице, ведь год начался\n",
    "в среду.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Поворот таблицы — `.T` (это атрибут, без скобок).\n",
    "\n",
    "</details>\n",
    "<details><summary>Подсказка 2</summary>\n",
    "\n",
    "Среда — строка 0, четверг — строка 1.\n",
    "\n",
    "</details>"
   ],
   "id": "days-rows-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "by_day = ...\n",
    "thursdays = ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "days-rows"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 4 — выполните после своего решения\n",
    "def test_by_day():\n",
    "    \"by_day — 7 строк по 52 недели\"\n",
    "    assert isinstance(by_day, np.ndarray), f\"by_day — это {type(by_day).__name__}, а нужен массив\"\n",
    "    assert by_day.shape == (7, 52), f\"форма by_day — {by_day.shape}, а нужно (7, 52): поверните tmin_weeks\"\n",
    "    assert by_day[0].tolist() == tmin[0:364:7].tolist(), (\n",
    "        \"форма верная, но строка 0 — не все среды: reshape перекладывает числа подряд, а не поворачивает таблицу — нужен поворот (транспонирование)\"\n",
    "    )\n",
    "\n",
    "\n",
    "def test_thursdays():\n",
    "    \"thursdays — минимальные температуры всех четвергов\"\n",
    "    assert isinstance(thursdays, np.ndarray), f\"thursdays — это {type(thursdays).__name__}, а нужна строка by_day\"\n",
    "    assert thursdays.shape == (52,), f\"у thursdays форма {thursdays.shape}, а нужно 52 значения — одна строка by_day\"\n",
    "    assert thursdays.tolist() != tmin[0:364:7].tolist(), \"это среды, а нужны четверги\"\n",
    "    assert thursdays.tolist() == tmin[1:364:7].tolist(), \"это не четверги: год начался в среду, четверг — второй день недели\"\n",
    "\n",
    "_check(test_by_day, test_thursdays, names=[\"by_day\",\"thursdays\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "days-rows-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "by_day = tmin_weeks.T\n",
    "thursdays = by_day[1]\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "days-rows-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Итоги\n",
    "\n",
    "- `reshape(строки, столбцы)` раскладывает те же числа по новой форме, построчно; число элементов не меняется.\n",
    "- `-1` вместо одного размера — «посчитай сам».\n",
    "- `ravel()` вытягивает таблицу в одномерный массив.\n",
    "- `.T` меняет местами строки и столбцы.\n",
    "- `reshape`, `ravel` и `.T` по возможности дают представление (окно на те же данные), а не копию."
   ],
   "id": "text-103"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Подробнее в справочнике:** [numpy/reshape](https://ds-edu-trainer.vercel.app/reference/numpy/reshape) · [numpy/transpose](https://ds-edu-trainer.vercel.app/reference/numpy/transpose)"
   ],
   "id": "more"
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python"
  },
  "colab": {
   "provenance": []
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}