Pr01_Numpy_ipynb_5491_Belozerov.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Копия блокнота \"Pr01_Numpy.ipynb\"",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-JUOp2KEdHTn"
      },
      "source": [
        "# Numpy\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oTtiG3HMz-Rt"
      },
      "source": [
        "Numpy - это библиотека для математических вычислений. Написана на языке С, поэтому считается наиболее предпочтительным вариантом при работе с многомерными массивами из-за производительности.\n",
        "\n",
        "[Официальный сайт](https://numpy.org/doc/stable/) последней версии.\n",
        "\n",
        "Начало работы с `numpy` заключается в подключении модуля. При этом в практике применения есть уже общепринятое сокращение для него под названием `np`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2HARN7afZ1Fk"
      },
      "source": [
        "import numpy as np"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "81-wHdEbg-qI"
      },
      "source": [
        "> Если вы ранее работали с MATLAB, обратите внимание, как некоторые подходы и функции схожи."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "woHgRbgPZ99s"
      },
      "source": [
        "# Создание массивов"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DVVfQ6DwaBUH"
      },
      "source": [
        "Для того, чтобы начать работать с `numpy`, мы должны научиться создавать объекты `ndarray`, которые по сути являются N-мерными массивами."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kQqPek1xZ2y7"
      },
      "source": [
        "# Самый просто способ создать массив numpy - взять уже существующий list и передать в функцию np.array()\n",
        "arr_1d = np.array([1, 2, 3])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7thycVOKbCJ7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d8110a33-367d-4d7f-b333-45f3175c1e58"
      },
      "source": [
        "# Теперь проверим \n",
        "#   - тип объекта c помощью функции type()\n",
        "#   - размерность с помощью аттрибута .shape\n",
        "#   - доступ по индексам, как у обычного list\n",
        "\n",
        "# Для отладки можно выводить небольшие массивы прямо через print()\n",
        "\n",
        "print(arr_1d)\n",
        "print(type(arr_1d))\n",
        "print(arr_1d.shape)\n",
        "print(arr_1d[0])\n",
        "print(arr_1d[2])\n",
        "print(arr_1d[-1])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1 2 3]\n",
            "<class 'numpy.ndarray'>\n",
            "(3,)\n",
            "1\n",
            "3\n",
            "3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "90qAyGF8bLLs"
      },
      "source": [
        "> Обратите внимание, индекс с отрицательным значением означает индексацию с конца. Это возможность языка Python. В данном случае индекс -1 ~ 2, так как 2 - последний индекс в массиве из трех элементов. Аналогично, если хотите взять второй элемент с конца, то можете использовать индекс -2 и т.д."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GlDZi0V_bijd"
      },
      "source": [
        "Как видите, объект имеет тип `np.ndarray`, таким образом описываются все массивы при работе с numpy. Размерность представляет собой кортеж с одним элементом (создали 1D массив ~ массив первого ранга в терминах numpy)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WfMA2hmgcPFH"
      },
      "source": [
        "# Теперь создадим двумерный массив с помощью тех же list\n",
        "arr_2d = np.array([[1, 2, 3], [4, 5, 6]])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ljaLlNS2cdvd",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "90218dcc-5cbb-44d6-8445-5a91eaeda979"
      },
      "source": [
        "# Проверим также тип, размерность и доступ по индексам\n",
        "\n",
        "print(arr_2d)\n",
        "print(type(arr_2d))\n",
        "print(arr_2d.shape)\n",
        "print(arr_2d[0, 0])\n",
        "print(arr_2d[1, 2])\n",
        "print(arr_2d[1, 0])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[1 2 3]\n",
            " [4 5 6]]\n",
            "<class 'numpy.ndarray'>\n",
            "(2, 3)\n",
            "1\n",
            "6\n",
            "4\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wQKPgHh7cOlh"
      },
      "source": [
        "Теперь видно, что в кортеже размерности стало два элемента, при этом тип объекта никак не поменялся.\n",
        "\n",
        "Индексация в 2D массиве делается уже посредством двух индексов:\n",
        "- первый индекс - номер ряда (строки);\n",
        "- второй индекс - номер колонки (столбца).\n",
        "\n",
        "> В 1D массивах вообще никаких вопросов не возникает, в 2D (ряд, колонка), если разворачивать до 3D массивов, то можно интерпретировать как (ряд, колонка, глубина). Дальнейшие размерности уже сложнее в визуальной интерпретации, поэтому вместо названий для каждой размерности идет просто индексация."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zeUwMz9aem4U"
      },
      "source": [
        "Помимо способов создания массивов из уже существующих представлений в виде `list`, можно также создавать массивы по-другому. Рассмотрим некоторые из них:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "W8EnLNXlf6HW",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ed2e2456-31a4-49dd-ecf3-59a4cd73dae2"
      },
      "source": [
        "# Создание массива фиксированного размера\n",
        "np.ndarray((5, 3))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1.60712203e-316, 1.01855798e-312, 1.03977794e-312],\n",
              "       [9.54898106e-313, 1.14587773e-312, 1.03977794e-312],\n",
              "       [1.23075756e-312, 1.08221785e-312, 1.01855798e-312],\n",
              "       [9.76118064e-313, 1.18831764e-312, 1.01855798e-312],\n",
              "       [1.12465777e-312, 4.44659081e-322, 0.00000000e+000]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IAHEQ5N2gUP_"
      },
      "source": [
        "В представленном способе мы напрямую вызываем конструктор и передаем ему размерность. Какими числами будет заполнен массив - никто не знает. Вероятнее всего, это будут нули, но для уверенности лучше самостоятельно заполнить такой массив данными."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "U4fnZoDMgJc6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d59ba68a-abc8-4771-c2b6-2848a79c76fd"
      },
      "source": [
        "# Явное создание массива нулей\n",
        "np.zeros((2, 3))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0., 0., 0.],\n",
              "       [0., 0., 0.]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AaJSBHSdgtCY",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9e5a9a44-118a-4e8a-bb7b-9371b74f6e80"
      },
      "source": [
        "# Явное создание массива единиц\n",
        "np.ones((3, 2))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1., 1.],\n",
              "       [1., 1.],\n",
              "       [1., 1.]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8_elMSoK7wQL",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3b3903f5-fcae-4670-b825-7c0b3f33d22f"
      },
      "source": [
        "# Создание массива, заполненного константным значением\n",
        "np.full((3, 4), 5)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[5, 5, 5, 5],\n",
              "       [5, 5, 5, 5],\n",
              "       [5, 5, 5, 5]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iNN2C908gwUB",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6171328d-b4df-42ac-963f-99ab199b484b"
      },
      "source": [
        "# 2D массив с единичной главной диагональю\n",
        "# (*) В этой функции размерность задается не кортежем, а отдельными аргументами\n",
        "np.eye(3, 2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1., 0.],\n",
              "       [0., 1.],\n",
              "       [0., 0.]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "x8cGz7nIhbbE",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ee1139b1-4207-4637-90f8-043069a795f6"
      },
      "source": [
        "# Создание массива нулей с такой же размерностью, как уже существующий\n",
        "arr_2d = np.array([[1, 2, 3], [4, 5, 6]])\n",
        "\n",
        "np.zeros_like(arr_2d)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0, 0, 0],\n",
              "       [0, 0, 0]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BqDTBiWzhj9R",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f2e7cc89-d930-4999-eb9f-1eeae4dfc230"
      },
      "source": [
        "# Создание массива единиц с такой же размерностью, как уже существующий\n",
        "arr_2d = np.array([[1, 2, 3], [4, 5, 6]])\n",
        "\n",
        "np.ones_like(arr_2d)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1, 1, 1],\n",
              "       [1, 1, 1]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MOqhVLYL7flG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0ee9e0ec-4ba3-4e56-9b16-3a4ae01b88ce"
      },
      "source": [
        "# Создание массива со случайными значениями в интервале [0; 1.0)\n",
        "np.random.random((2,2))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0.09089635, 0.80715979],\n",
              "       [0.97347748, 0.14446413]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PwWoeq26zmFm",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ac6874b2-615e-4e88-86cf-f022e7a0688f"
      },
      "source": [
        "# Аналог функции range\n",
        "np.arange(start=1, stop=10, step=1.5)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1. , 2.5, 4. , 5.5, 7. , 8.5])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "adlhJ7Hnz-z9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fcb6be98-30ad-4dc7-99bd-7c7f9e7e0a5a"
      },
      "source": [
        "# Также создание диапазона значений, но уже с заданием количества элементов\n",
        "# (*) stop уже входит в создаваемый диапазон\n",
        "np.linspace(start=1, stop=2, num=10)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1.        , 1.11111111, 1.22222222, 1.33333333, 1.44444444,\n",
              "       1.55555556, 1.66666667, 1.77777778, 1.88888889, 2.        ])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S-szHgm6hq7X"
      },
      "source": [
        "# Хитрая индексация"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LYFlLDO5huxy"
      },
      "source": [
        "Индексация в Python не ограничивается заданием конкретных индексов для получения значений в контейнерах (стандартных или массивов `ndarray`). Существуют специальные символы и подходы для работы с диапазонами данных, которые не только упрощают и улучшают код, но и выполняются более быстро, нежели проходы по массивам циклом.\n",
        "\n",
        "Начнем со знакомства с символом `:`, который позволяет задавать диапазон индексов для чтения/записи контейнеров."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9UClHM52huJi"
      },
      "source": [
        "# Для начала на простом списке (1D массива)\n",
        "# Следующее создание массива можно заменить list(range(1, 11))\n",
        "arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eltg4vei7P2R",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3e1ad358-5704-4b6e-8f85-c0f5866526fe"
      },
      "source": [
        "# Простая индексация\n",
        "print(arr[0])\n",
        "print(arr[-2])\n",
        "print(arr[5])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "9\n",
            "6\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dzWHdiZw8GlN"
      },
      "source": [
        "Для получения подмассива (части массива) или записи в подмассив используется нотация $$index_{start}:index_{end}:step$$\n",
        "\n",
        "- $index_{start}$ - индекс начала подмассива\n",
        "- $index_{end}$ - индекс конца подмассива\n",
        "- $step$ - шаг подмассива"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w3x1hjul7ZnM",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2e214f64-db2a-40af-842b-bd0c31265281"
      },
      "source": [
        "# Получение части массива от 2го элемента до 6го (не включительно) \n",
        "#   с шагом 2 \n",
        "print(arr[2:8:2])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[3, 5, 7]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UeghJuRp9XSG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5492c54d-4c66-4e0d-b6dc-54229a02bf72"
      },
      "source": [
        "# Если шаг не задан, то он равен единице (при этом второй раз : не пишется)\n",
        "print(arr[2:8])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[3, 4, 5, 6, 7, 8]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "f2et5vq_9YQ0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "68ebf315-f4f6-451f-9d4d-29418c29d040"
      },
      "source": [
        "# Шаг может быть и отрицательным (индексы меняются местами)\n",
        "print(arr[8:2:-1])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[9, 8, 7, 6, 5, 4]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "THxAw6mR9ZK1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5d73edb0-d17f-4751-c1fe-de84427887ce"
      },
      "source": [
        "# Если не задавать index_start или index_end, \n",
        "#   то они будут равны индексу начала и конца массива\n",
        "print(arr[2:])\n",
        "print(arr[:8])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[3, 4, 5, 6, 7, 8, 9, 10]\n",
            "[1, 2, 3, 4, 5, 6, 7, 8]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ti3t0ZVa9gfe",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "96278f6e-dedd-4580-b7d8-8ed75458624d"
      },
      "source": [
        "# Можно комбинировать один из индексов и шаг\n",
        "print(arr[2::2])\n",
        "print(arr[:8:3])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[3, 5, 7, 9]\n",
            "[1, 4, 7]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xj257QBQ-LsQ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9c93f43e-3866-402c-fc52-0d72c003d3d5"
      },
      "source": [
        "# И не забываем, что все трюки работают и на запись\n",
        "new_arr = list(range(1, 11))\n",
        "\n",
        "new_arr[1:5] = arr[:4]\n",
        "print(new_arr)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1, 1, 2, 3, 4, 6, 7, 8, 9, 10]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UiQHCjYPAreX",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0b01c00f-9e89-431d-b45c-8cd06b1ece77"
      },
      "source": [
        "# Не самая полезная, но все же запись (получить весь диапазон)\n",
        "print(arr[:])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y1CX7Bpi91aI"
      },
      "source": [
        "## Задание\n",
        "\n",
        "Объясните результат операции:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HRS-xvPK97di",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b8feb69c-487e-46d5-c9a3-2f485da501db"
      },
      "source": [
        "print(arr[:5:-2])\r\n",
        "# \"-\"значит мы бежим с конца массива\r\n",
        "# начинаем с конечного элемента индекс 9 (значение 10) \r\n",
        "# затем индекс 9-2=7 (значение 8), затем индекс 5 (однако по синтаксу языка последний индекс не берем)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[10, 8]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CmTGLk0n_K8w"
      },
      "source": [
        "## Задание\n",
        "\n",
        "Получите перевернутый список:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7XJaNnuf_TUl",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a2731f3b-9081-4f02-995a-08f7ea43f2d3"
      },
      "source": [
        "data = list(range(10))\n",
        "print(data)\n",
        "\n",
        "# TODO - [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]\n",
        "new = list(range(0,9))\n",
        "new[:8]=data[9:0:-1]\n",
        "new[9]=0\n",
        "print(new)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
            "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TT3t4yG5B8XW"
      },
      "source": [
        "## Задание\n",
        "\n",
        "Получите массив без первого и двух последних элементов:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "evJXMrHrCFFj",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7da4e7a3-f82c-44fd-fee8-a0b4f92494ac"
      },
      "source": [
        "data = list(range(10))\n",
        "print(data)\n",
        "\n",
        "\n",
        "new_arr=data[1:8]\n",
        "print(new_arr)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
            "[1, 2, 3, 4, 5, 6, 7]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yr_Sgpxeg7nG"
      },
      "source": [
        "# Хитрая индексация в матрицах"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4vzYWeA1_nL4"
      },
      "source": [
        "Работа с одномерными списками удобна даже через класс `list`, но 2D массивы уже удобнее использовать через библиотеку numpy. Использование numpy никак не ограничивает применение такой индексации, так что можно делать много классных штук:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "roSKMhOd_7HG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "96155d15-76a2-477b-9c01-7cb77777fda7"
      },
      "source": [
        "arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])\n",
        "print(arr)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 1  2  3  4]\n",
            " [ 5  6  7  8]\n",
            " [ 9 10 11 12]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bw7Re8l_ASG0"
      },
      "source": [
        "В индексации numpy есть очень полезное правило: если последующие индексы не заданы, то они принимаются как \"весь диапазон\". Например, в двумерном массиве мы индексируем по двум числам $[3, 2]$. Если в 2D массиве задать индекс $[3]$, то это эквивалентно индексации $[3, :]$, то есть третий ряд, все колонки.\n",
        "\n",
        "В плане предшествующих индексов это не работает, поэтому, чтобы получить целую колонку, надо индексировать $[:, 2]$."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KhiA2r2-AK5d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "200a8a45-159a-44ce-c838-657eadc0b8c4"
      },
      "source": [
        "# Получим вторую строку массива\n",
        "print(arr[2])\n",
        "print(arr[2, :])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[ 9 10 11 12]\n",
            "[ 9 10 11 12]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dF2bEK7dBU5C",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4702eb85-7ed4-4fa2-be51-0079b7e026ef"
      },
      "source": [
        "# Получим первую колонку массива\n",
        "print(arr[:, 1])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[ 2  6 10]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MjkcYLIUBoIZ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9551a462-9d01-4706-9ac5-ffbaec00cb0d"
      },
      "source": [
        "# Получить первые два элемента (первые две колонки) первого ряда\n",
        "print(arr[1, :2])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[5 6]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nsjlZWVkC4JV",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1e9f2728-d324-4f1b-836c-407b703e0eee"
      },
      "source": [
        "# Можно повторять целые части массива\n",
        "#   (но при этом должны соотноситься размерности)\n",
        "# ndarray.copy() - функция копирования массива\n",
        "# Копируем, чтобы не изменить оригинальный\n",
        "new_arr = arr.copy()\n",
        "print(arr)\n",
        "\n",
        "new_arr[2, :] = arr[1, :]\n",
        "print(new_arr)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 1  2  3  4]\n",
            " [ 5  6  7  8]\n",
            " [ 9 10 11 12]]\n",
            "[[1 2 3 4]\n",
            " [5 6 7 8]\n",
            " [5 6 7 8]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Cok9ET1xDpHL",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "709461ff-b302-42a5-fb5f-98904c3f94c7"
      },
      "source": [
        "# При этом, такая индексация - это новый массив со своей размерностью.\n",
        "print(arr[:2, :2])\n",
        "print(arr[:2, :2].shape)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[1 2]\n",
            " [5 6]]\n",
            "(2, 2)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cc0YJBmSEDlb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2018d7f5-1bbd-4072-b64d-094727bea253"
      },
      "source": [
        "# В качестве индексов можно также задавать другие массивы\n",
        "# Получаем первую и последнюю колонки\n",
        "print(arr[:, [0, -1]])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 1  4]\n",
            " [ 5  8]\n",
            " [ 9 12]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "296Ww5MDFaY4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f02b364b-1897-409b-c3b3-75418b82914b"
      },
      "source": [
        "# И таким образом никто не заставляет писать в том же порядке индексы\n",
        "# Перемешаем ряды\n",
        "print(arr[[2, 0, 1], :])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 9 10 11 12]\n",
            " [ 1  2  3  4]\n",
            " [ 5  6  7  8]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RFkxEluyFpZb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "53ae9f43-15da-4b1d-9bec-85731cc524c7"
      },
      "source": [
        "# Также, можно комбинировать способы задания\n",
        "print(arr[[2, 0], [1, 3]])\n",
        "# То же самое, только первая запись дает массив\n",
        "print(arr[2, 1], arr[0, 3])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[10  4]\n",
            "10 4\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EKQkjUnxE4vN",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8a806a37-a3e0-4abb-b7f3-e13b10fa2a45"
      },
      "source": [
        "# Создаем список возможных индексов для рядов массива\n",
        "row_indices = list(range(arr.shape[0]))\n",
        "print(row_indices)\n",
        "\n",
        "# Переворачиваем его\n",
        "row_indices = list(reversed(row_indices))\n",
        "print(row_indices)\n",
        "\n",
        "# Используем для индексации\n",
        "print('----------------')\n",
        "print(arr[row_indices])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0, 1, 2]\n",
            "[2, 1, 0]\n",
            "----------------\n",
            "[[ 9 10 11 12]\n",
            " [ 5  6  7  8]\n",
            " [ 1  2  3  4]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4jVVCGMSCPWu"
      },
      "source": [
        "## Задание\n",
        "\n",
        "Получите массив без крайних рядов и колонок (по одной с каждой стороны)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rJegDeQ6CcTD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2e87b941-7030-4393-83eb-ffe751db65d3"
      },
      "source": [
        "data = np.random.randint(low=0, high=10, size=(5, 6))\n",
        "print(data)\n",
        "\n",
        "# TODO - центральная часть массива размером (4, 5)\n",
        "print('')\n",
        "newdata = data[1:4,1:5] # cо второй по третью строку и со второго по 5 столбец (включительно)\n",
        "print(newdata) # без крайних слева справа снизу и сверху столбцов и строк\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[9 2 1 8 3 9]\n",
            " [9 5 0 2 5 3]\n",
            " [4 1 7 8 7 3]\n",
            " [3 1 0 4 2 1]\n",
            " [5 3 7 9 6 8]]\n",
            "\n",
            "[[5 0 2 5]\n",
            " [1 7 8 7]\n",
            " [1 0 4 2]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7R_2MeNRGsNq"
      },
      "source": [
        "## Задание\n",
        "\n",
        "Произведите перемешивание колонок с помощью функции `numpy.random.permutation()`:\n",
        "\n",
        "<details>\n",
        "<summary>Подсказка</summary>\n",
        "\n",
        "Перемешать колонки можно путем перемешивания списка возможных индексов колонок (`range(<col_count>)`) и затем индексацией этого списка по индексам колонок (`[:, cols]`).\n",
        "</details>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EawZBVacHHk4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8fb05bc0-0106-47e2-9a41-e4a07feecf69"
      },
      "source": [
        "data = np.random.randint(low=0, high=10, size=(3, 6))\n",
        "print(data)\n",
        "\n",
        "# TODO - такой же массив, но со случайной перестановкой колонок\n",
        "\n",
        "print('')\n",
        "randomseq=np.random.permutation(range(6)) # мешаем 6 чисел - колонок\n",
        "print (randomseq) # новая последовательность колонок\n",
        "print('')\n",
        "datan = data[:,randomseq] \n",
        "print (datan)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[6 6 1 7 1 0]\n",
            " [8 8 4 8 1 3]\n",
            " [3 6 9 3 1 0]]\n",
            "\n",
            "[4 1 3 0 2 5]\n",
            "\n",
            "[[1 6 7 6 1 0]\n",
            " [1 8 8 8 4 3]\n",
            " [1 6 3 3 9 0]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RKssiBX6IWQ4"
      },
      "source": [
        "# Типы данных в массивах"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1W373guIIYpQ"
      },
      "source": [
        "Массивы в numpy имеют не только размер, но и конкретный тип данных, которые хранятся внутри массива. При создании массива почти все функции создания имеют аргумент `dtype`, который означает, с каким типом создать данным массив. Также, класс `ndarray` имеет атрибут `dtype`, который означает тип хранимых данных. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RkaZp3yUQ2l9"
      },
      "source": [
        "Подробнее можно прочитать в [документации](https://numpy.org/doc/stable/reference/arrays.dtypes.html)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hhX2FD0xJC50",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "45435567-d83e-486c-c78e-f7f03cbdc26e"
      },
      "source": [
        "# Создадим массив без задания типа - тип будет определен автоматически\n",
        "arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])\n",
        "print(arr.dtype)\n",
        "\n",
        "# int, так как все элементы являются целочисленными"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "int64\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pVSghFu5JQTO",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e40316b6-9e16-4637-f233-52fd5ba5f57a"
      },
      "source": [
        "# Изменим один элемент на вещественный\n",
        "arr = np.array([[1.5, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])\n",
        "print(arr.dtype)\n",
        "\n",
        "# Один из элементов float, поэтому весь массив будет float"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "float64\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OfAofWauJePj",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c57e9802-0839-4bcd-fe96-0318bc13c789"
      },
      "source": [
        "# Зададим явно тип массива\n",
        "# Хоть массив и содержит вещественные числа\n",
        "# мы создаем массив целочисленных, что приводит\n",
        "# к округлению\n",
        "arr = np.array([[1.1, 1.6, 2.4], [-1.7, 2.6, -1.2]], dtype=int)\n",
        "print(arr)\n",
        "print(arr.dtype)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 1  1  2]\n",
            " [-1  2 -1]]\n",
            "int64\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Nj1UkwjDKBr1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f571289a-364b-483c-a2ee-ea09ed392fb6"
      },
      "source": [
        "# Создаем массив вещественных\n",
        "arr = np.array([[1.1, 1.6, 2.4], [-1.7, 2.6, -1.2]])\n",
        "print(arr)\n",
        "print(arr.dtype)\n",
        "print('----------')\n",
        "# Но в какой-то момент нам нужно привести массив к целочисленным\n",
        "# Воспользуемся методом ndarray.astype()\n",
        "arr = arr.astype(int)\n",
        "print(arr)\n",
        "print(arr.dtype)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 1.1  1.6  2.4]\n",
            " [-1.7  2.6 -1.2]]\n",
            "float64\n",
            "----------\n",
            "[[ 1  1  2]\n",
            " [-1  2 -1]]\n",
            "int64\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4Zv5Ss7KKa77",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8afb9d66-251d-4660-d9b9-637ca71683ca"
      },
      "source": [
        "# При этом попытки записать в целочисленный массив \n",
        "# вещественное число приводят к округлению\n",
        "arr = np.array([[1.1, 1.6, 2.4], [-1.7, 2.6, -1.2]], dtype=int)\n",
        "print(arr)\n",
        "\n",
        "arr[0, 1] = 10.12\n",
        "print(arr)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 1  1  2]\n",
            " [-1  2 -1]]\n",
            "[[ 1 10  2]\n",
            " [-1  2 -1]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MVMN0qd7HlFu"
      },
      "source": [
        "# Булевы операции над массивами"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8CjSRYurH1mk"
      },
      "source": [
        "Массивы numpy поддерживают операции сравнения, которые генерируют так называемые маски."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "buwe4r-2IDdO",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ed1f3c23-dfa1-493a-f7df-adab9954f40b"
      },
      "source": [
        "arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])\n",
        "print(arr)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 1  2  3  4]\n",
            " [ 5  6  7  8]\n",
            " [ 9 10 11 12]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rGNfFg2RIJE5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1bba3d3a-c088-4abb-f01b-bc34eef262cd"
      },
      "source": [
        "# Произведем сравнение с числом\n",
        "result = arr > 6\n",
        "print(result)\n",
        "print(result.dtype)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[False False False False]\n",
            " [False False  True  True]\n",
            " [ True  True  True  True]]\n",
            "bool\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZfYWaYzSIPlU"
      },
      "source": [
        "Как видно, в результате операции создается такой же массив, но с булевым типом. Так мы получаем маску элементов, которые соответсвуют условию булевого выражения.\n",
        "\n",
        "Как и с простым булевым типом, маски можно совмещать булевыми операциями:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ruFSuJzwNoME",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "57c41321-908c-4933-8f51-1b25efbc010e"
      },
      "source": [
        "result_1 = arr > 6\n",
        "result_2 = arr < 10\n",
        "print(result_1)\n",
        "print(result_2)\n",
        "\n",
        "print('----------')\n",
        "# Следующие две операции идентичны, но для второй скобки обязательны!\n",
        "print(result_1 & result_2)\n",
        "print((arr > 6) & (arr < 10))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[False False False False]\n",
            " [False False  True  True]\n",
            " [ True  True  True  True]]\n",
            "[[ True  True  True  True]\n",
            " [ True  True  True  True]\n",
            " [ True False False False]]\n",
            "----------\n",
            "[[False False False False]\n",
            " [False False  True  True]\n",
            " [ True False False False]]\n",
            "[[False False False False]\n",
            " [False False  True  True]\n",
            " [ True False False False]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "q-2ToYvBLaLb"
      },
      "source": [
        "При работе с масками полезно помнить про функции `np.all()` и `np.any()`, которые имеют следующие описания:\n",
        "- `all` - проверка на то, что все элементы в массиве имеют значение True (аналог операции И);\n",
        "- `any` - проверка, что хотя бы один элемент в массиве имеет значение True (аналог операции ИЛИ)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xOxMSvvfL0Yj"
      },
      "source": [
        "## Задание\n",
        "\n",
        "Определите, имеется ли хотя бы одно значение больше пяти и меньше восьми в массиве:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GM6BqDDcMK4X",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fdeb2349-5b3b-4251-97ce-cfc76f861a9c"
      },
      "source": [
        "arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])\n",
        "print(arr)\n",
        "\n",
        "# TODO - определить, имеется ли в массиве хотя бы один элемент, \n",
        "#           отвечающий условию больше пяти и меньше восьми\n",
        "\n",
        "np.any([( arr > 5) & ( arr < 8 )])\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 1  2  3  4]\n",
            " [ 5  6  7  8]\n",
            " [ 9 10 11 12]]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 54
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zEuM4ZnWHUm5"
      },
      "source": [
        "# Больше индексации"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F62Ol7oXHWlu"
      },
      "source": [
        "Помимо индексации с помощью диапазонов и списков индексов numpy поддерживает индексацию с помощью булевых массивов."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Vpt6OK_RHfyG"
      },
      "source": [
        "arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "G0YBhqI3MpUr",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8b69c4f5-d2a5-4115-a712-9119252c512f"
      },
      "source": [
        "# Получим маску и воспользуемся ею для индексации\n",
        "mask = arr > 6\n",
        "print(mask)\n",
        "print(arr[mask])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[False False False False]\n",
            " [False False  True  True]\n",
            " [ True  True  True  True]]\n",
            "[ 7  8  9 10 11 12]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hyCi34eKM33_"
      },
      "source": [
        "Обратите внимание, такая индексация по всему массиву приводит к созданию 1D массива из-за того, что элементы имеют неравномерное расположение, так что они представляются в выпрямленном виде (flattened).\n",
        "\n",
        "> Выпрямленное представление - приведение массива любой размерности к 1D представлению. Для этого есть метод `ndarray.flatten()`. Происходит это путем разворачивания массива в одномерный, проходом по индексам, начиная с последней размерности: в 2D случае мы берем элемент 1-го рядя, 1-й колонки, затем 1-го ряда, 2-й колонки, как закончим со всем рядом, то переходим на следующий и снова по колонкам. Для 3D массивов - сначала полностью разворачивается глубина, затем колонки, затем ряды."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RLbUE76_PgBu",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e552e110-dd4c-40fd-ff1f-35bc00a2a65e"
      },
      "source": [
        "arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])\n",
        "print(arr)\n",
        "print(arr.flatten())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[1 2 3 4]\n",
            " [5 6 7 8]]\n",
            "[1 2 3 4 5 6 7 8]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X-08XaFSzGo4"
      },
      "source": [
        "# Операции с массивами"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5CRyuSOlQoQe"
      },
      "source": [
        "Мало смысла в создании массивов без возможности сделать с ними что-либо. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "D4koFxcK1PyA"
      },
      "source": [
        "x = np.array([[1,2],[3,4]], dtype=np.float64)\n",
        "y = np.array([[5,6],[7,8]], dtype=np.float64)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q2TffF7Q2jCt",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6082dfa4-56c4-4a2d-c45c-a20e4c3dfcde"
      },
      "source": [
        "# Сложение\n",
        "print(x + y)\n",
        "print(np.add(x, y))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 6.  8.]\n",
            " [10. 12.]]\n",
            "[[ 6.  8.]\n",
            " [10. 12.]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SBVvWTwx2uEz",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "26907397-0b24-4663-eec8-60cd6f75c934"
      },
      "source": [
        "# Вычитание\n",
        "print(x - y)\n",
        "print(np.subtract(x, y))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[-4. -4.]\n",
            " [-4. -4.]]\n",
            "[[-4. -4.]\n",
            " [-4. -4.]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aOAqrdb33IRV",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "439c50c7-0d2d-439d-a86d-e74696a68e19"
      },
      "source": [
        "# Поэлементное умножение\n",
        "print(x * y)\n",
        "print(np.multiply(x, y))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 5. 12.]\n",
            " [21. 32.]]\n",
            "[[ 5. 12.]\n",
            " [21. 32.]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fTbMbYoo3MlX",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "07f2e13c-140b-4e87-cc53-7cef5459a5cc"
      },
      "source": [
        "# Поэлементное деление\n",
        "print(x / y)\n",
        "print(np.divide(x, y))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[0.2        0.33333333]\n",
            " [0.42857143 0.5       ]]\n",
            "[[0.2        0.33333333]\n",
            " [0.42857143 0.5       ]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ke48RJZz3QFN",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "af29375e-82f3-47fa-d90e-8f4c5c45c9d7"
      },
      "source": [
        "# Вычисление корня каждого элемента\n",
        "print(np.sqrt(x))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[1.         1.41421356]\n",
            " [1.73205081 2.        ]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xk83DBbX4GTX"
      },
      "source": [
        "Отлично, мы рассмотрели основные операции над массивами. Операции поэлементные, результаты такие же по размеру, как и операнды. Помимо рассмотренных существуют и множество других, например, экспонента, логарифм и т.д.\n",
        "\n",
        "Помимо поэлементных операций, которые не составляют сложностей в представлении, существует операция матричного умножения. В данном случае мы имеем варианты перемножения матриц, векторов и скаляров."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XTQGfz575qFK",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ac07935e-cb96-41da-f136-188db1fa500c"
      },
      "source": [
        "# Умножение матрицы на скаляр - релизуется как поэлементное перемножение \n",
        "k = 1.5\n",
        "\n",
        "print(k*x)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[1.5 3. ]\n",
            " [4.5 6. ]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "N5xOhY-e6BtE"
      },
      "source": [
        "v = np.array([1, 2])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KyTncnjz6FPm",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "629e5172-4102-4ddf-f08b-34a7366a01f4"
      },
      "source": [
        "# Матричное умножение реализуется через оператор @ или функцию np.dot() \n",
        "#   или метод ndarray.dot()\n",
        "# Для умножения матрица-вектор\n",
        "\n",
        "print(x @ v)\n",
        "print(x.dot(v))\n",
        "print(np.dot(x, v))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[ 5. 11.]\n",
            "[ 5. 11.]\n",
            "[ 5. 11.]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "08UQZ9Ks63FH",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "80fdf441-bac4-47b7-a487-0b9ca0233a26"
      },
      "source": [
        "# Двух векторов\n",
        "w = np.array([3, 4])\n",
        "\n",
        "print(w @ v)\n",
        "print(w.dot(v))\n",
        "print(np.dot(w, v))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "11\n",
            "11\n",
            "11\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Fmd4HaZP6paa",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ff248f66-c0ea-4464-9d71-2d61d525a0fe"
      },
      "source": [
        "# Так и для перемножения матриц\n",
        "print(x @ y)\n",
        "print(x.dot(y))\n",
        "print(np.dot(x, y))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[19. 22.]\n",
            " [43. 50.]]\n",
            "[[19. 22.]\n",
            " [43. 50.]]\n",
            "[[19. 22.]\n",
            " [43. 50.]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BXjO0pdq7EVL"
      },
      "source": [
        "Правила умножения матриц и векторов здесь идентичны математическим, то есть соседние размерности должны соотноситься: $(m, n)*(n, k)=(m, k)$.\n",
        "\n",
        "Прекрасно! Раз мы разобрались с тем, как делать базовые операции, то осталось лишь последняя базовая операция - транспонирование."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wtkDK4UU76Pp",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "365efecc-79fd-4d6b-8607-abc9d28e925e"
      },
      "source": [
        "# Для транспонирования можно воспользоваться атрибутом ndarray.T\n",
        "#   или функцией np.transpose()\n",
        "x = np.array([[1, 2, 3], [4, 5, 6]])\n",
        "print(x)\n",
        "print(x.shape)\n",
        "print('--------')\n",
        "print(np.transpose(x))\n",
        "print(x.T)\n",
        "print(x.T.shape)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[1 2 3]\n",
            " [4 5 6]]\n",
            "(2, 3)\n",
            "--------\n",
            "[[1 4]\n",
            " [2 5]\n",
            " [3 6]]\n",
            "[[1 4]\n",
            " [2 5]\n",
            " [3 6]]\n",
            "(3, 2)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "foJSgM3-9Ktj"
      },
      "source": [
        "# Операции по осям"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Zu26o_Jq8ko-"
      },
      "source": [
        "Если ранее операции позволяли модифицировать массив и получать новые массивы с помощью базовых операций, то сейчас мы рассмотрим более \"аггрегуирующие\" операции, например, получение среднего значения, суммы и т.д.\n",
        "\n",
        "При разборе обратим внимание на один важный аргумент в операциях `axis`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CNvo0bMH8Hw4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1079d05b-d534-4c01-b079-f61a1d23a04c"
      },
      "source": [
        "x = np.array([[1, 2, 3], [5, 4, 3]])\n",
        "print(x)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[1 2 3]\n",
            " [5 4 3]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VmORpW679pGA",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c7e8e1b1-9efe-410d-9024-d46d144ff29c"
      },
      "source": [
        "# Возьмем среднее значение всего массива\n",
        "print(np.mean(x))\n",
        "print(np.mean(x, axis=None))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3.0\n",
            "3.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AAbohlvH94YY",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "296bae20-6032-44ec-acbf-949b4318212f"
      },
      "source": [
        "# Получим сумму значений всего массива\n",
        "print(np.sum(x))\n",
        "print(np.sum(x, axis=None))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "18\n",
            "18\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3SD2e0--9_sl"
      },
      "source": [
        "Отлично, работает как надо, но зачем этот аргумент `axis`? Все очень просто, он управляет тем, по какой оси (размерности) делается операция. Нужно это, чтобы получить, например, среднее по каждому столбцу или строке."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TwyP8qED-ROD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "660c8659-65f6-4a41-bf16-535300b067dc"
      },
      "source": [
        "# Получим среднее по каждому столбцу\n",
        "print(np.mean(x, axis=0))\n",
        "\n",
        "# Получим среднее по каждой строке\n",
        "print(np.mean(x, axis=1))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[3. 3. 3.]\n",
            "[2. 4.]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Cvne71NE_RJB"
      },
      "source": [
        "Так как же это воспринимать? Помните индексацию слайсами (диапазонами)? Чтобы получить весь второй столбец, мы пишем $[:, 2]$, что означает \"все строки стобца под индексом 2\". Так и тут, если мы хотим, чтобы операция выполнилась по всем строкам (например для результата по столбцам), то пишем `axis=0`. Если хотим, чтобы операция проходила по колонкам (для каждой строки), то пишем `axis=1`. То есть, в `axis` задается тот индекс, вдоль которого выполняется операция.\n",
        "\n",
        "Можно подходить к вопросу более формально. Например, мы имеем матрицу размера $(10, 13)$. При указании `axis=0` мы получим результат вычисления операции по каждому столбцу или массив размером $(13, )$. Через аргумент `axis` мы указываем размерность, которую схлопнем до единицы. Для случая многомерных массивов, например с размером $(8, 3, 40, 20)$, указывая `axis=1`, мы получаем результат с размером $(8, 40, 20)$.\n",
        "\n",
        "> Такие возможности задания осей хороши тем, что не нужно писать циклы прохода по всем строкам, чтобы получить результат - это делает код более читаемым и производительным."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pzurzVvuBCgi"
      },
      "source": [
        "## Задание\n",
        "\n",
        "Напишите операцию получения суммы элементов по всем стобцам:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ut4bOSdcBP0v",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a1592bb5-b16d-4d09-e944-bf6bf2c04af6"
      },
      "source": [
        "data = np.random.randint(low=0, high=5, size=(3, 6))\n",
        "print(data)\n",
        "\n",
        "# TODO - вектор сумм элементов по каждому столбцу\n",
        "print('')\n",
        "print(np.sum(data, axis=0))"
      ],
      "execution_count": 79,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[4 1 3 0 2 4]\n",
            " [3 4 4 0 2 4]\n",
            " [1 0 0 2 2 3]]\n",
            "\n",
            "[ 8  5  7  2  6 11]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bcgRRkseBqzq"
      },
      "source": [
        "# Broadcasting (трансляция)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fgwB6980BuZ0"
      },
      "source": [
        "Тема достаточно \"широкая\" =)\n",
        "На деле механизм броадкастинга очень полезен и его понимание является одним из мощных инструментов библиотеки numpy.\n",
        "\n",
        "Зачем он нужен? Допустим, мы имеет вектор $(4,)$, матрицу $(3, 4)$ и хотим умножить этот вектор на каждую строку матрицы. Самый простой способ - пройти в цикле по строкам:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PXEeaAmqHqp8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2c7df562-bdec-4771-dc79-7148c0f50995"
      },
      "source": [
        "vec = np.arange(4)\n",
        "mtrx = np.ones((3, 4))\n",
        "print(vec)\n",
        "print(mtrx)"
      ],
      "execution_count": 80,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0 1 2 3]\n",
            "[[1. 1. 1. 1.]\n",
            " [1. 1. 1. 1.]\n",
            " [1. 1. 1. 1.]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8xH_CXJoHrkr",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2c105c44-c8f1-474f-8122-ae01df3c4a03"
      },
      "source": [
        "result = np.empty_like(mtrx)\n",
        "\n",
        "for i_row in range(mtrx.shape[0]):\n",
        "    result[i_row,:] = mtrx[i_row,:] * vec\n",
        "\n",
        "print(result)"
      ],
      "execution_count": 81,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[0. 1. 2. 3.]\n",
            " [0. 1. 2. 3.]\n",
            " [0. 1. 2. 3.]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UVbNFmqkIHL_"
      },
      "source": [
        "С другой стороны, можно склонировать вектор по размеру матрицы, чтобы затем просто перемножить поэлементно две матрицы."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "P2aJ71qMIJIN",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "07c815fc-e22f-4d1e-f20c-2467625b9796"
      },
      "source": [
        "# Функция np.tile() повторяет массив то количество раз и по тем осям,\n",
        "#   которые заданы в аргументе reps\n",
        "vec_m = np.tile(vec, reps=(3, 1))\n",
        "print(vec_m)\n",
        "print(vec_m * mtrx)"
      ],
      "execution_count": 82,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[0 1 2 3]\n",
            " [0 1 2 3]\n",
            " [0 1 2 3]]\n",
            "[[0. 1. 2. 3.]\n",
            " [0. 1. 2. 3.]\n",
            " [0. 1. 2. 3.]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YIAATyxQHp6y"
      },
      "source": [
        "А можно вспомнить про броадкастинг и просто умножить вектор на матрицу:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cvhGzlKyGPkk",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fce01954-a758-4d40-f1c2-cbe4f1ff1d69"
      },
      "source": [
        "# Умножение, используя броадкастинг\n",
        "print(vec * mtrx)"
      ],
      "execution_count": 83,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[0. 1. 2. 3.]\n",
            " [0. 1. 2. 3.]\n",
            " [0. 1. 2. 3.]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m45myVWXInxI"
      },
      "source": [
        "Таким образом, броадкастинг - это механизм распространения элементов операций по разметностям, по которым количество элементов не соотносится с другим операндом. В последней ячейке вектор был продублирован на каждую строку так, что размерности соотносятся.\n",
        "\n",
        "> Обязательно прочитайте примеры броадкастинга в [статье](https://numpy.org/doc/stable/user/basics.broadcasting.html).\n",
        "\n",
        "Броадкастинг также работает и при умножении скаляра на массив:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vyolr9OlHRx0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d91e6593-901b-4b2b-d8e1-fd9c9f770725"
      },
      "source": [
        "print(2 * mtrx)"
      ],
      "execution_count": 84,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[2. 2. 2. 2.]\n",
            " [2. 2. 2. 2.]\n",
            " [2. 2. 2. 2.]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b5C9CLXvLy_X"
      },
      "source": [
        "Чтобы больше понять правила броадкастинга, посмотрим на результаты операций 3D матриц:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "p5gNIS1QLmTq",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f5703ee7-79c1-4f92-d5fb-64f3994447e0"
      },
      "source": [
        "x = np.ones((4, 1, 1))\n",
        "y = np.random.randint(0, 5, size=(4, 3, 2))\n",
        "\n",
        "print((x*y).shape)"
      ],
      "execution_count": 85,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(4, 3, 2)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sXzWWxHnMS8E",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6c6f17af-c800-449e-bc22-3abaa262a54e"
      },
      "source": [
        "x = np.ones((3, 1))\n",
        "y = np.random.randint(0, 5, size=(4, 3, 2))\n",
        "\n",
        "print((x*y).shape)"
      ],
      "execution_count": 86,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(4, 3, 2)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gCclW4LGMYUA",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7018f2a9-3b8b-46c2-d777-73eacf7d053e"
      },
      "source": [
        "x = np.ones((1, 3, 2))\n",
        "y = np.random.randint(0, 5, size=(5, 1, 2))\n",
        "\n",
        "print((x*y).shape)"
      ],
      "execution_count": 87,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(5, 3, 2)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V5BvOyFOMdyr"
      },
      "source": [
        "В последних примерах можно увидеть, что размерности должны быть соотносимы (количества размерностей равны). В случае неравенства количества размерностей новые размерности со значением 1 добавляются слева ($(3, 1) \\rightarrow (1, 3, 1)$ в одном из примеров).\n",
        "\n",
        "> Добавление размерности было и в случае умножения вектора на матрицу: $(4,)*(3, 4) \\rightarrow (1, 4)*(3, 4)$\n",
        "\n",
        "Броадкастинг делается по тем осям, которые у одного операнда имеют размерность 1 путем копирования.\n",
        "\n",
        "> В нашем случае $(1, 4)*(3, 4) \\rightarrow (3, 4)*(3, 4)$"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7TwQwQt6OEA_"
      },
      "source": [
        "Осознать броадкастинг сразу не совсем просто, но главное не забывать, что такой инструмент есть и им нужно пользоваться во избежание лишнего кода."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6Aece1s4OM7y"
      },
      "source": [
        "# Изменение размеров массива (Reshape)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AjcQO4NSOQtv"
      },
      "source": [
        "Еще одна интересная тема, которую стоит рассмотреть. Мы уже касались вопроса приведения массива к выпрямленному виду - это один из видов изменения размерности массива.\n",
        "\n",
        "По сути, размерность массива - это то, как выстроены элементы в нем. Изменение размерности - это изменение структуры **без изменения элементов или порядка**.\n",
        "\n",
        "Рассмотрим на примере:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QaEqZf_aPoSp",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f98262d1-050a-4c85-e5ab-d33d9c7b8564"
      },
      "source": [
        "arr = np.arange(20)\n",
        "print(arr)"
      ],
      "execution_count": 88,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y6rx0qLXPtKD"
      },
      "source": [
        "Вот мы имеем вектор из 20 элементов в порядке возрастания. Теперь, допустим, нам нужно сделать массив размером $(4, 5)$, в котором каждый ряд - это продолжение предыдущего по возрастанию чисел. Для начала сделаем руками: "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Kx9kBRe2QBR-",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "277777cd-a8d8-4e3a-b7ea-c39fd74741c9"
      },
      "source": [
        "mtrx = np.ndarray((4, 5), dtype=np.int32)\n",
        "mtrx[0, :] = arr[:5]\n",
        "mtrx[1, :] = arr[5:10]\n",
        "mtrx[2, :] = arr[10:15]\n",
        "mtrx[3, :] = arr[15:]\n",
        "\n",
        "print(mtrx)"
      ],
      "execution_count": 89,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 0  1  2  3  4]\n",
            " [ 5  6  7  8  9]\n",
            " [10 11 12 13 14]\n",
            " [15 16 17 18 19]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UPyGvrtWdPm-"
      },
      "source": [
        "Получилось как надо, но есть два недостатка:\n",
        "- Если элементов будет больше и нужен будет другой размер - код не универсален;\n",
        "- Приходится расставлять данные вручную.\n",
        "\n",
        "Теперь взглянем, как работает метод `ndarray.reshape()`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AFpqjOXAdOqD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2759cb72-938d-4558-b246-7196cd719bce"
      },
      "source": [
        "print(arr.reshape((4, 5)))"
      ],
      "execution_count": 90,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 0  1  2  3  4]\n",
            " [ 5  6  7  8  9]\n",
            " [10 11 12 13 14]\n",
            " [15 16 17 18 19]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rVRLk09SdrtT"
      },
      "source": [
        "В результате происходит то же самое. То есть, элементы расположились в порядке размещения по размерностям: начиная с первой строки (нулевая размерность) заполняется по колонкам (первая размерность), а как только заполнение по колонкам закончено - переходим на следующий ряд.\n",
        "\n",
        "Таким образом, в какую бы размерность не происходило изменение размера - расположение будет придерживаться этого правила.\n",
        "\n",
        "Для лучшего понимания посмотрим на другие представления:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ecjFNZPPebov",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f1f716c0-1526-4234-8109-ef2b4aa50ae9"
      },
      "source": [
        "print(arr.reshape((2, 10)))\n",
        "print(arr.reshape((5, 4)))\n",
        "print(arr.reshape((20, 1)))"
      ],
      "execution_count": 91,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 0  1  2  3  4  5  6  7  8  9]\n",
            " [10 11 12 13 14 15 16 17 18 19]]\n",
            "[[ 0  1  2  3]\n",
            " [ 4  5  6  7]\n",
            " [ 8  9 10 11]\n",
            " [12 13 14 15]\n",
            " [16 17 18 19]]\n",
            "[[ 0]\n",
            " [ 1]\n",
            " [ 2]\n",
            " [ 3]\n",
            " [ 4]\n",
            " [ 5]\n",
            " [ 6]\n",
            " [ 7]\n",
            " [ 8]\n",
            " [ 9]\n",
            " [10]\n",
            " [11]\n",
            " [12]\n",
            " [13]\n",
            " [14]\n",
            " [15]\n",
            " [16]\n",
            " [17]\n",
            " [18]\n",
            " [19]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VFh8-iyHeh6d"
      },
      "source": [
        "Таким образом, можно приводить к любой размерности с учетом правила:\n",
        "> Количество элементов должно сохраняться\n",
        "\n",
        "Но бывают ситуации, когда мы точно не знаем количество элементов, но нам нужно точно создать, например, 4 строки в матрице. В этом поможет неопределенная размерность, которая задается числом -1:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-rioXaAse-Da",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5a8d237f-c1bf-4fbb-ccd1-ad6789696c0e"
      },
      "source": [
        "print(arr.reshape((4, -1)))"
      ],
      "execution_count": 92,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 0  1  2  3  4]\n",
            " [ 5  6  7  8  9]\n",
            " [10 11 12 13 14]\n",
            " [15 16 17 18 19]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m4DEV-Q0Pngj"
      },
      "source": [
        "Таким образом можно задать, что матрица должна быть 2D с фиксированным количеством строк, но без фиксации на количество столбцов. Конечно же, если в исходном будет 21 элемент, то такой трюк не сработает, потому что 21 не делится на 4 без остатка."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "53NWq6i_fe2W"
      },
      "source": [
        "# Объединение массивов"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EDCNSihEfiVA"
      },
      "source": [
        "При работе с массивами бывают случаи, когда несколько массивов необходимо объединить в один. Для этого поможет функция `np.concatenate()` и понимание ее основных правил."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iiVzWooVfw-w",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "32d466e2-3e93-4806-b0b4-32c5ed23735c"
      },
      "source": [
        "x = np.arange(10).reshape((2, 5))\n",
        "y = np.arange(15).reshape((3, 5))\n",
        "\n",
        "print(x)\n",
        "print(y)"
      ],
      "execution_count": 93,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[0 1 2 3 4]\n",
            " [5 6 7 8 9]]\n",
            "[[ 0  1  2  3  4]\n",
            " [ 5  6  7  8  9]\n",
            " [10 11 12 13 14]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dpXU_P7TguD_"
      },
      "source": [
        "Для объединения массивов необходимо, чтобы одна из размерностей имела одинаковое количество элементов. Это достаточно логичное требование задается аргументом `axis` в функции:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rX9FSi5Hg62I",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fba8e4a2-a517-4c57-801c-b6bdaa05177f"
      },
      "source": [
        "print(np.concatenate((x, y), axis=0))"
      ],
      "execution_count": 94,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 0  1  2  3  4]\n",
            " [ 5  6  7  8  9]\n",
            " [ 0  1  2  3  4]\n",
            " [ 5  6  7  8  9]\n",
            " [10 11 12 13 14]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "In1g-miAg_vz"
      },
      "source": [
        "Обратите внимание, что массивы передаются в виде кортежа, что позволяет объединять два и более массивов."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9zi8VK2HhHnw"
      },
      "source": [
        "## Задание\n",
        "\n",
        "Объедините три массива вдоль колонок:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WroGVeHYhXYU",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0f89ded0-3f73-4c2a-e66e-0f8f6e2020cf"
      },
      "source": [
        "x = np.arange(9).reshape((3, 3))\n",
        "y = np.arange(12).reshape((3, 4))\n",
        "z = np.arange(15).reshape((3, 5))\n",
        "\n",
        "print(x)\n",
        "print(y)\n",
        "print(z)\n",
        "\n",
        "# TODO - получите объединенный массив:\n",
        "# [[ 0  1  2  0  1  2  3  0  1  2  3  4]\n",
        "#  [ 3  4  5  4  5  6  7  5  6  7  8  9]\n",
        "#  [ 6  7  8  8  9 10 11 10 11 12 13 14]]\n",
        "print('----------')\n",
        "modarr=np.concatenate((x,y,z), axis=1)\n",
        "print(modarr)\n"
      ],
      "execution_count": 100,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[0 1 2]\n",
            " [3 4 5]\n",
            " [6 7 8]]\n",
            "[[ 0  1  2  3]\n",
            " [ 4  5  6  7]\n",
            " [ 8  9 10 11]]\n",
            "[[ 0  1  2  3  4]\n",
            " [ 5  6  7  8  9]\n",
            " [10 11 12 13 14]]\n",
            "----------\n",
            "[[ 0  1  2  0  1  2  3  0  1  2  3  4]\n",
            " [ 3  4  5  4  5  6  7  5  6  7  8  9]\n",
            " [ 6  7  8  8  9 10 11 10 11 12 13 14]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g1vMT1PZSpSs"
      },
      "source": [
        "## Задание\n",
        "\n",
        "Напишите реализацию добавления стобца единиц к матрице слева:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uKMSNM0ySyQ2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5dc9e38b-7167-4322-d176-924b9f97fa9c"
      },
      "source": [
        "x = np.arange(1, 10).reshape((3, 3))\n",
        "print(x)\n",
        "\n",
        "# TODO - получить матрицу со столбцом единиц слева\n",
        "# [[1 1 2 3]\n",
        "#  [1 4 5 6]\n",
        "#  [1 7 8 9]]\n",
        "\n",
        "print('----------')\n",
        "ones=np.array([[1],[1],[1]])\n",
        "print(ones)\n",
        "print('----------')\n",
        "arr1=np.concatenate((ones,x), axis=1)\n",
        "print(arr1)"
      ],
      "execution_count": 108,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[1 2 3]\n",
            " [4 5 6]\n",
            " [7 8 9]]\n",
            "----------\n",
            "[[1]\n",
            " [1]\n",
            " [1]]\n",
            "----------\n",
            "[[1 1 2 3]\n",
            " [1 4 5 6]\n",
            " [1 7 8 9]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ylb4mK18hxpf"
      },
      "source": [
        "# Сортировка массива"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pLIYlEd0h2fp"
      },
      "source": [
        "Numpy как серьезная библиотека работы с массивами имеет также и функционал сортировки. Для этого есть функция `np.sort()`, которая производит сортировку элементов и возвращает отсортированный массив:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qeoYgI9Eilc6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c3613145-1732-4beb-b4a0-2c493e5f8c09"
      },
      "source": [
        "unsorted_arr = np.array([2, 4, 5, 1, 2, 7, 5, 0, -1, 3, 5])\n",
        "sorted_arr = np.sort(unsorted_arr)\n",
        "\n",
        "print(unsorted_arr)\n",
        "print(sorted_arr)"
      ],
      "execution_count": 109,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[ 2  4  5  1  2  7  5  0 -1  3  5]\n",
            "[-1  0  1  2  2  3  4  5  5  5  7]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Bnck_27Bi0id"
      },
      "source": [
        "Помимо явной сортировки существует также функция `np.argsort()`, которая возвращает не отсортированный массив, а массив индексов исходного массива в порядке, который дает отсортированный исходный. Посмотрим:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NPkO5wIkjvoN",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f3373b09-5600-4bbc-92c1-94e5b3998096"
      },
      "source": [
        "sorted_indices = np.argsort(unsorted_arr)\n",
        "print(sorted_indices)\n",
        "\n",
        "# А теперь воспользуемся индексами и отобразим исходный массив с индексацией\n",
        "print(unsorted_arr[sorted_indices])"
      ],
      "execution_count": 110,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[ 8  7  3  0  4  9  1  2  6 10  5]\n",
            "[-1  0  1  2  2  3  4  5  5  5  7]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "unm24O5ukBIN"
      },
      "source": [
        "## Задание\n",
        "\n",
        "По такому же принципу именования найдите функцию, которая возвращает индекс максимального/минимального (в завимости от варианта) элемента в массиве.\n",
        "\n",
        "Воспользуйтесь найденной функцией и найдите индексы максимальных элементов в каждом столбце 2D матрицы: "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "V8mS3lbMkzha",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e57d08b1-7f1e-47eb-f3aa-838abcf74f34"
      },
      "source": [
        "arr = np.array([\n",
        "    [11, -1, 1, 3, 5],\n",
        "    [6, 1, 0, -1, 10],\n",
        "    [1, 3, 2, 3, 6],\n",
        "    [5, 2, 7, 8, 9],\n",
        "])\n",
        "\n",
        "print(arr)\n",
        "\n",
        "# TODO - напишите код поиска индексов максимальных/минимальных \n",
        "#           элементов в массиве по столбцам: [0 2 3 3 1]/[2 0 1 1 0]\n",
        "print('----------')\n",
        "max=np.argmax(arr,axis=0)\n",
        "print(max)\n",
        "min=np.argmin(arr,axis=0)\n",
        "print(min)"
      ],
      "execution_count": 114,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[11 -1  1  3  5]\n",
            " [ 6  1  0 -1 10]\n",
            " [ 1  3  2  3  6]\n",
            " [ 5  2  7  8  9]]\n",
            "----------\n",
            "[0 2 3 3 1]\n",
            "[2 0 1 1 0]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "B-BhMwTynb1c"
      },
      "source": [
        "## Задание\n",
        "\n",
        "Напишите код сортировки массива по столбцам:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XeyGvnv9nha8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "34ab27a9-f084-4ae8-e6b5-8824af4ddf4c"
      },
      "source": [
        "arr = np.array([\n",
        "    [11, 2, 1, 3, 5],\n",
        "    [6, 2, 0, -1, 10],\n",
        "    [1, 3, 2, 3, 5],\n",
        "    [5, 2, 7, 8, 9],\n",
        "])\n",
        "print(arr)\n",
        "\n",
        "# TODO - напишите код сортировки:\n",
        "# [[ 1  2  0 -1  5]\n",
        "#  [ 5  2  1  3  5]\n",
        "#  [ 6  2  2  3  9]\n",
        "#  [11  3  7  8 10]]\n",
        "\n",
        "print('----------')\n",
        "sortedarr = np.sort(arr,axis=0)\n",
        "print(sortedarr)"
      ],
      "execution_count": 116,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[11  2  1  3  5]\n",
            " [ 6  2  0 -1 10]\n",
            " [ 1  3  2  3  5]\n",
            " [ 5  2  7  8  9]]\n",
            "----------\n",
            "[[ 1  2  0 -1  5]\n",
            " [ 5  2  1  3  5]\n",
            " [ 6  2  2  3  9]\n",
            " [11  3  7  8 10]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q7HnQ1sydJy9"
      },
      "source": [
        "# Задачки"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G9GZ6RxEFl4R"
      },
      "source": [
        "Создайте массив, состоящий из случайных элементов в диапазоне $[-10; 20]$ размером $(5, 7)$:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nm7ygwgfF-2M",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7635075b-66f0-4e86-959c-489ef1c06941"
      },
      "source": [
        "# TODO - создайте массив со случайными целочисленными элементами\r\n",
        "array = np.random.randint(-10, 20, size=(5, 7))\r\n",
        "print(array)"
      ],
      "execution_count": 118,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ -4   6  -7   1  12   9  -2]\n",
            " [ 17   0   5  -9   3   1  -3]\n",
            " [  5   1  16   0  -4  -9 -10]\n",
            " [ -4  14   4   1   5   2  -4]\n",
            " [ 13  12   7 -10  -7   3  -9]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N7RHO3OQmZAv"
      },
      "source": [
        "Добавьте границу в виде нулей со всех сторон 2D массива:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3Eg9jmjLGief",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "86f6f79a-a07d-43b7-82e8-18b70168fcb1"
      },
      "source": [
        "data = np.arange(1, 16).reshape((3, 5))\n",
        "print(data)\n",
        "\n",
        "# TODO - реализуйте добавление нулей со всех сторон массива:\n",
        "# [[ 0  0  0  0  0  0  0]\n",
        "#  [ 0  1  2  3  4  5  0]\n",
        "#  [ 0  6  7  8  9 10  0]\n",
        "#  [ 0 11 12 13 14 15  0]\n",
        "#  [ 0  0  0  0  0  0  0]]\n",
        "print('----------')\n",
        "zeros = np.zeros((3,1))\n",
        "zeros1=np.zeros((1,7))\n",
        "arr1=np.concatenate((zeros,data,zeros), axis=1)\n",
        "arr1=np.concatenate((zeros1,arr1,zeros1), axis=0)\n",
        "print(arr1)"
      ],
      "execution_count": 131,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 1  2  3  4  5]\n",
            " [ 6  7  8  9 10]\n",
            " [11 12 13 14 15]]\n",
            "----------\n",
            "[[ 0.  0.  0.  0.  0.  0.  0.]\n",
            " [ 0.  1.  2.  3.  4.  5.  0.]\n",
            " [ 0.  6.  7.  8.  9. 10.  0.]\n",
            " [ 0. 11. 12. 13. 14. 15.  0.]\n",
            " [ 0.  0.  0.  0.  0.  0.  0.]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dZd4lWT7-A02"
      },
      "source": [
        "Разберитесь с функцией `np.clip()` и произведите ограничение массива, чтобы в нем значения были не более шести и не менее двух:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ux991dZdmpS4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "98b8f664-53ca-46b2-ebd5-979e5e3e96b4"
      },
      "source": [
        "data = np.arange(1, 16).reshape((3, 5))\n",
        "print(data)\n",
        "\n",
        "# TODO - ограничьте значения массива\n",
        "# [[2 2 3 4 5]\n",
        "#  [6 6 6 6 6]\n",
        "#  [6 6 6 6 6]]\n",
        "print('----------')\n",
        "print(np.clip(data, 2, 6)) "
      ],
      "execution_count": 134,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 1  2  3  4  5]\n",
            " [ 6  7  8  9 10]\n",
            " [11 12 13 14 15]]\n",
            "----------\n",
            "[[2 2 3 4 5]\n",
            " [6 6 6 6 6]\n",
            " [6 6 6 6 6]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GaK2Wjsc-ufd"
      },
      "source": [
        "Произведите модификацию массива так, чтобы значение в колонке результата соответствовало исходному значению, возведенному в степень индекса колонки:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hL1yy-0b-Ned",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7bc06de7-8b24-41f7-82b0-1d59fb167c0a"
      },
      "source": [
        "data = np.full((3, 5), fill_value=2, dtype=np.int32)\n",
        "print(data)\n",
        "\n",
        "# TODO - возведите значения в колонках в степень индекса колонки\n",
        "# [[ 1  2  4  8 16]\n",
        "#  [ 1  2  4  8 16]\n",
        "#  [ 1  2  4  8 16]]\n",
        "print('----------')\n",
        "stepeni=np.tile(np.arange(0,5),reps=(3, 1))\n",
        "print(stepeni)\n",
        "print('----------')\n",
        "print(np.power(data,stepeni))\n",
        "\n",
        "\n"
      ],
      "execution_count": 145,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[2 2 2 2 2]\n",
            " [2 2 2 2 2]\n",
            " [2 2 2 2 2]]\n",
            "----------\n",
            "[[0 1 2 3 4]\n",
            " [0 1 2 3 4]\n",
            " [0 1 2 3 4]]\n",
            "----------\n",
            "[[ 1  2  4  8 16]\n",
            " [ 1  2  4  8 16]\n",
            " [ 1  2  4  8 16]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UvwJTfMQE2Eh"
      },
      "source": [
        "Умножьте каждую колонку на ее индекс:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hV5rEePyE1VH",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "59e0a05e-8de5-43c8-c191-759e24ad9fc5"
      },
      "source": [
        "data = np.full((3, 5), fill_value=2, dtype=np.int32)\n",
        "print(data)\n",
        "\n",
        "# TODO - Умножьте каждый столбец на свой индекс\n",
        "# [[0 2 4 6 8]\n",
        "#  [0 2 4 6 8]\n",
        "#  [0 2 4 6 8]]\n",
        "\n",
        "print('----------')\n",
        "index=np.tile(np.arange(0,5),reps=(3, 1))\n",
        "print(index)\n",
        "print('----------')\n",
        "print(data*index)"
      ],
      "execution_count": 149,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[2 2 2 2 2]\n",
            " [2 2 2 2 2]\n",
            " [2 2 2 2 2]]\n",
            "----------\n",
            "[[0 1 2 3 4]\n",
            " [0 1 2 3 4]\n",
            " [0 1 2 3 4]]\n",
            "----------\n",
            "[[0 2 4 6 8]\n",
            " [0 2 4 6 8]\n",
            " [0 2 4 6 8]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VzMibei69GMQ"
      },
      "source": [
        "Умножьте каждый четный ряд в матрице на вектор:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BWkmzzWq-O3d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9d572a08-b18f-4bd4-8d4f-21ed08c6a6eb"
      },
      "source": [
        "data = np.repeat(np.arange(1, 8), 4).reshape(7, 4)\n",
        "vec = np.array([1, 2, 1, 2])\n",
        "print(data)\n",
        "\n",
        "# TODO - умножьте каждый четный ряд ????? в матрице на вектор\n",
        "# [[ 1  2  1  2]\n",
        "#  [ 2  2  2  2]\n",
        "#  [ 3  6  3  6]\n",
        "#  [ 4  4  4  4]\n",
        "#  [ 5 10  5 10]\n",
        "#  [ 6  6  6  6]\n",
        "#  [ 7 14  7 14]]\n",
        "\n",
        "print('----------')\n",
        "for i in range(0,7,2):\n",
        "  data[i,:] = data[i,:]*vec # умножил начиная с 0 индекса (не совсем согласен с тем, что это четный ряд)\n",
        "\n",
        "print(data)"
      ],
      "execution_count": 153,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[1 1 1 1]\n",
            " [2 2 2 2]\n",
            " [3 3 3 3]\n",
            " [4 4 4 4]\n",
            " [5 5 5 5]\n",
            " [6 6 6 6]\n",
            " [7 7 7 7]]\n",
            "----------\n",
            "[[ 1  2  1  2]\n",
            " [ 2  2  2  2]\n",
            " [ 3  6  3  6]\n",
            " [ 4  4  4  4]\n",
            " [ 5 10  5 10]\n",
            " [ 6  6  6  6]\n",
            " [ 7 14  7 14]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HkNh2J_BCXgo"
      },
      "source": [
        "Определите индексы двух наибольших элементов в матрице по каждому ряду:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oPta0_FI9phV",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8e27f0dd-0d2f-4ae1-816a-1f77ecb4e268"
      },
      "source": [
        "data = np.array([[20, 22,  2, 14, 25,  8],\n",
        "                [ 7, 25, 23,  3, 22, 15],\n",
        "                [ 8, 16,  9, 22,  0,  9],\n",
        "                [ 4, 24, 24, 28,  3, 40]])\n",
        "print(data)\n",
        "\n",
        "# TODO - определите индексы двух наибольших элементов по каждому ряду\n",
        "# [[4 1]\n",
        "#  [1 2]\n",
        "#  [3 1]\n",
        "#  [5 3]]\n",
        "print('----------')\n",
        "sort_from_min_to_max=np.argsort(data, axis=1) # сортируем индексы по строкам \n",
        "print(sort_from_min_to_max)\n",
        "print('----------RESULT-----------')\n",
        "print(sort_from_min_to_max[:,5:3:-1]) # выводим в обратном порядке\n",
        "\n"
      ],
      "execution_count": 160,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[20 22  2 14 25  8]\n",
            " [ 7 25 23  3 22 15]\n",
            " [ 8 16  9 22  0  9]\n",
            " [ 4 24 24 28  3 40]]\n",
            "----------\n",
            "[[2 5 3 0 1 4]\n",
            " [3 0 5 4 2 1]\n",
            " [4 0 2 5 1 3]\n",
            " [4 0 1 2 3 5]]\n",
            "----------RESULT-----------\n",
            "[[4 1]\n",
            " [1 2]\n",
            " [3 1]\n",
            " [5 3]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dHWhvnrxGNbi"
      },
      "source": [
        "Выберите две случайные колонки из массива:\n",
        "\n",
        "<details>\n",
        "<summary>Подсказка 1</summary>\n",
        "\n",
        "Для случайного выбора полезно воспользоваться функцией `np.random.choice()`\n",
        "</details>\n",
        "\n",
        "<details>\n",
        "<summary>Подсказка 2</summary>\n",
        "\n",
        "`np.random.choice()` принимает на вход 1D массив, так что для выбора можно создать массив индексов колонок (`range()` с количеством колонок) и из него функция выберет два случайных индекса\n",
        "</details>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QyOXcEMSGWhJ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5c08db5f-547a-4a68-dc4d-2ae85ade2238"
      },
      "source": [
        "data = np.array([[20, 22,  2, 14, 25,  8],\n",
        "                [ 7, 25, 23,  3, 22, 15],\n",
        "                [ 8, 16,  9, 22,  0,  9],\n",
        "                [ 4, 24, 24, 28,  3, 40]])\n",
        "print(data)\n",
        "\n",
        "# TODO - выберите случайные две колонки из массива\n",
        "# *Например,\n",
        "# [[22  8]\n",
        "#  [25 15]\n",
        "#  [16  9]\n",
        "#  [24 40]]\n",
        "\n",
        "print('----------')\n",
        "index=np.arange(0,5) # индексы колонок\n",
        "rand = np.random.choice(index,size=2) # выбираем 2 рандомных числа\n",
        "print(rand)\n",
        "print('----------')\n",
        "data1=data[:,rand[0]]# первый выбранный рандомный столбец\n",
        "data2=data[:,rand[1]] # второй выбранный рандомный столбец\n",
        "data3=np.concatenate((data1,data2),axis=0) # объединяем\n",
        "data3=data3.reshape((2,4)) # делаем нужной формы\n",
        "print(data3.T) # транспонируем\n",
        "\n"
      ],
      "execution_count": 195,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[20 22  2 14 25  8]\n",
            " [ 7 25 23  3 22 15]\n",
            " [ 8 16  9 22  0  9]\n",
            " [ 4 24 24 28  3 40]]\n",
            "----------\n",
            "[4 0]\n",
            "----------\n",
            "[[25 20]\n",
            " [22  7]\n",
            " [ 0  8]\n",
            " [ 3  4]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2klcFh_wKeZl"
      },
      "source": [
        "Создайте массив размером $(10, 3)$, который состоит из повторяющихся рядов исходного массива:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "V3iiVqlRKnlw",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7250878f-70c4-46ff-a326-0eb930197f86"
      },
      "source": [
        "data = np.arange(9).reshape(3, 3)\n",
        "print(data)\n",
        "\n",
        "# TODO - создайте массив из повторяющихся рядов размером (10, 3)\n",
        "# *Например,\n",
        "# [[3 4 5]\n",
        "#  [6 7 8]\n",
        "#  [0 1 2]\n",
        "#  [6 7 8]\n",
        "#  [3 4 5]\n",
        "#  [6 7 8]\n",
        "#  [6 7 8]\n",
        "#  [6 7 8]\n",
        "#  [6 7 8]\n",
        "#  [0 1 2]]\n",
        "\n",
        "index=np.arange(0,3) # индексы строк\n",
        "array_of_random_numbers = np.random.choice(index,size=10)\n",
        "data=np.tile(data,(4, 1))\n",
        "print('----------')\n",
        "for i in range(0,10,1):\n",
        "  data[i,:] = data[array_of_random_numbers[i],:] \n",
        "\n",
        "print(data[0:10,:])"
      ],
      "execution_count": 237,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[0 1 2]\n",
            " [3 4 5]\n",
            " [6 7 8]]\n",
            "----------\n",
            "[[0 1 2]\n",
            " [6 7 8]\n",
            " [0 1 2]\n",
            " [0 1 2]\n",
            " [0 1 2]\n",
            " [6 7 8]\n",
            " [0 1 2]\n",
            " [0 1 2]\n",
            " [0 1 2]\n",
            " [0 1 2]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SH70EM7FIyqL"
      },
      "source": [
        "Соберите массив, состоящий из элементов 2й и 4й колонок и строк с 1й по 3ю:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "c6KbqmPBDYaJ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b44a3d67-3a3c-4f25-c786-838357bafb27"
      },
      "source": [
        "data = np.array([[20, 22,  2, 14, 25,  8],\n",
        "                [ 7, 25, 23,  3, 22, 15],\n",
        "                [ 8, 16,  9, 22,  0,  9],\n",
        "                [ 14, 9,  33, 21,  7,  6],\n",
        "                [ 4, 24, 24, 28,  3, 40]])\n",
        "print(data)\n",
        "# TODO - соберите матрицу из конкретных элементов массива\n",
        "# [[23 22]\n",
        "#  [ 9  0]\n",
        "#  [33  7]]\n",
        "\n",
        "print('----------')\n",
        "\n",
        "print(data[1:4,[2,4]]) # от первой до 3 строки  и столбцов 2 и 4"
      ],
      "execution_count": 241,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[20 22  2 14 25  8]\n",
            " [ 7 25 23  3 22 15]\n",
            " [ 8 16  9 22  0  9]\n",
            " [14  9 33 21  7  6]\n",
            " [ 4 24 24 28  3 40]]\n",
            "----------\n",
            "[[23 22]\n",
            " [ 9  0]\n",
            " [33  7]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vS3kwb59Jee2"
      },
      "source": [
        "Инвертируйте порядок элементов в последних двух колонках:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wTKNzMf9Jd3g",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "50d91724-e611-4a96-dcb4-aa6df3d46d7b"
      },
      "source": [
        "data = np.array([[20, 22,  2, 14, 25,  8],\n",
        "                [ 7, 25, 23,  3, 22, 15],\n",
        "                [ 8, 16,  9, 22,  0,  9],\n",
        "                [ 14, 9,  33, 21,  7,  6],\n",
        "                [ 4, 24, 24, 28,  3, 40]])\n",
        "print(data)\n",
        "# TODO - инвертируйте порядок последних двух колонок\n",
        "# [[20 22  2 14  3 40]\n",
        "#  [ 7 25 23  3  7  6]\n",
        "#  [ 8 16  9 22  0  9]\n",
        "#  [14  9 33 21 22 15]\n",
        "#  [ 4 24 24 28 25  8]]\n",
        "\n",
        "print('----------')\n",
        "\n",
        "data_left=data[:,0:4] # левая сторона массива\n",
        "data_right=np.flip(data[:,4:6], axis = 0) # меняем порядок в двух последних колонках\n",
        "data_combined=np.column_stack((data_left,data_right)) # правая сторона массива\n",
        "print(data_combined)"
      ],
      "execution_count": 248,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[20 22  2 14 25  8]\n",
            " [ 7 25 23  3 22 15]\n",
            " [ 8 16  9 22  0  9]\n",
            " [14  9 33 21  7  6]\n",
            " [ 4 24 24 28  3 40]]\n",
            "----------\n",
            "[[20 22  2 14  3 40]\n",
            " [ 7 25 23  3  7  6]\n",
            " [ 8 16  9 22  0  9]\n",
            " [14  9 33 21 22 15]\n",
            " [ 4 24 24 28 25  8]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lr9Ecb42JIQm"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}