{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Первый массив\n",
    "\n",
    "Что такое массив NumPy, чем он отличается от списка и как одной строкой посчитать что-то для всех элементов сразу.\n",
    "\n",
    "Курс NumPy · урок `np-first-array` · [урок на сайте](https://ds-edu-trainer.vercel.app/courses/numpy/first-array).\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": [
    "Представьте прайс-лист маленькой кофейни: четыре позиции по 120, 80, 45 и 300 рублей. Вы решили сделать скидку\n",
    "10 % на всё. В обычном Python цены — это список, и новую цену приходится считать для каждого элемента отдельно:\n",
    "циклом или генератором списка. (Если последняя строка ячейки — просто выражение, без `print`, Jupyter и этот\n",
    "урок показывают его значение под ячейкой.)"
   ],
   "id": "text-9"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Скидка на список цен\n",
    "prices_list = [120, 80, 45, 300]\n",
    "[p * 0.9 for p in prices_list]"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "list-loop"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Работает, но с числами так приходится делать постоянно: каждая формула превращается в цикл. **NumPy**\n",
    "(Numerical Python) — библиотека, которая хранит числа в **массивах** (array) и умеет считать по всем элементам\n",
    "сразу. На ней построены pandas, scikit-learn, SciPy и почти весь анализ данных на Python.\n",
    "\n",
    "## Первый массив\n",
    "\n",
    "NumPy подключают под коротким именем `np` — так пишут почти во всех программах и в документации:"
   ],
   "id": "text-16"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Массив из списка\n",
    "import numpy as np\n",
    "\n",
    "prices = np.array([120, 80, 45, 300])\n",
    "prices"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "first"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`np.array` берёт список и делает из него массив. Последняя строка ячейки — просто `prices`, и Jupyter (как и\n",
    "этот урок) показывает её значение: `array([...])`. По такой записи сразу видно, что перед нами массив, а не\n",
    "список. `print` показывает тот же массив иначе:"
   ],
   "id": "text-26"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# print показывает массив без запятых\n",
    "print(prices)\n",
    "print(type(prices))"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "print"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Элементы через пробелы, без запятых — это не ошибка, так массив выглядит при печати. Тип массива называется\n",
    "`ndarray` (n-dimensional array, «n-мерный массив»): массивы бывают и двумерными, как таблица, — до них дойдём во\n",
    "втором модуле."
   ],
   "id": "text-32"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 1. Температуры за неделю\n",
    "\n",
    "Утренние температуры за неделю: 18, 21, 19, 25, 23, 17, 20 °C. Сохраните их в массив `temps`.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Сначала запишите числа списком в квадратных скобках, а потом передайте этот список в `np.array(...)`.\n",
    "\n",
    "</details>"
   ],
   "id": "temps-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "temps = ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "temps"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 1 — выполните после своего решения\n",
    "def test_array():\n",
    "    \"temps — массив NumPy\"\n",
    "    assert isinstance(temps, np.ndarray), f\"temps — это {type(temps).__name__}, а нужен массив — его создают из списка\"\n",
    "\n",
    "\n",
    "def test_values():\n",
    "    \"в temps семь температур по порядку\"\n",
    "    got = np.asarray(temps).tolist()\n",
    "    assert got == [18, 21, 19, 25, 23, 17, 20], f\"в temps сейчас {got}\"\n",
    "\n",
    "_check(test_array, test_values, names=[\"temps\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "temps-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "temps = np.array([18, 21, 19, 25, 23, 17, 20])\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "temps-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Действие со всем массивом сразу\n",
    "\n",
    "Главное, ради чего нужен NumPy: арифметика с массивом применяется к **каждому элементу**. Цикл при этом писать\n",
    "не нужно — он спрятан внутри NumPy и работает на скорости языка C."
   ],
   "id": "text-42"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Скидка 10 % на все цены\n",
    "prices * 0.9"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "discount"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Получился новый массив, а `prices` не изменился. Точки после чисел (`108.`) значат, что числа дробные: целые\n",
    "цены, умноженные на 0.9, стали дробными, и NumPy не пишет ноль после точки. Лишние пробелы (`108. ,`) — тоже не ошибка: NumPy\n",
    "выравнивает числа в столбик. Так же работают `+`, `-`, `/` и `**`\n",
    "(возведение в степень):"
   ],
   "id": "text-49"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Другие операции с числом\n",
    "print(prices + 50)   # доставка 50 ₽ к каждой позиции\n",
    "print(prices / 2)    # половина цены\n",
    "print(prices ** 2)   # квадрат каждого числа"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "more-ops"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 2. Градусы Фаренгейта\n",
    "\n",
    "Переведите температуры `temps` из градусов Цельсия в градусы Фаренгейта по формуле F = C × 9 / 5 + 32.\n",
    "Результат сохраните в `temps_f` — это должен быть массив той же длины.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Формулу можно написать прямо с массивом: там, где в ней стоит C, пишите `temps`.\n",
    "\n",
    "</details>\n",
    "<details><summary>Подсказка 2</summary>\n",
    "\n",
    "Умножение и деление выполняются раньше сложения, как в математике: скобки здесь не нужны.\n",
    "\n",
    "</details>"
   ],
   "id": "fahrenheit-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "temps_f = ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "fahrenheit"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 2 — выполните после своего решения\n",
    "def test_array():\n",
    "    \"temps_f — массив той же длины, что temps\"\n",
    "    assert isinstance(temps_f, np.ndarray), f\"temps_f — это {type(temps_f).__name__}, а нужен массив: формула с массивом даёт массив\"\n",
    "    assert len(temps_f) == 7, f\"в temps_f {len(temps_f)} чисел, а температур 7\"\n",
    "\n",
    "\n",
    "def test_values():\n",
    "    \"значения переведены по формуле F = C × 9 / 5 + 32\"\n",
    "    got = np.asarray(temps_f, dtype=float)\n",
    "    assert not np.allclose(got, [90.0, 95.4, 91.8, 102.6, 99.0, 88.2, 93.6]), \"похоже, 32 прибавлено до умножения: вспомните порядок действий в формуле\"\n",
    "    assert np.allclose(got, [64.4, 69.8, 66.2, 77.0, 73.4, 62.6, 68.0]), f\"получилось {np.round(got, 1).tolist()}, а 18 °C — это 64.4 °F\"\n",
    "\n",
    "_check(test_array, test_values, names=[\"temps_f\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "fahrenheit-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "temps_f = temps * 9 / 5 + 32\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "fahrenheit-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Список ведёт себя иначе\n",
    "\n",
    "У обычного списка те же знаки означают совсем другое: `*` повторяет список, а `+` склеивает два списка."
   ],
   "id": "text-64"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Одна операция — разный результат\n",
    "print(prices_list * 2)\n",
    "print(prices * 2)"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "list-times"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "А умножить список на дробное число Python не может вовсе:"
   ],
   "id": "text-70"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Список на 0.9 не умножается\n",
    "# Эта ячейка показывает ошибку TypeError: она перехвачена, чтобы «Выполнить всё» не останавливалось.\n",
    "try:\n",
    "    prices_list * 0.9\n",
    "except Exception as error:\n",
    "    print(f\"{type(error).__name__}: {error}\")"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "list-float"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Типичная ошибка: список вместо массива.**\n",
    ">\n",
    "> Если забыть `np.array` и считать со списком, ошибки может и не быть: `prices_list * 2` молча вернёт список\n",
    "> двойной длины. Когда результат выглядит странно, проверьте, что у вас в руках: `type(x)` покажет\n",
    "> `numpy.ndarray` для массива и `list` для списка."
   ],
   "id": "component-75"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Вопрос.** Что получится, если сложить два **списка**: `[1, 2, 3] + [10, 20, 30]`?\n",
    "\n",
    "- `[11, 22, 33]`\n",
    "- `[1, 2, 3, 10, 20, 30]`\n",
    "- ошибка `TypeError`\n",
    "\n",
    "<details><summary>Ответ</summary>\n",
    "\n",
    "`[1, 2, 3, 10, 20, 30]`\n",
    "\n",
    "`+` у списков склеивает их в один. Поэлементное сложение, `[11, 22, 33]`, получится у массивов — об этом следующий урок.\n",
    "\n",
    "</details>"
   ],
   "id": "quiz-81"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 3. Новые цены\n",
    "\n",
    "Кофейня поднимает все цены из `prices` на 10 % и прибавляет к каждой 20 ₽ за стаканчик. Сохраните новые цены\n",
    "в массив `new_prices`. Сам `prices` не меняйте — он ещё пригодится.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Поднять цену на 10 % — значит умножить её на 1.1.\n",
    "\n",
    "</details>\n",
    "<details><summary>Подсказка 2</summary>\n",
    "\n",
    "Сначала умножение, потом сложение: скобки не нужны.\n",
    "\n",
    "</details>"
   ],
   "id": "new-prices-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "new_prices = ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "new-prices"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 3 — выполните после своего решения\n",
    "def test_array():\n",
    "    \"new_prices — массив из четырёх цен\"\n",
    "    assert isinstance(new_prices, np.ndarray), f\"new_prices — это {type(new_prices).__name__}, а нужен массив: считайте от массива prices\"\n",
    "    assert len(new_prices) == 4, f\"в new_prices {len(new_prices)} чисел, а цен 4\"\n",
    "\n",
    "\n",
    "def test_values():\n",
    "    \"цены подняты на 10 %, к каждой прибавлено 20 ₽\"\n",
    "    got = np.asarray(new_prices, dtype=float)\n",
    "    assert not np.allclose(got, [154, 110, 71.5, 352]), \"похоже, 20 ₽ прибавлены до повышения: сначала повышение на 10 %, потом надбавка\"\n",
    "    assert not np.allclose(got, [32, 28, 24.5, 50]), \"умножение на 0.1 даёт 10 % от цены, а нужна цена плюс 10 % — то есть 110 % цены\"\n",
    "    assert np.allclose(got, [152, 108, 69.5, 350]), f\"получилось {np.round(got, 2).tolist()}, а позиция за 120 ₽ должна стоить 152 ₽\"\n",
    "\n",
    "\n",
    "def test_prices_kept():\n",
    "    \"prices не изменился\"\n",
    "    assert np.asarray(prices).tolist() == [120, 80, 45, 300], (\n",
    "        \"массив prices изменился — новые цены нужно сохранить в new_prices. Чтобы вернуть prices, выполните ячейку \"\n",
    "        \"«Массив из списка» ещё раз или нажмите «Перезапустить»\"\n",
    "    )\n",
    "\n",
    "_check(test_array, test_values, test_prices_kept, names=[\"new_prices\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "new-prices-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "new_prices = prices * 1.1 + 20\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "new-prices-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Вопрос.** Какой массив получится: `np.array([10, 20]) / 4`?\n",
    "\n",
    "- `array([2, 5])`\n",
    "- `array([2.5, 5. ])`\n",
    "- ошибка: 10 не делится на 4 нацело\n",
    "\n",
    "<details><summary>Ответ</summary>\n",
    "\n",
    "`array([2.5, 5. ])`\n",
    "\n",
    "Деление `/` в NumPy, как и в Python, всегда даёт дробные числа. `5.` — это 5.0: ноль после точки NumPy не пишет.\n",
    "\n",
    "</details>"
   ],
   "id": "quiz-99"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 4. Секунды в минуты\n",
    "\n",
    "Длительность пяти треков в секундах: 185, 240, 210, 330, 150. Создайте массив `seconds` с этими числами, а потом\n",
    "массив `minutes` — те же длительности в минутах.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "В минуте 60 секунд: чтобы получить минуты, секунды делят на 60.\n",
    "\n",
    "</details>"
   ],
   "id": "minutes-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "seconds = ...\n",
    "minutes = ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "minutes"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 4 — выполните после своего решения\n",
    "def test_seconds():\n",
    "    \"seconds — массив из пяти длительностей\"\n",
    "    assert isinstance(seconds, np.ndarray), f\"seconds — это {type(seconds).__name__}, а нужен массив — создайте его из списка\"\n",
    "    got = np.asarray(seconds).tolist()\n",
    "    assert got == [185, 240, 210, 330, 150], f\"в seconds сейчас {got}\"\n",
    "\n",
    "\n",
    "def test_minutes():\n",
    "    \"minutes — те же длительности в минутах\"\n",
    "    assert isinstance(minutes, np.ndarray), f\"minutes — это {type(minutes).__name__}, а нужен массив: арифметика с массивом даёт массив\"\n",
    "    got = np.asarray(minutes, dtype=float)\n",
    "    assert not np.allclose(got, [11100, 14400, 12600, 19800, 9000]), \"вы умножили на 60, а секунды в минуты переводят делением\"\n",
    "    assert np.allclose(got, [185 / 60, 4, 3.5, 5.5, 2.5]), f\"получилось {np.round(got, 2).tolist()}, а 240 секунд — это 4 минуты\"\n",
    "\n",
    "_check(test_seconds, test_minutes, names=[\"seconds\",\"minutes\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "minutes-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "seconds = np.array([185, 240, 210, 330, 150])\n",
    "minutes = seconds / 60\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "minutes-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Итоги\n",
    "\n",
    "- NumPy подключают так: `import numpy as np`.\n",
    "- `np.array(список)` создаёт массив. Значение ячейки выглядит как `array([...])`, а `print` показывает элементы\n",
    "  без запятых.\n",
    "- Арифметика с числом (`+ - * / **`) применяется к каждому элементу и даёт новый массив — без циклов.\n",
    "- У списков те же знаки значат другое: `*` повторяет список, `+` склеивает."
   ],
   "id": "text-115"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Подробнее в справочнике:** [numpy/intro](https://ds-edu-trainer.vercel.app/reference/numpy/intro) · [numpy/creation](https://ds-edu-trainer.vercel.app/reference/numpy/creation) · [numpy/arithmetic](https://ds-edu-trainer.vercel.app/reference/numpy/arithmetic)"
   ],
   "id": "more"
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python"
  },
  "colab": {
   "provenance": []
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}