{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Срез — это окно\n",
    "\n",
    "Срез не копирует данные, а смотрит на тот же массив — изменив срез, вы меняете исходник. Когда это удобно, когда опасно и как сделать копию.\n",
    "\n",
    "Курс NumPy · урок `np-views` · [урок на сайте](https://ds-edu-trainer.vercel.app/courses/numpy/views).\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": [
    "У списков Python срез — это **копия**: изменили кусок — исходный список цел. У массивов NumPy иначе, и это\n",
    "одна из самых частых неожиданностей для новичков.\n",
    "\n",
    "## Срез смотрит на тот же массив\n",
    "\n",
    "Срез массива — это **представление** (view): окно, через которое видны те же самые данные. Своих данных у\n",
    "него нет. Поэтому изменение среза меняет исходный массив:"
   ],
   "id": "text-9"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Изменили срез — изменился массив\n",
    "import numpy as np\n",
    "\n",
    "prices = np.array([100.0, 250.0, 80.0, 40.0])\n",
    "first = prices[:2]\n",
    "first[0] = 0\n",
    "print(first)\n",
    "print(prices)"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "view"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`first` и `prices` — два взгляда на одну память. Для сравнения — список:"
   ],
   "id": "text-19"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# А у списка срез — копия\n",
    "price_list = [100.0, 250.0, 80.0, 40.0]\n",
    "part = price_list[:2]\n",
    "part[0] = 0\n",
    "print(part)\n",
    "print(price_list)"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "list-copy"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Зачем так сделано: массивы бывают огромными (миллионы чисел), и копировать данные при каждом срезе было бы\n",
    "медленно и расточительно. Представление создаётся мгновенно, сколько бы элементов в нём ни было."
   ],
   "id": "text-23"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Типичная ошибка: «я поменял только кусок».**\n",
    ">\n",
    "> Если вы взяли срез, чтобы поэкспериментировать, и изменили его, — исходный массив изменился тоже. Ошибки нет,\n",
    "> просто данные тихо испортились. Правило: срез, который вы собираетесь менять, а исходник беречь, нужно\n",
    "> скопировать. Привычное для списков `lst[:]` у массива тоже даёт окно, а не копию."
   ],
   "id": "component-27"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Копия: copy()\n",
    "\n",
    "Метод `copy()` создаёт настоящую копию со своими данными. Её можно менять как угодно:"
   ],
   "id": "text-32"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Копия не трогает исходник\n",
    "prices = np.array([100.0, 250.0, 80.0, 40.0])\n",
    "first = prices[:2].copy()\n",
    "first[0] = 0\n",
    "print(first)\n",
    "print(prices)"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "copy"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В заготовке ниже встретится запись `sale[:] = sale * 0.5` — присваивание **в** срез: новые значения\n",
    "записываются в те же ячейки памяти, на которые смотрит `sale`. Подробнее о ней — чуть ниже."
   ],
   "id": "text-38"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 1. Скидка без порчи прайса\n",
    "\n",
    "В `prices` — цены четырёх товаров. Сделайте массив `sale` — цены **первых двух** товаров со скидкой 50 %,\n",
    "а `prices` оставьте как был. В заготовке уже есть код, но он портит `prices` — исправьте его.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Код меняет срез `prices[:2]` прямо в исходном массиве.\n",
    "\n",
    "</details>\n",
    "<details><summary>Подсказка 2</summary>\n",
    "\n",
    "Скопируйте срез, прежде чем менять: `prices[:2].copy()`.\n",
    "\n",
    "</details>"
   ],
   "id": "sale-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "prices = np.array([100.0, 250.0, 80.0, 40.0])\n",
    "sale = prices[:2]\n",
    "sale[:] = sale * 0.5"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "sale"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 1 — выполните после своего решения\n",
    "def test_sale():\n",
    "    \"sale — первые два товара за полцены\"\n",
    "    assert isinstance(sale, np.ndarray), f\"sale — это {type(sale).__name__}, а нужен массив\"\n",
    "    assert sale.tolist() == [50.0, 125.0], f\"в sale {sale.tolist()} — это не первые два товара за полцены\"\n",
    "\n",
    "\n",
    "def test_prices_kept():\n",
    "    \"prices не изменился\"\n",
    "    assert prices.tolist() == [100.0, 250.0, 80.0, 40.0], (\n",
    "        f\"prices изменился: {prices.tolist()} — sale смотрит на те же данные. Сделайте копию среза\"\n",
    "    )\n",
    "\n",
    "_check(test_sale, test_prices_kept)"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "sale-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "prices = np.array([100.0, 250.0, 80.0, 40.0])\n",
    "sale = prices[:2].copy()\n",
    "sale[:] = sale * 0.5\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "sale-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Вопрос.** Что напечатает этот код?\n",
    "\n",
    "```python\n",
    "a = np.array([1, 2, 3, 4])\n",
    "b = a[1:3]\n",
    "b[0] = 99\n",
    "print(a)\n",
    "```\n",
    "\n",
    "- `[1 2 3 4]`\n",
    "- `[ 1 99  3  4]`\n",
    "- `[99  2  3  4]`\n",
    "\n",
    "<details><summary>Ответ</summary>\n",
    "\n",
    "`[ 1 99  3  4]`\n",
    "\n",
    "`b` — окно на элементы `a` с индексами 1 и 2. `b[0]` — это `a[1]`, поэтому в `a` двойка меняется на 99.\n",
    "\n",
    "</details>"
   ],
   "id": "quiz-50"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Когда представление — то, что нужно\n",
    "\n",
    "Бывает, что изменить часть исходника и нужно. Тогда представление удобно: дали ему короткое имя — и меняете\n",
    "через него:"
   ],
   "id": "text-66"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Обнулить выходные в плане\n",
    "week_plan = np.full(7, 100)\n",
    "weekend = week_plan[5:]   # суббота и воскресенье\n",
    "weekend[:] = 0\n",
    "print(week_plan)"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "useful"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Типичная ошибка: v = v * 1.1 не меняет исходник.**\n",
    ">\n",
    "> Присваивание `v = …` не меняет данные, а даёт имени `v` новый массив — результат умножения. Старое окно\n",
    "> забыто, исходный массив остался прежним. Менять данные через представление можно только присваиванием **в**\n",
    "> него: `v[:] = …` или `v[0] = …`."
   ],
   "id": "component-74"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 2. Премия второму кварталу\n",
    "\n",
    "В `plan` — план продаж по 12 месяцам. Через представление `q2` (месяцы с индексами 3, 4, 5 — второй квартал)\n",
    "увеличьте план второго квартала на 10 %, чтобы изменился и сам `plan`.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "`q2 = plan[3:6]` — окно на три месяца.\n",
    "\n",
    "</details>\n",
    "<details><summary>Подсказка 2</summary>\n",
    "\n",
    "Чтобы изменить данные на месте, присваивайте в срез: `q2[:] = q2 * 1.1`. Простое `q2 = q2 * 1.1` создаст новый массив и `plan` не тронет.\n",
    "\n",
    "</details>"
   ],
   "id": "bonus-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "plan = np.array([100.0, 110.0, 120.0, 150.0, 160.0, 170.0, 130.0, 120.0, 140.0, 150.0, 160.0, 200.0])\n",
    "q2 = ...\n",
    "# увеличьте q2 на 10 % так, чтобы изменился plan"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "bonus"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 2 — выполните после своего решения\n",
    "def test_plan():\n",
    "    \"в plan второй квартал увеличен на 10 %\"\n",
    "    got = np.asarray(plan, dtype=float)\n",
    "    assert not np.allclose(got[3:6], [150, 160, 170]), (\n",
    "        \"plan не изменился: если присвоить переменной q2 результат умножения, это новый массив, а не окно на plan — записывайте значения в сам срез\"\n",
    "    )\n",
    "    assert np.allclose(got[3:6], [165, 176, 187]), f\"второй квартал в plan — {np.round(got[3:6], 1).tolist()}, а должен вырасти на 10 %\"\n",
    "\n",
    "\n",
    "def test_rest():\n",
    "    \"остальные месяцы не изменились\"\n",
    "    got = np.asarray(plan, dtype=float)\n",
    "    assert np.allclose(got[:3], [100, 110, 120]) and np.allclose(got[6:], [130, 120, 140, 150, 160, 200]), (\n",
    "        f\"изменились не только месяцы 3–5: {np.round(got, 1).tolist()}\"\n",
    "    )\n",
    "\n",
    "_check(test_plan, test_rest, names=[\"q2\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "bonus-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "plan = np.array([100.0, 110.0, 120.0, 150.0, 160.0, 170.0, 130.0, 120.0, 140.0, 150.0, 160.0, 200.0])\n",
    "q2 = plan[3:6]\n",
    "q2[:] = q2 * 1.1\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "bonus-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 3. Резервная копия\n",
    "\n",
    "Прежде чем обнулить в `scores` всё после третьего элемента, сохраните полную резервную копию в `backup`, затем\n",
    "обнулите элементы начиная с индекса 3. `backup` должен остаться прежним.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Копию делайте до изменения: `backup = scores.copy()`.\n",
    "\n",
    "</details>\n",
    "<details><summary>Подсказка 2</summary>\n",
    "\n",
    "Обнулить хвост — `scores[3:] = 0`.\n",
    "\n",
    "</details>"
   ],
   "id": "backup-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "scores = np.array([12, 15, 9, 20, 17, 11])\n",
    "backup = ...\n",
    "# обнулите scores начиная с индекса 3"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "backup"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 3 — выполните после своего решения\n",
    "def test_scores():\n",
    "    \"в scores обнулено всё начиная с индекса 3\"\n",
    "    assert scores.tolist() == [12, 15, 9, 0, 0, 0], f\"scores = {scores.tolist()}, а обнулить нужно всё начиная с индекса 3, остальное не трогать\"\n",
    "\n",
    "\n",
    "def test_backup():\n",
    "    \"backup — прежние значения\"\n",
    "    assert isinstance(backup, np.ndarray), f\"backup — это {type(backup).__name__}, а нужна копия массива\"\n",
    "    assert backup.tolist() != [12, 15, 9, 0, 0, 0], \"backup тоже обнулился: присваивание и срез — не копии, а окна на тот же массив; нужна настоящая копия, и до изменения\"\n",
    "    assert backup.tolist() == [12, 15, 9, 20, 17, 11], f\"backup = {backup.tolist()}, а должен хранить исходные значения\"\n",
    "\n",
    "_check(test_scores, test_backup, names=[\"backup\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "backup-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "scores = np.array([12, 15, 9, 20, 17, 11])\n",
    "backup = scores.copy()\n",
    "scores[3:] = 0\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "backup-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Итоги\n",
    "\n",
    "- Срез массива — представление: те же данные, изменение видно в исходнике.\n",
    "- `copy()` — независимая копия; нужна, если срез будете менять, а исходник беречь.\n",
    "- Менять данные через представление — присваиванием в него (`v[:] = …`); `v = …` просто даёт имени новый массив.\n",
    "- Подробнее о том, что даёт представление, а что копию, — в справочнике; например, выборка по маске (модуль 4)\n",
    "  всегда копия."
   ],
   "id": "text-95"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Подробнее в справочнике:** [numpy/views-copies](https://ds-edu-trainer.vercel.app/reference/numpy/views-copies)"
   ],
   "id": "more"
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python"
  },
  "colab": {
   "provenance": []
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}