Data Manipuation with Numpy.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "id": "9fc2fc06-b6c5-4520-b4ba-370c960a309b",
      "metadata": {
        "id": "9fc2fc06-b6c5-4520-b4ba-370c960a309b"
      },
      "source": [
        "# Data Manipulation with Numpy"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "b54d4615-400d-4004-8786-be7990e75436",
      "metadata": {
        "id": "b54d4615-400d-4004-8786-be7990e75436"
      },
      "source": [
        "**NumPy** is the fundamental package for scientific computing in Python. It is a Python library that provides a multidimensional array object, various derived objects (such as masked arrays and matrices), and an assortment of routines for fast operations on arrays, including mathematical, logical, shape manipulation, sorting, selecting, I/O, discrete Fourier transforms, basic linear algebra, basic statistical operations, random simulation and much more.\n",
        "\n",
        "NumPy is a library for the Python programming language, adding support for large, multi-dimensional arrays and matrices, along with a large collection of high-level mathematical functions to operate on these arrays"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "6506d52d-a30a-40f7-bebb-f10dbf429985",
      "metadata": {
        "id": "6506d52d-a30a-40f7-bebb-f10dbf429985"
      },
      "outputs": [],
      "source": [
        "# uncomment, the below line and run the cell to install numpy\n",
        "# !pip install numpy"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "22abbe52-8bfa-4a99-a440-183fc65b1f7e",
      "metadata": {
        "id": "22abbe52-8bfa-4a99-a440-183fc65b1f7e"
      },
      "source": [
        "1. Import numpy"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "d8ac99c3-acb8-467b-8c41-a1e1e7a2e2e6",
      "metadata": {
        "id": "d8ac99c3-acb8-467b-8c41-a1e1e7a2e2e6"
      },
      "outputs": [],
      "source": [
        "# import numpy\n",
        "import numpy as np\n",
        "from numpy import array\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "aadb3f55-59d0-435f-a1d4-e9128bae743c",
      "metadata": {
        "id": "aadb3f55-59d0-435f-a1d4-e9128bae743c"
      },
      "source": [
        "2. create a one dimensional array"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "339480df-7add-4b78-ada3-2e2a9e63294d",
      "metadata": {
        "id": "339480df-7add-4b78-ada3-2e2a9e63294d"
      },
      "outputs": [],
      "source": [
        "# create array\n",
        "arr = np.array([2, 3, 4, 1, 0, -2, 7, 8, 9, 12])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "277d3e62-acbf-491d-8395-bf7b31b418ec",
      "metadata": {
        "id": "277d3e62-acbf-491d-8395-bf7b31b418ec",
        "outputId": "6a707c44-8f71-4c39-a1fb-ea54d0f5e56d"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([ 1,  7,  8,  9, 12])"
            ]
          },
          "execution_count": 45,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "arr[3:]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "5007828e-1dad-4535-a767-c7052d56e27d",
      "metadata": {
        "id": "5007828e-1dad-4535-a767-c7052d56e27d",
        "outputId": "a2a53844-dbc7-4cba-80f8-9d3908154ed0"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "'for i in arr:\\n    print(i)'"
            ]
          },
          "execution_count": 47,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "\"\"\"for i in arr:\n",
        "    print(i)\"\"\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "ad4eeaa9-3d88-4abe-a3f7-e4d0238b3e95",
      "metadata": {
        "id": "ad4eeaa9-3d88-4abe-a3f7-e4d0238b3e95"
      },
      "outputs": [],
      "source": [
        "#dir(arr)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "2d857ac2-df57-4b43-abe9-a22569ad72cf",
      "metadata": {
        "id": "2d857ac2-df57-4b43-abe9-a22569ad72cf"
      },
      "source": [
        "check the dimension of the array"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "eb04b2de-9207-4212-aece-d197c2a2c30f",
      "metadata": {
        "id": "eb04b2de-9207-4212-aece-d197c2a2c30f",
        "outputId": "da5256ab-81cf-4953-b086-ebba9c107954"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "execution_count": 52,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# check the dimension of the array\n",
        "arr.ndim"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "e1e26148-b8e7-4162-b3b1-07be1d6bb85f",
      "metadata": {
        "id": "e1e26148-b8e7-4162-b3b1-07be1d6bb85f"
      },
      "source": [
        "check the size of the array"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "6ea59f83-8a5c-477e-b29f-8f824486fcc6",
      "metadata": {
        "id": "6ea59f83-8a5c-477e-b29f-8f824486fcc6",
        "outputId": "ccfdaf33-cd08-44e9-feda-f2d11e9e4452"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "8"
            ]
          },
          "execution_count": 54,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# size of the array\n",
        "arr.size"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "aca1cf7a-da56-466e-b0fc-469217001164",
      "metadata": {
        "id": "aca1cf7a-da56-466e-b0fc-469217001164",
        "outputId": "4801ddec-09e8-4655-f878-e20d642d1646"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "8"
            ]
          },
          "execution_count": 56,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "len(arr)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "9ee6bfdd-60a3-4dab-90f5-8569cfcb503b",
      "metadata": {
        "id": "9ee6bfdd-60a3-4dab-90f5-8569cfcb503b"
      },
      "source": [
        "check the shape of the array"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "e2306aa6-b7b4-45f5-9548-b2eead4ea922",
      "metadata": {
        "id": "e2306aa6-b7b4-45f5-9548-b2eead4ea922",
        "outputId": "cf2858c0-1ace-441b-c7cb-cddc72e4b958"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(8,)"
            ]
          },
          "execution_count": 55,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# shape of the array\n",
        "arr.shape"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "cbd98474-6538-4fd1-b8b7-778dca12c44d",
      "metadata": {
        "id": "cbd98474-6538-4fd1-b8b7-778dca12c44d"
      },
      "source": [
        "Identify the type of the array"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "3e8dce3d-60a5-448f-86af-276c936342cb",
      "metadata": {
        "id": "3e8dce3d-60a5-448f-86af-276c936342cb",
        "outputId": "f16528dc-7050-4df6-f9fb-a1f28f2f6a3f"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "dtype('int64')"
            ]
          },
          "execution_count": 62,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# idntify the type of the array\n",
        "arr.dtype"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "8e6e0e05-5484-4d79-8dab-4d280d4d8a3b",
      "metadata": {
        "id": "8e6e0e05-5484-4d79-8dab-4d280d4d8a3b",
        "outputId": "058154fd-db3a-4a86-b497-46452de23d53"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[ 2  3  4  1  7  8  9 12]\n"
          ]
        }
      ],
      "source": [
        "print(arr)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "dcbcaca8-baa7-4e91-b78e-494573a38d60",
      "metadata": {
        "id": "dcbcaca8-baa7-4e91-b78e-494573a38d60"
      },
      "source": [
        "sum of the array elements"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "b5ec6225-fbd1-4261-afa4-fcf9e1a1c909",
      "metadata": {
        "id": "b5ec6225-fbd1-4261-afa4-fcf9e1a1c909",
        "outputId": "276034ce-2177-4f7f-d2c5-06276874fe8a"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "44"
            ]
          },
          "execution_count": 69,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# sum of array elements\n",
        "sum(arr)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "1ce4a36e-17a1-4f6d-8049-ec185d6e17ec",
      "metadata": {
        "id": "1ce4a36e-17a1-4f6d-8049-ec185d6e17ec"
      },
      "source": [
        "min and max elements from the array"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "f5ad1514-9960-4658-91ad-ff590f7b663f",
      "metadata": {
        "id": "f5ad1514-9960-4658-91ad-ff590f7b663f",
        "outputId": "77445fd4-b81e-4a16-89ba-2f6906f566c5"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "-2"
            ]
          },
          "execution_count": 71,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# print min and max\n",
        "min(arr)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "6e237763-728f-4a0e-b65b-8b5708f3f515",
      "metadata": {
        "id": "6e237763-728f-4a0e-b65b-8b5708f3f515"
      },
      "source": [
        "sort array elements\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "2e544f27-5d97-4402-9acf-5dea3e3c78a0",
      "metadata": {
        "id": "2e544f27-5d97-4402-9acf-5dea3e3c78a0",
        "outputId": "2943a2f5-32cf-4ae9-9c4f-63c473a70849"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[12, 9, 8, 7, 4, 3, 2, 1, 0, -2]"
            ]
          },
          "execution_count": 80,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# sort array\n",
        "sorted(arr, reverse=True)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "f0007529-6d28-4492-b64c-4fd2abb056f9",
      "metadata": {
        "id": "f0007529-6d28-4492-b64c-4fd2abb056f9"
      },
      "source": [
        "3. Create two dimensional array"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "1f6e2ed0-5765-4e78-84b8-310cb514f289",
      "metadata": {
        "id": "1f6e2ed0-5765-4e78-84b8-310cb514f289"
      },
      "outputs": [],
      "source": [
        "# create two dimensional array\n",
        "arr_2d = np.array([\n",
        "    [2, 3, 6],\n",
        "    [3, 4, 5],\n",
        "    [3, 2, 4]\n",
        "])\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "95d25487-48b8-4661-8d7d-969fba0c3315",
      "metadata": {
        "id": "95d25487-48b8-4661-8d7d-969fba0c3315",
        "outputId": "5a4c7804-e683-4798-9bb4-7d35854599f9"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "execution_count": 96,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "arr_2d.ndim"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "ed4507a2-437c-4f02-bcdf-4daa72215798",
      "metadata": {
        "id": "ed4507a2-437c-4f02-bcdf-4daa72215798",
        "outputId": "79096c09-0f6a-4017-a120-e7be58b7bab0"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "9"
            ]
          },
          "execution_count": 97,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "arr_2d.size"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "bd3f3f2b-d674-475c-a362-d039385c2bdf",
      "metadata": {
        "id": "bd3f3f2b-d674-475c-a362-d039385c2bdf",
        "outputId": "83e4d376-8672-4c8c-9017-593e4387828a"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(3, 3)"
            ]
          },
          "execution_count": 98,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "arr_2d.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "4a3bb06e-7779-4807-8512-7cd5db1f805e",
      "metadata": {
        "id": "4a3bb06e-7779-4807-8512-7cd5db1f805e",
        "outputId": "7a088471-1502-4b39-bba7-7ccc4db4b35d"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "4"
            ]
          },
          "execution_count": 99,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "arr_2d[2][2]"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "fb010b2e-bff7-4c54-8e0c-97ab0d271552",
      "metadata": {
        "id": "fb010b2e-bff7-4c54-8e0c-97ab0d271552"
      },
      "source": [
        "4. another way of create an array using `arange()`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "cd270b40-1ee2-4224-8833-1122fbe09d89",
      "metadata": {
        "id": "cd270b40-1ee2-4224-8833-1122fbe09d89",
        "outputId": "2616114d-f958-4d78-d08d-f39216435a51"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[0., 1., 2., 3., 4.],\n",
              "       [5., 6., 7., 8., 9.]])"
            ]
          },
          "execution_count": 123,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# another way of creating an array\n",
        "# arange() function\n",
        "arr_a = np.arange(0, 10, dtype=\"float64\").reshape(2, 5)\n",
        "arr_a"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "42045a2e-a317-426a-bd3f-b03dde43584f",
      "metadata": {
        "id": "42045a2e-a317-426a-bd3f-b03dde43584f"
      },
      "source": [
        "5. specify the data type of the array while creating the array using `dtype`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "3e194a2e-0e7b-430e-876d-caa1af689496",
      "metadata": {
        "id": "3e194a2e-0e7b-430e-876d-caa1af689496",
        "outputId": "7906df70-a9fd-421b-f8ea-0b6159a97521"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([2. , 3.1, 4. ])"
            ]
          },
          "execution_count": 121,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "ar = np.array([2.0, 3.1,4], dtype='float64')\n",
        "ar"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "51c3eaa2-c170-45e0-9dd1-38e3e129da83",
      "metadata": {
        "id": "51c3eaa2-c170-45e0-9dd1-38e3e129da83"
      },
      "source": [
        "# Part II\n",
        "- adding\n",
        "- removing\n",
        "\n",
        "array elements\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "312a167e-3da5-4657-b442-52879b5507b2",
      "metadata": {
        "id": "312a167e-3da5-4657-b442-52879b5507b2"
      },
      "outputs": [],
      "source": [
        "# import the numpy\n",
        "import numpy as np"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "0ff28c36-7663-4f38-a36b-2af28b06e885",
      "metadata": {
        "id": "0ff28c36-7663-4f38-a36b-2af28b06e885"
      },
      "source": [
        "Let's create both one and two dimensional array"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "f4a19614-cfa3-4dea-bf13-876f09ba8a50",
      "metadata": {
        "id": "f4a19614-cfa3-4dea-bf13-876f09ba8a50"
      },
      "outputs": [],
      "source": [
        "# create one dimensional array\n",
        "arr_1d = np.arange(2, 21, 2)\n",
        "\n",
        "# create two dimensional array\n",
        "arr_2d = np.arange(1,16).reshape(5, 3)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "b3b548ce-e4fc-4d2f-92c0-1ad8df4bd0eb",
      "metadata": {
        "id": "b3b548ce-e4fc-4d2f-92c0-1ad8df4bd0eb",
        "outputId": "e9f95988-875a-46f3-88f6-17228c54177a"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[ 2  4  6  8 10 12 14 16 18 20]\n"
          ]
        }
      ],
      "source": [
        "print(arr_1d)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "18529f67-be12-49e7-a0cd-af6e54170f8e",
      "metadata": {
        "id": "18529f67-be12-49e7-a0cd-af6e54170f8e",
        "outputId": "e2a80f9c-f783-41d8-fb0b-8f66ff22120a"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[ 1  2  3]\n",
            " [ 4  5  6]\n",
            " [ 7  8  9]\n",
            " [10 11 12]\n",
            " [13 14 15]]\n"
          ]
        }
      ],
      "source": [
        "print(arr_2d)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "b9ffb709-6c93-4fb0-b3bb-07ac2bec11f9",
      "metadata": {
        "id": "b9ffb709-6c93-4fb0-b3bb-07ac2bec11f9"
      },
      "source": [
        "## `append()` - appends values to the end of an array"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "e4303fed-dbe9-4f84-bb2c-22a5143b94f4",
      "metadata": {
        "id": "e4303fed-dbe9-4f84-bb2c-22a5143b94f4",
        "outputId": "5aa5015e-0904-4a1e-fd37-46275b1ed698"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "1D array before append: [ 2  4  6  8 10 12 14 16 18 20] 10\n",
            "[ 2  4  6  8 10 12 14 16 18 20 40]\n",
            "[ 2  4  6  8 10 12 14 16 18 20  1  2  3  4]\n"
          ]
        }
      ],
      "source": [
        "# append new values into 1D array\n",
        "\n",
        "print(\"1D array before append:\", arr_1d, arr_1d.size)\n",
        "print(np.append(arr_1d, 40))\n",
        "print(np.append(arr_1d, np.arange(1, 5)))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "abe4f3d3-d12d-4ea9-aa3d-12c68822a1be",
      "metadata": {
        "id": "abe4f3d3-d12d-4ea9-aa3d-12c68822a1be",
        "outputId": "99178d98-0c6a-40c8-b14e-9dd7f7f7b2ab"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "2D before appended: [[ 1  2  3]\n",
            " [ 4  5  6]\n",
            " [ 7  8  9]\n",
            " [10 11 12]\n",
            " [13 14 15]]\n",
            "[[ 1  2  3]\n",
            " [ 4  5  6]\n",
            " [ 7  8  9]\n",
            " [10 11 12]\n",
            " [13 14 15]\n",
            " [20 30 40]]\n",
            "[[ 1  2  3]\n",
            " [ 4  5  6]\n",
            " [ 7  8  9]\n",
            " [10 11 12]\n",
            " [13 14 15]\n",
            " [ 1  2  3]\n",
            " [ 4  5  6]]\n"
          ]
        }
      ],
      "source": [
        "# append new values into 2D with column wise\n",
        "print(\"2D before appended:\",arr_2d)\n",
        "\n",
        "print(np.append(arr_2d, [[20, 30, 40]], axis=0))\n",
        "\n",
        "print(np.append(arr_2d, np.arange(1, 7).reshape(2, 3), axis=0))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "66177e56-467b-486b-8038-1c0eb6f35ead",
      "metadata": {
        "id": "66177e56-467b-486b-8038-1c0eb6f35ead",
        "outputId": "2828af77-387e-4983-af10-5426ae36c480"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "2D before appended: [[ 1  2  3]\n",
            " [ 4  5  6]\n",
            " [ 7  8  9]\n",
            " [10 11 12]\n",
            " [13 14 15]]\n",
            "[[ 1  2  3 20]\n",
            " [ 4  5  6 30]\n",
            " [ 7  8  9 40]\n",
            " [10 11 12 20]\n",
            " [13 14 15 15]]\n",
            "[[ 1  2  3  1  2]\n",
            " [ 4  5  6  3  4]\n",
            " [ 7  8  9  5  6]\n",
            " [10 11 12  7  8]\n",
            " [13 14 15  9 10]]\n"
          ]
        }
      ],
      "source": [
        "# append new vlaues into 2D with row wise\n",
        "print(\"2D before appended:\",arr_2d)\n",
        "\n",
        "print(np.append(arr_2d, [[20], [30], [40], [20],[15]], axis=1))\n",
        "\n",
        "print(np.append(arr_2d, np.arange(1, 11).reshape(5, 2), axis=1))"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "e8b8c8e4-7657-4b18-b45a-cdb57375a441",
      "metadata": {
        "id": "e8b8c8e4-7657-4b18-b45a-cdb57375a441"
      },
      "source": [
        "## `insert()` - insert elements into an array"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "77eaba44-a1ab-4bd5-a935-90c052e7eab2",
      "metadata": {
        "id": "77eaba44-a1ab-4bd5-a935-90c052e7eab2",
        "outputId": "2b7246ff-625e-4f4f-adbc-7251eb89aa6b"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "1D array before insert new element: [ 2  4  6  8 10 12 14 16 18 20] (10,)\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "array([ 2, 22, 23, 24,  4,  6,  8, 10, 12, 14, 16, 18, 20])"
            ]
          },
          "execution_count": 193,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# insert values into 1D array\n",
        "print(\"1D array before insert new element:\", arr_1d, arr_1d.shape)\n",
        "\n",
        "np.insert(arr_1d, 1, np.arange(22, 25))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "63bc0add-332a-4076-b3d9-e9a5e23de994",
      "metadata": {
        "id": "63bc0add-332a-4076-b3d9-e9a5e23de994",
        "outputId": "dfc9b881-3952-4447-ee76-5e04a5fde536"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[ 1  2  3]\n",
            " [ 4  5  6]\n",
            " [ 7  8  9]\n",
            " [10 11 12]\n",
            " [13 14 15]] (5, 3)\n",
            "after inserted\n",
            "at different points\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "array([[20,  1,  2,  3, 20],\n",
              "       [20,  4,  5,  6, 20],\n",
              "       [20,  7,  8,  9, 20],\n",
              "       [20, 10, 11, 12, 20],\n",
              "       [20, 13, 14, 15, 20]])"
            ]
          },
          "execution_count": 197,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# insert values into 2D with at different points\n",
        "print(arr_2d, arr_2d.shape)\n",
        "\n",
        "print(\"after inserted\")\n",
        "np.insert(arr_2d, 2, 66, axis=1)\n",
        "print(\"at different points\")\n",
        "np.insert(arr_2d, (0, 3), 20, axis=1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "9bbc09f3-b7be-4b1f-83b7-48872f9d3636",
      "metadata": {
        "id": "9bbc09f3-b7be-4b1f-83b7-48872f9d3636",
        "outputId": "0e00ccd6-5e09-4cd3-e898-c31212a5dd90"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[ 1,  2,  2,  3],\n",
              "       [ 4,  5,  4,  6],\n",
              "       [ 7,  8,  3,  9],\n",
              "       [10, 11,  5, 12],\n",
              "       [13, 14,  6, 15]])"
            ]
          },
          "execution_count": 211,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# insert into 2D with scalars\n",
        "np.insert(arr_2d, [2], [[2], [4], [3], [5], [6]], axis=1)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "a0a9d99f-560d-406e-ba75-7bea67f0bdcc",
      "metadata": {
        "id": "a0a9d99f-560d-406e-ba75-7bea67f0bdcc"
      },
      "source": [
        "## `delete()` - delete elements from an array"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "164d9a80-1a57-49cb-a213-d6c1b6329727",
      "metadata": {
        "id": "164d9a80-1a57-49cb-a213-d6c1b6329727",
        "outputId": "6bd8b075-1f85-4c3d-d7ef-5b465ff18bc1"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[ 2  4  6  8 10 12 14 16 18 20]\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "array([ 2,  6,  8, 12, 14, 18, 20])"
            ]
          },
          "execution_count": 215,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# delete any element from the array\n",
        "# deleting from 1D\n",
        "\n",
        "print(arr_1d)\n",
        "np.delete(arr_1d, [1, 4, 7])\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "0e022555-230b-41d6-b489-123a7e9bf97c",
      "metadata": {
        "id": "0e022555-230b-41d6-b489-123a7e9bf97c",
        "outputId": "55fc3e0e-41e2-4447-c853-d3f97f321b63"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[ 1  2  3]\n",
            " [ 4  5  6]\n",
            " [ 7  8  9]\n",
            " [10 11 12]\n",
            " [13 14 15]]\n",
            "after deleting\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "array([[ 1,  2],\n",
              "       [ 4,  5],\n",
              "       [ 7,  8],\n",
              "       [10, 11],\n",
              "       [13, 14]])"
            ]
          },
          "execution_count": 224,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# deleting from 2D\n",
        "print(arr_2d)\n",
        "print(\"after deleting\")\n",
        "np.delete(arr_2d, 2, 1)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "aefe7d6e-b4a6-4c3c-977e-c1daf835fac1",
      "metadata": {
        "id": "aefe7d6e-b4a6-4c3c-977e-c1daf835fac1"
      },
      "source": [
        "# Part III\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "64655046-f23f-4f64-b156-9c07c3048726",
      "metadata": {
        "id": "64655046-f23f-4f64-b156-9c07c3048726"
      },
      "source": [
        "# Data Manipulation with Numpy\n",
        "\n",
        "# Statistics I\n",
        "from this tutorial you w'll be able to learn how to:\n",
        "- calculate the median\n",
        "- calculate mean\n",
        "- calculate weighted average"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "fafd6828-e419-4eea-bb80-cd4f27490f4f",
      "metadata": {
        "id": "fafd6828-e419-4eea-bb80-cd4f27490f4f"
      },
      "outputs": [],
      "source": [
        "# import numpy\n",
        "import numpy as np"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "f0cca1cf-4a9f-40ee-85de-6111309c211f",
      "metadata": {
        "id": "f0cca1cf-4a9f-40ee-85de-6111309c211f"
      },
      "source": [
        "Create 2D array"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "aa25f995-3213-4d49-99f2-08a44db4e2f9",
      "metadata": {
        "id": "aa25f995-3213-4d49-99f2-08a44db4e2f9",
        "outputId": "9fb1de19-8181-4a7e-9cce-56fcc4609b5f"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[ 1,  3,  5,  7,  9],\n",
              "       [11, 13, 15, 17, 19],\n",
              "       [21, 23, 25, 27, 29],\n",
              "       [31, 33, 35, 37, 39],\n",
              "       [41, 43, 45, 47, 49]])"
            ]
          },
          "execution_count": 51,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# create 2D array\n",
        "arr_2d = np.arange(1, 50, 2).reshape(5, 5)\n",
        "arr_2d"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "15273736-6964-4e31-8b4d-5d2d0054442c",
      "metadata": {
        "id": "15273736-6964-4e31-8b4d-5d2d0054442c",
        "outputId": "d5ec67b2-3538-434f-aa33-e9b1535a9ef2"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(5, 5)"
            ]
          },
          "execution_count": 52,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "arr_2d.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "dcbb26a7-3430-4da6-a67a-fb87e4d2afab",
      "metadata": {
        "id": "dcbb26a7-3430-4da6-a67a-fb87e4d2afab",
        "outputId": "c4a817da-ef08-47dc-cd9c-c1650be81364"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "25"
            ]
          },
          "execution_count": 53,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "arr_2d.size"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "79b1f5c8-160d-4eea-b3c0-e62b305b4d30",
      "metadata": {
        "id": "79b1f5c8-160d-4eea-b3c0-e62b305b4d30"
      },
      "source": [
        "1. Compute the median of array elements along specified axis"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "61335a61-b15e-4cda-be49-402c072336d3",
      "metadata": {
        "id": "61335a61-b15e-4cda-be49-402c072336d3"
      },
      "source": [
        "**Note**: Given a vector `V` of length `N`, the median of `V` is the middle value of a sorted copy of `V`, `V_sorted` - i e., `V_sorted[(N-1)/2]`, when `N` is odd, and the average of the two middle values of `V_sorted` when `N` is even."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "f3805fb7-4125-4958-9f24-1d0260688eb2",
      "metadata": {
        "id": "f3805fb7-4125-4958-9f24-1d0260688eb2",
        "outputId": "a7835848-8e66-4c2b-a796-a3145c33a142"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "25.0"
            ]
          },
          "execution_count": 54,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# find the median\n",
        "np.median(arr_2d)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "c9106879-33a6-4bff-823d-9266db1a3ed4",
      "metadata": {
        "id": "c9106879-33a6-4bff-823d-9266db1a3ed4",
        "outputId": "e6b97441-a8f0-49da-a102-995f473f0e08"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[ 1,  3,  5,  7,  9],\n",
              "       [11, 13, 15, 17, 19],\n",
              "       [21, 23, 25, 27, 29],\n",
              "       [31, 33, 35, 37, 39],\n",
              "       [41, 43, 45, 47, 49]])"
            ]
          },
          "execution_count": 56,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "arr_2d"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "2ea50df8-de98-4c6f-832b-8fc9f773bc38",
      "metadata": {
        "id": "2ea50df8-de98-4c6f-832b-8fc9f773bc38",
        "outputId": "381498e8-5dfa-4ed1-b2a0-8a90ce89ffe3"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([ 5., 15., 25., 35., 45.])"
            ]
          },
          "execution_count": 57,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "np.median(arr_2d, axis=1)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "931dcd2a-ed61-4a84-ac0c-6dc96ff3628a",
      "metadata": {
        "id": "931dcd2a-ed61-4a84-ac0c-6dc96ff3628a"
      },
      "source": [
        "2. Find the mean of array elements along specified axis"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "9ad2718d-90f5-4865-89a9-6bb4b5b710a6",
      "metadata": {
        "id": "9ad2718d-90f5-4865-89a9-6bb4b5b710a6",
        "outputId": "045a7915-e4ef-4920-9ab2-a97e12502d35"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([ 5., 15., 25., 35., 45.])"
            ]
          },
          "execution_count": 60,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# find the mean\n",
        "np.mean(arr_2d, axis=1)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "70d24085-8501-473b-92d7-bb04094749a4",
      "metadata": {
        "id": "70d24085-8501-473b-92d7-bb04094749a4"
      },
      "source": [
        "3. Find weighted average of array elements along specified axis"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "b8909c97-2d8c-49fc-b898-8a00b35c700d",
      "metadata": {
        "id": "b8909c97-2d8c-49fc-b898-8a00b35c700d"
      },
      "source": [
        "An array of weights associated with the values in `array_2d`. Each value in `arr_2d` contributes to the average according to its associated weight. The weights array can either be `1-D` (in which case its length must be the size of a along the given axis) or of the same shape as `arr_2d`. If weights=None, then all data in `arr_2d` are assumed to have a weight equal to one. The 1-D calculation is:"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "71daf0ce-a159-4f40-bae1-4acc3341f2f3",
      "metadata": {
        "id": "71daf0ce-a159-4f40-bae1-4acc3341f2f3"
      },
      "source": [
        "`average = sum(array_2d * weights) / sum(weights)`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "0c735c17-191c-4189-8056-358ecb20746d",
      "metadata": {
        "id": "0c735c17-191c-4189-8056-358ecb20746d",
        "outputId": "0297a09c-254c-4640-eadb-e08302dd2cbd"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[ 1,  3,  5,  7,  9],\n",
              "       [11, 13, 15, 17, 19],\n",
              "       [21, 23, 25, 27, 29],\n",
              "       [31, 33, 35, 37, 39],\n",
              "       [41, 43, 45, 47, 49]])"
            ]
          },
          "execution_count": 63,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "arr_2d"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "2df4671f-fbe9-4ac9-92cb-69c084f919f6",
      "metadata": {
        "id": "2df4671f-fbe9-4ac9-92cb-69c084f919f6",
        "outputId": "780e3f15-0ff9-4354-c6e4-8cf2b95bcc63"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([ 6.63636364, 16.63636364, 26.63636364, 36.63636364, 46.63636364])"
            ]
          },
          "execution_count": 64,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# find the average\n",
        "np.average(arr_2d, axis=1, weights=[1, 2, 0, 3, 5])"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "18e8f05e-b416-471b-9b9a-cb8b6a01efdc",
      "metadata": {
        "id": "18e8f05e-b416-471b-9b9a-cb8b6a01efdc"
      },
      "source": [
        "\n",
        "# Quantiles and Percentile with Numpy\n",
        "\n",
        "In statistics and probability, quantiles are cut points dividing the range of a probability distribution into continuous intervals with equal probabilities, or dividing the observations in a sample in the same way. There is one fewer quantile than the number of groups created."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "8e341195-7005-449c-8de5-47e1f22b2c3d",
      "metadata": {
        "id": "8e341195-7005-449c-8de5-47e1f22b2c3d"
      },
      "source": [
        "Let's assume you have a dataset which stores list of person's heights. The height is in cm which are stored in a variable named heights.\n",
        "\n",
        "- Use `Numpy’s quantile()` function to find the first, second, third quartile.\n",
        "\n",
        "Store the result in a variable named `height_q1, height_q2, height_q3`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "05963a30-b17b-4a27-a70d-957e47f8a37f",
      "metadata": {
        "id": "05963a30-b17b-4a27-a70d-957e47f8a37f"
      },
      "outputs": [],
      "source": [
        "heights = [80, 150, 155, 160, 156,\n",
        "           180, 134, 131, 123, 125,\n",
        "           165, 146, 130, 150, 140,\n",
        "           19, 170, 164, 166, 153,\n",
        "           145, 158, 200, 300]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "f185898e-8250-4396-81b5-9e1fe9fd29da",
      "metadata": {
        "id": "f185898e-8250-4396-81b5-9e1fe9fd29da"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "2baa8cf0-33a7-42ed-92bb-1ba77d910a39",
      "metadata": {
        "id": "2baa8cf0-33a7-42ed-92bb-1ba77d910a39"
      },
      "outputs": [],
      "source": [
        "q1 = np.quantile(heights, 0.25)\n",
        "q2 = np.quantile(heights, 0.50)\n",
        "q3 = np.quantile(heights, 0.75)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "3192a439-9b3c-4777-bab6-b523070a2bde",
      "metadata": {
        "id": "3192a439-9b3c-4777-bab6-b523070a2bde",
        "outputId": "a53a6651-ab4d-43f7-cd9c-da9f989d6a83"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(133.25, 151.5, 164.25)"
            ]
          },
          "execution_count": 29,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "q1, q2, q3"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "b3062026-af13-4a29-8a51-3c0ee848c413",
      "metadata": {
        "id": "b3062026-af13-4a29-8a51-3c0ee848c413"
      },
      "source": [
        "What is your height in cm?\n",
        "Store that value in a variable named `my_height`."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "038486cf-1880-4437-8f21-fc5e46accfdc",
      "metadata": {
        "id": "038486cf-1880-4437-8f21-fc5e46accfdc"
      },
      "source": [
        "Does that your height fall in the `first, second, third, or fourth quarter` of the data?"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "d91377e1-b649-4f93-a2bd-c527f5838609",
      "metadata": {
        "id": "d91377e1-b649-4f93-a2bd-c527f5838609"
      },
      "source": [
        "What is the IQR?"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "d787f01b-a105-4307-bf47-4f13ed44158a",
      "metadata": {
        "id": "d787f01b-a105-4307-bf47-4f13ed44158a"
      },
      "source": [
        "The `interquartile range (IQR)` is a descriptive statistic that tries to solve this problem. The IQR ignores the tails of the dataset, so you know the range around-which your data is centered."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "55352571-c974-4fbc-96aa-62935786d301",
      "metadata": {
        "id": "55352571-c974-4fbc-96aa-62935786d301"
      },
      "source": [
        "#"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "040775b9-bb5a-4a50-a5c4-ce20e5d77efb",
      "metadata": {
        "id": "040775b9-bb5a-4a50-a5c4-ce20e5d77efb"
      },
      "source": [
        "# `copy()` vs. `view()` in Numpy Array\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "a86c8411-a767-4410-8ddb-82855e5b909a",
      "metadata": {
        "id": "a86c8411-a767-4410-8ddb-82855e5b909a"
      },
      "source": [
        "after this tutorial you will understand about:-\n",
        "- the differences and\n",
        "- the similarity between `copy` and `view`\n",
        "----\n",
        "\n",
        "- view - shallow copy\n",
        "- copy - deep copy"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "4ee0b81d-d57c-4833-94b4-6d372e4ce092",
      "metadata": {
        "id": "4ee0b81d-d57c-4833-94b4-6d372e4ce092",
        "outputId": "335b5e48-af35-40c7-afb9-bb448edf1a10"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[0, 1, 2, 3, 4],\n",
              "       [5, 6, 7, 8, 9]])"
            ]
          },
          "execution_count": 74,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "import numpy as np\n",
        "\n",
        "arr_2d = np.arange(10).reshape(2, 5)\n",
        "arr_2d"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "51be3cc5-b199-49d2-907e-22f500f03647",
      "metadata": {
        "id": "51be3cc5-b199-49d2-907e-22f500f03647"
      },
      "source": [
        "view the original array"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "784b65ab-ee26-4e60-83f8-f862246ee533",
      "metadata": {
        "id": "784b65ab-ee26-4e60-83f8-f862246ee533",
        "outputId": "fba19ae2-a091-4ba6-e0e2-76c4c3abc115"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[0, 1, 2, 3, 4],\n",
              "       [5, 6, 7, 8, 9]])"
            ]
          },
          "execution_count": 69,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# view of the original array\n",
        "v = arr_2d.view()\n",
        "v"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "a3045b12-c31a-4b0d-a861-123fc63615d9",
      "metadata": {
        "id": "a3045b12-c31a-4b0d-a861-123fc63615d9"
      },
      "source": [
        "change value at row index 0 and column index 1 of the view data"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "31c355a4-0a16-493b-a474-5a085903b7a6",
      "metadata": {
        "id": "31c355a4-0a16-493b-a474-5a085903b7a6",
        "outputId": "7556c65a-519c-4571-abc2-110e0ba3278b"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[ 0, 20,  2,  3,  4],\n",
              "       [ 5,  6,  7,  8,  9]])"
            ]
          },
          "execution_count": 70,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# change value of the view data at [0][1]\n",
        "v[0][1] = 20\n",
        "v"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "21f43673-076a-4bc0-8f7c-79bea12f0c40",
      "metadata": {
        "id": "21f43673-076a-4bc0-8f7c-79bea12f0c40",
        "outputId": "6dadd07c-937d-4d78-8daf-e0ca5dd4fbad"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[ 0, 20,  2,  3,  4],\n",
              "       [ 5,  6,  7,  8,  9]])"
            ]
          },
          "execution_count": 71,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "arr_2d"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "8fb34695-1fbe-4c18-9f4b-b90c5da4572e",
      "metadata": {
        "id": "8fb34695-1fbe-4c18-9f4b-b90c5da4572e"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "id": "e3b6ca19-9d9b-4678-a3ea-a75957fd91be",
      "metadata": {
        "id": "e3b6ca19-9d9b-4678-a3ea-a75957fd91be"
      },
      "source": [
        "change the value at row index 1 and column index 2 of the original data"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "cf61a46d-80f2-4e47-8c74-226c91e6fc90",
      "metadata": {
        "id": "cf61a46d-80f2-4e47-8c74-226c91e6fc90",
        "outputId": "6b93f0b4-1e47-4ef7-faae-4ac0ef614a9b"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[ 0, 20,  2,  3,  4],\n",
              "       [ 5,  6, 30,  8,  9]])"
            ]
          },
          "execution_count": 72,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# change value of the view data at [1][2]\n",
        "arr_2d[1][2] = 30\n",
        "arr_2d"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "5ff63b24-b313-4c96-a911-47c6b7df7f65",
      "metadata": {
        "id": "5ff63b24-b313-4c96-a911-47c6b7df7f65",
        "outputId": "14ced582-a47f-442f-9530-ec27082851a1"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[ 0, 20,  2,  3,  4],\n",
              "       [ 5,  6, 30,  8,  9]])"
            ]
          },
          "execution_count": 73,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "v"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "04337c81-5bcc-418f-a07d-5b6ea8d7ea7b",
      "metadata": {
        "id": "04337c81-5bcc-418f-a07d-5b6ea8d7ea7b"
      },
      "source": [
        "copy the original array"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "2a76ba16-f442-41d5-aeb5-66e1668947cc",
      "metadata": {
        "id": "2a76ba16-f442-41d5-aeb5-66e1668947cc",
        "outputId": "a02aeb19-2d4e-43ad-b994-4aac66ceb627"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[0, 1, 2, 3, 4],\n",
              "       [5, 6, 7, 8, 9]])"
            ]
          },
          "execution_count": 77,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# copy of the original array\n",
        "c = arr_2d.copy()\n",
        "c"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "7d6fa5c1-12e3-4dd8-b21d-677ad06eef01",
      "metadata": {
        "id": "7d6fa5c1-12e3-4dd8-b21d-677ad06eef01",
        "outputId": "7a6f86a1-b863-4d6d-8138-7053a9cd3c38"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[ 0, 90,  2,  3,  4],\n",
              "       [ 5,  6,  7,  8,  9]])"
            ]
          },
          "execution_count": 78,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "c[0][1] = 90\n",
        "c"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "8a98f687-b046-4a0d-bbb0-fe9ac3dfe9b7",
      "metadata": {
        "id": "8a98f687-b046-4a0d-bbb0-fe9ac3dfe9b7",
        "outputId": "eccd89e8-35fc-424b-bbed-21b354bdfbb7"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[ 0,  1,  2,  3,  4],\n",
              "       [ 5,  6, 15,  8,  9]])"
            ]
          },
          "execution_count": 80,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "arr_2d[1][2] = 15\n",
        "arr_2d"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "10a5bf17-470e-41a1-9b6f-ec6c526a3da0",
      "metadata": {
        "id": "10a5bf17-470e-41a1-9b6f-ec6c526a3da0",
        "outputId": "828035bc-27bb-4c5d-ba86-8ab295251551"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[ 0, 90,  2,  3,  4],\n",
              "       [ 5,  6,  7,  8,  9]])"
            ]
          },
          "execution_count": 81,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "c"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "1e47eddd-0b14-4732-b1db-d5a64121813c",
      "metadata": {
        "id": "1e47eddd-0b14-4732-b1db-d5a64121813c",
        "outputId": "b14f849b-b07d-400e-dd15-78f08c3dad00"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "140162769876816"
            ]
          },
          "execution_count": 82,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "id(c)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "02206dc0-24cf-4a08-8e71-1e7fb982002c",
      "metadata": {
        "id": "02206dc0-24cf-4a08-8e71-1e7fb982002c",
        "outputId": "3adad121-4128-499c-a1de-84e626d92290"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "140162769875568"
            ]
          },
          "execution_count": 83,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "id(arr_2d)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "cada89a1-fd74-4d01-a556-e9062557840c",
      "metadata": {
        "id": "cada89a1-fd74-4d01-a556-e9062557840c"
      },
      "source": [
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "7f3b7333-557e-47fa-aaab-b9a40dc0fb50",
      "metadata": {
        "id": "7f3b7333-557e-47fa-aaab-b9a40dc0fb50"
      },
      "source": [
        "# NumPy matrix multiplication\n",
        "\n",
        "How to multiply matrices?"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "8eceb748-dfd6-4f18-a009-ce0cb3ebcf66",
      "metadata": {
        "id": "8eceb748-dfd6-4f18-a009-ce0cb3ebcf66"
      },
      "source": [
        ">A matrix is a 2-D array. Each element in the array has two indices."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "e3e91fcf-e31b-4a3b-8c98-145b79828ea4",
      "metadata": {
        "id": "e3e91fcf-e31b-4a3b-8c98-145b79828ea4"
      },
      "outputs": [],
      "source": [
        "import numpy as np"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "39b1f3cb-966b-401d-af3a-0fe322395993",
      "metadata": {
        "id": "39b1f3cb-966b-401d-af3a-0fe322395993"
      },
      "outputs": [],
      "source": [
        "# let's have matrix A and B\n",
        "A = np.array([[0, 3], [1, -1], [2, 1], [5, 2]])\n",
        "B = np.array([[1, 2, 1, 2], [4, 1, -1, -4]])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "2ae7e55e-a7ff-425d-8d7f-7f29df7cab58",
      "metadata": {
        "id": "2ae7e55e-a7ff-425d-8d7f-7f29df7cab58",
        "outputId": "7c0de775-e2b3-4ed8-fe13-2b7b66455217"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "(4, 2) (2, 4)\n"
          ]
        }
      ],
      "source": [
        "print(A.shape, B.shape)\n",
        "# 4*2 and 2*4"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "d6d5b4a6-92c2-4d44-a210-25be2d62ef90",
      "metadata": {
        "id": "d6d5b4a6-92c2-4d44-a210-25be2d62ef90"
      },
      "source": [
        "Three ways of performing matrix multiplication\n",
        "1. `np.dot(A, B)`\n",
        "2. `np.multiply(A, B)`\n",
        "3. `np.matmul(A, B)`"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "a78c61c2-a83d-4249-a85e-882c0238f865",
      "metadata": {
        "id": "a78c61c2-a83d-4249-a85e-882c0238f865"
      },
      "source": [
        "### Scalar Multiplication\n",
        "\n",
        ">scalar is a number like `1, 2, or 3`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "07586177-6563-47b8-8ccb-7d6136b0206b",
      "metadata": {
        "id": "07586177-6563-47b8-8ccb-7d6136b0206b",
        "outputId": "360a1c94-9c21-4ec0-e596-4bf82cef7708"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[ 0  3]\n",
            " [ 1 -1]\n",
            " [ 2  1]\n",
            " [ 5  2]]\n"
          ]
        }
      ],
      "source": [
        "print(A)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "03b94466-b348-45eb-9e8b-ac46f486e21e",
      "metadata": {
        "id": "03b94466-b348-45eb-9e8b-ac46f486e21e",
        "outputId": "ad5973ab-ac6c-4067-cd09-5e2ba403e979"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[ 0,  6],\n",
              "       [ 2, -2],\n",
              "       [ 4,  2],\n",
              "       [10,  4]])"
            ]
          },
          "execution_count": 25,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# scalar multiplication\n",
        "# 2*0 2*3\n",
        "# 2*1\n",
        "s = 2\n",
        "np.dot(s, A)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "a72839bc-f61a-4ca4-8659-2814f7bf25cb",
      "metadata": {
        "id": "a72839bc-f61a-4ca4-8659-2814f7bf25cb",
        "outputId": "ab9295bf-8387-454f-9cf7-ac7c8eb0f943"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[ 0,  6],\n",
              "       [ 2, -2],\n",
              "       [ 4,  2],\n",
              "       [10,  4]])"
            ]
          },
          "execution_count": 26,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "np.dot(A, s)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "3bf50290-aca2-4fec-b332-37215a75268c",
      "metadata": {
        "id": "3bf50290-aca2-4fec-b332-37215a75268c"
      },
      "source": [
        "### Dot Product of two 2-D arrays"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "1fde0e29-15ac-4264-a69f-e1c7e47b211c",
      "metadata": {
        "id": "1fde0e29-15ac-4264-a69f-e1c7e47b211c",
        "outputId": "7cf3d350-73bd-406e-ef81-48b920ed581b"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[ 0  3]\n",
            " [ 1 -1]\n",
            " [ 2  1]\n",
            " [ 5  2]]\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "array([[ 1,  2,  1,  2],\n",
              "       [ 4,  1, -1, -4]])"
            ]
          },
          "execution_count": 27,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "print(A)\n",
        "B"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "267e9a5b-118d-494f-a681-bd2c7c80b770",
      "metadata": {
        "id": "267e9a5b-118d-494f-a681-bd2c7c80b770",
        "outputId": "fa4cccab-3766-4fdf-c6e2-64ab8d461b48"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[ 12,   3,  -3, -12],\n",
              "       [ -3,   1,   2,   6],\n",
              "       [  6,   5,   1,   0],\n",
              "       [ 13,  12,   3,   2]])"
            ]
          },
          "execution_count": 28,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# 4*2 x 2*4\n",
        "# 2*4 x 4*2\n",
        "# A x B is not the same as B X A\n",
        "# 0*1 + 3*4 = 12 0*2+3*1 = 3  -3\n",
        "np.dot(A, B)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "53c81d4a-8fa1-4459-a779-bcbeab051172",
      "metadata": {
        "id": "53c81d4a-8fa1-4459-a779-bcbeab051172",
        "outputId": "63393b8c-1fe0-4571-954d-9f07b6af251e"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[ 14,   6],\n",
              "       [-21,   2]])"
            ]
          },
          "execution_count": 29,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "np.dot(B, A)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "58608053-1c81-4a6a-a4c6-40c0566638bc",
      "metadata": {
        "id": "58608053-1c81-4a6a-a4c6-40c0566638bc"
      },
      "outputs": [],
      "source": [
        "# Example with multiplication of 2 dimensional\n",
        "# with another 2 dimensional\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "5ec411b7-95ad-48c8-8dad-f8560138ae4a",
      "metadata": {
        "id": "5ec411b7-95ad-48c8-8dad-f8560138ae4a"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "b30d67c1-5c03-4955-8260-a65c768ba5e6",
      "metadata": {
        "id": "b30d67c1-5c03-4955-8260-a65c768ba5e6"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "id": "8ff57884-394b-4787-a265-6e8992118ef9",
      "metadata": {
        "id": "8ff57884-394b-4787-a265-6e8992118ef9"
      },
      "source": [
        "### #\n",
        "#\n",
        "#\n",
        "#\n",
        "#\n",
        "#\n",
        "#\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "fdbebffb-47b8-47a7-baab-93451dcf81b5",
      "metadata": {
        "id": "fdbebffb-47b8-47a7-baab-93451dcf81b5"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "84794f96-8510-4be1-9bc8-b04aabc7e533",
      "metadata": {
        "id": "84794f96-8510-4be1-9bc8-b04aabc7e533"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "acb6cd56-1517-4036-9f76-4a12711548e9",
      "metadata": {
        "id": "acb6cd56-1517-4036-9f76-4a12711548e9"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "adee6575-5f71-4ef4-8882-c7998132f070",
      "metadata": {
        "id": "adee6575-5f71-4ef4-8882-c7998132f070"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "c62d4f8a-4e35-431d-9706-51ad222ab9df",
      "metadata": {
        "id": "c62d4f8a-4e35-431d-9706-51ad222ab9df"
      },
      "outputs": [],
      "source": [
        "# zeros function\n",
        "a = np.zeros((2, 3))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "89910c2f-06b4-4162-96fa-6837d5ba1454",
      "metadata": {
        "id": "89910c2f-06b4-4162-96fa-6837d5ba1454",
        "outputId": "f6fb142a-8cf7-42a6-b971-c953ec090349"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[0., 0., 0.],\n",
              "       [0., 0., 0.]])"
            ]
          },
          "execution_count": 35,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "a"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "db9254e5-186b-43ab-a250-1fc12e039a58",
      "metadata": {
        "id": "db9254e5-186b-43ab-a250-1fc12e039a58"
      },
      "outputs": [],
      "source": [
        "a = np.ones((3, 5))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "2e134c62-05cc-491e-841c-9cf77b4ec862",
      "metadata": {
        "id": "2e134c62-05cc-491e-841c-9cf77b4ec862",
        "outputId": "6e5131cc-87bf-411d-c786-cbe832c629cd"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[1., 1., 1., 1., 1.],\n",
              "       [1., 1., 1., 1., 1.],\n",
              "       [1., 1., 1., 1., 1.]])"
            ]
          },
          "execution_count": 37,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "a"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "0397adaa-0079-41e6-85bb-eda5291cab92",
      "metadata": {
        "id": "0397adaa-0079-41e6-85bb-eda5291cab92"
      },
      "outputs": [],
      "source": [
        "e = np.empty((3, 4))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "248862ba-c555-48b2-9caf-dc417b903298",
      "metadata": {
        "id": "248862ba-c555-48b2-9caf-dc417b903298",
        "outputId": "8a5c1c35-089c-478e-cd26-07ec3589bf48"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[1.6442717e-316, 0.0000000e+000, 0.0000000e+000, 0.0000000e+000],\n",
              "       [0.0000000e+000, 0.0000000e+000, 0.0000000e+000, 0.0000000e+000],\n",
              "       [0.0000000e+000, 0.0000000e+000, 0.0000000e+000, 0.0000000e+000]])"
            ]
          },
          "execution_count": 39,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "e"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "19c6591a-63fe-4fba-891c-8057c77b8f92",
      "metadata": {
        "id": "19c6591a-63fe-4fba-891c-8057c77b8f92",
        "outputId": "3b86572f-e86b-4bf2-aee3-5f8b691f69ae"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "dtype('float64')"
            ]
          },
          "execution_count": 40,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "e.dtype"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "55ee10f8-775b-484c-8cf9-8515a62a8268",
      "metadata": {
        "id": "55ee10f8-775b-484c-8cf9-8515a62a8268"
      },
      "source": [
        "# Mathematical Functions"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "f1dbf13b-1110-4017-99da-5efa6c4207c6",
      "metadata": {
        "id": "f1dbf13b-1110-4017-99da-5efa6c4207c6"
      },
      "source": [
        "#### Elementwise vs matrices"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "9ac18afa-6ccf-4fa7-8375-be061c7241d4",
      "metadata": {
        "id": "9ac18afa-6ccf-4fa7-8375-be061c7241d4"
      },
      "source": [
        "1. Add()\n",
        "2. Substract()\n",
        "3. multiply()\n",
        "4. divide()\n",
        "5. sqrt()\n",
        "6. product(dot)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "d8c7343b-0e9a-470c-b4a6-d56466ca96c3",
      "metadata": {
        "id": "d8c7343b-0e9a-470c-b4a6-d56466ca96c3"
      },
      "outputs": [],
      "source": [
        "import numpy as np"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "6570aede-c5e3-4163-8e99-41ccbcd9d360",
      "metadata": {
        "id": "6570aede-c5e3-4163-8e99-41ccbcd9d360"
      },
      "outputs": [],
      "source": [
        "x = np.array([[2, 3, 4], [3, 4, 2]])\n",
        "y = np.array([[5, 3, 4], [3, 4, 5]], dtype=\"int64\")\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "a7c17557-26b2-4c81-9dc4-1ec9a4a10f3f",
      "metadata": {
        "id": "a7c17557-26b2-4c81-9dc4-1ec9a4a10f3f",
        "outputId": "bc854798-a2ec-40f8-af28-ad35fdad8b03"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[7 6 8]\n",
            " [6 8 7]]\n"
          ]
        }
      ],
      "source": [
        "# adding elements in the array\n",
        "# [[7, 6, 8], [6, 8, 7]]\n",
        "result = x + y\n",
        "result = np.add(x, y)\n",
        "print(result)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "cba9cd45-d34e-4ae3-90dc-8aa9aea08492",
      "metadata": {
        "id": "cba9cd45-d34e-4ae3-90dc-8aa9aea08492",
        "outputId": "64174e09-33d8-42fa-812c-66b050c2aca4"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[3 0 0]\n",
            " [0 0 3]]\n"
          ]
        }
      ],
      "source": [
        "# subtract\n",
        "result = x - y\n",
        "result = np.subtract(y, x)\n",
        "# [[-3,0, 0 ], [0, 0, -3]]\n",
        "print(result)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "fc02f0fb-750a-498a-a0db-aaeb10792035",
      "metadata": {
        "id": "fc02f0fb-750a-498a-a0db-aaeb10792035",
        "outputId": "261f5784-55cb-41c7-b611-8065c23e1a20"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[10  9 16]\n",
            " [ 9 16 10]]\n"
          ]
        }
      ],
      "source": [
        "# multiply\n",
        "#[[10, 9, 16], [9, 16, 10]]\n",
        "result = x * y\n",
        "result = np.multiply(x, y)\n",
        "print(result)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "223cc271-cdea-4e74-9243-bf46ba745c92",
      "metadata": {
        "id": "223cc271-cdea-4e74-9243-bf46ba745c92",
        "outputId": "ae5a51d5-4687-4be2-cca7-8311b8d17324"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[2.5 1.  1. ]\n",
            " [1.  1.  2.5]]\n"
          ]
        }
      ],
      "source": [
        "# divid\n",
        "result = x / y\n",
        "result = np.divide(y, x)\n",
        "print(result)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "2230220f-8d28-4725-9e4d-abf7cbaa5514",
      "metadata": {
        "id": "2230220f-8d28-4725-9e4d-abf7cbaa5514",
        "outputId": "2c5c8a50-cc34-4dc6-8e9e-5e8b8aeb0e62"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[2.5 1.  1. ]\n",
            " [1.  1.  2.5]]\n"
          ]
        }
      ],
      "source": [
        "resutl = np.sqrt(y)\n",
        "\n",
        "print(result)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "3d59ae79-9ae8-4d8a-9991-208016f4835c",
      "metadata": {
        "id": "3d59ae79-9ae8-4d8a-9991-208016f4835c"
      },
      "outputs": [],
      "source": [
        "# Matrices wise\n",
        "# dot()\n",
        "x = np.array([[3, 5], [2, 1]])\n",
        "y = np.array([[5, 1], [1, 2]])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "e282fa15-a1b7-4ac5-a881-273651a8ecd6",
      "metadata": {
        "id": "e282fa15-a1b7-4ac5-a881-273651a8ecd6"
      },
      "outputs": [],
      "source": [
        "# define vectors\n",
        "v = np.array([2, 3])\n",
        "w = np.array([1, 4])\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "671e2b04-d22c-4024-bbbc-636f5c89b05b",
      "metadata": {
        "id": "671e2b04-d22c-4024-bbbc-636f5c89b05b",
        "outputId": "e8dec41c-fc6c-4f5e-dd01-5226cf65c190"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "14\n"
          ]
        }
      ],
      "source": [
        "result = v.dot(w)\n",
        "# 2*1 + 3*4 = 14\n",
        "# not [[2, 12]]\n",
        "print(result)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "07c473d4-bd8a-4c6b-beee-df0e98c5aebb",
      "metadata": {
        "id": "07c473d4-bd8a-4c6b-beee-df0e98c5aebb",
        "outputId": "3e038c07-e44e-4c44-e9a5-88685dd5eb3a"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[21  7]\n"
          ]
        }
      ],
      "source": [
        "# WHAT IS THE OUTPUT OF\n",
        "result = x.dot(v)\n",
        "# 3*5 + 5*1 = 20\n",
        "[3* 2 + 5*3, 2*2 + 1*3]\n",
        "print(result)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "9c018595-a3fa-4d9b-928b-749090756d64",
      "metadata": {
        "id": "9c018595-a3fa-4d9b-928b-749090756d64",
        "outputId": "fa82aec1-4e46-492d-d9bc-021bcdc14c0d"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[20 13]\n",
            " [11  4]]\n"
          ]
        }
      ],
      "source": [
        "result = x.dot(y)\n",
        "# [3*5 + 5*1, 3*1 + 5*2, 2* 5 + 1* 1, 2*1 + 1*2]\n",
        "print(result)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "c563ebff-773f-4b7e-a781-7b6dc244e28f",
      "metadata": {
        "id": "c563ebff-773f-4b7e-a781-7b6dc244e28f",
        "outputId": "4045f9a8-617f-42f8-99de-1429d36736fb"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[20 13]\n",
            " [11  4]]\n"
          ]
        }
      ],
      "source": [
        "print(np.dot(x, y))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "d3f73ab3-768a-4bfe-a474-a9ee5a12b858",
      "metadata": {
        "id": "d3f73ab3-768a-4bfe-a474-a9ee5a12b858",
        "outputId": "17e1e9a0-137c-4370-c015-542aa6df08e3"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "13\n",
            "21\n",
            "[5 7 9]\n"
          ]
        }
      ],
      "source": [
        " # what is the output of np.sum(x)\n",
        "x = np.array([[2, 3, 4],\n",
        "              [3, 4, 5]])\n",
        "y = [2, 3, 4, 4] # list\n",
        "\n",
        "# there are three ways of sum of arrays elements\n",
        "\n",
        "print(np.sum(y))\n",
        "print(np.sum(x))\n",
        "\n",
        "# the sume of column elements\n",
        "print(np.sum(x, axis=0))\n",
        "# [5, 7, 9]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "ad77a296-0636-4354-a453-fba099e2b640",
      "metadata": {
        "id": "ad77a296-0636-4354-a453-fba099e2b640",
        "outputId": "20890348-8336-4760-c79d-735e3f285337"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[ 9 12]\n"
          ]
        }
      ],
      "source": [
        "print(np.sum(x, axis=1))\n",
        "# [9, 12]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "abbef856-e5ad-4778-a664-9aaabdf60e19",
      "metadata": {
        "id": "abbef856-e5ad-4778-a664-9aaabdf60e19",
        "outputId": "b37c0efb-ab27-4202-963a-9e55c89e66ca"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "13\n"
          ]
        }
      ],
      "source": [
        "s = 0\n",
        "for i in y:\n",
        "    s += i\n",
        "\n",
        "print(s)\n",
        ""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "75ab3baf-3cf8-4057-aeff-d63f44928c52",
      "metadata": {
        "id": "75ab3baf-3cf8-4057-aeff-d63f44928c52",
        "outputId": "ebf8e149-ef67-4429-b69e-4084f279a21c"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "2\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "array([[2, 3, 8],\n",
              "       [3, 2, 8],\n",
              "       [5, 1, 9],\n",
              "       [5, 6, 7]])"
            ]
          },
          "execution_count": 17,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        " x = np.array([\n",
        "             [2, 3, 5, 5],\n",
        "            [3, 2, 1, 6],\n",
        "            [8, 8, 9, 7]])\n",
        "print(x.ndim)\n",
        "x.T"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "29325af5-e861-44e9-8390-c261ab199848",
      "metadata": {
        "id": "29325af5-e861-44e9-8390-c261ab199848",
        "outputId": "aeb2935f-fd05-4c25-aacb-870ed996d4ae"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "(3, 4)\n"
          ]
        }
      ],
      "source": [
        "# how many dimensions in this array\n",
        "print(x.shape)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "96864cb5-26e3-4a63-bf38-3c089cec5bf0",
      "metadata": {
        "id": "96864cb5-26e3-4a63-bf38-3c089cec5bf0",
        "outputId": "4619e975-dc7a-4ab8-fe24-520536177587"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "12"
            ]
          },
          "execution_count": 19,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "x.size"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "ec6107f4-fdbd-4b93-be8d-c5ad51f83f5c",
      "metadata": {
        "id": "ec6107f4-fdbd-4b93-be8d-c5ad51f83f5c"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n"
      ],
      "metadata": {
        "id": "vqacUPIfDsu0"
      },
      "id": "vqacUPIfDsu0"
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Advanced Numpy Tutorial"
      ],
      "metadata": {
        "id": "uRtBn7DIDuCL"
      },
      "id": "uRtBn7DIDuCL"
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Mastering Sorting Algorithms in Python with NumPy"
      ],
      "metadata": {
        "id": "jIwZ1TPSDxQc"
      },
      "id": "jIwZ1TPSDxQc"
    },
    {
      "cell_type": "markdown",
      "source": [
        "To sort a NumPy array, you can use the `numpy.sort` function or the sort method of the array itself. NumPy offers various sorting algorithms, including **quicksort**, **mergesort**, and **heapsort**. Here's a basic example of how to sort a NumPy array:"
      ],
      "metadata": {
        "id": "bg3nBG_YD108"
      },
      "id": "bg3nBG_YD108"
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "# Create a NumPy array\n",
        "array = np.array([3, 1, 4, 1, 5, 9, 2, 6, 5])\n",
        "\n",
        "# Using numpy.sort function to create a sorted copy of the array\n",
        "sorted_array = np.sort(array)\n",
        "\n",
        "print(\"Sorted array:\")\n",
        "print(sorted_array)\n",
        "\n",
        "# Using the sort method to sort the array in place\n",
        "array.sort()\n",
        "print(\"Original array after sorting:\")\n",
        "print(array)\n"
      ],
      "metadata": {
        "id": "P3ucYXTcEEG5"
      },
      "id": "P3ucYXTcEEG5",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Increasing or Decreasing sort"
      ],
      "metadata": {
        "id": "aPk9F_RcJYpy"
      },
      "id": "aPk9F_RcJYpy"
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "ia791QX4Jb73"
      },
      "id": "ia791QX4Jb73",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "You can also sort a multi-dimensional array along a specific axis by specifying the axis parameter. Here's an example:"
      ],
      "metadata": {
        "id": "z03uBNP_EN6x"
      },
      "id": "z03uBNP_EN6x"
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a 2D NumPy array\n",
        "array_2d = np.array([[3, 1, 4],\n",
        "                     [1, 5, 9],\n",
        "                     [2, 6, 5]])\n",
        "\n",
        "# Sorting along the rows (axis=0)\n",
        "sorted_array_2d_rows = np.sort(array_2d, axis=0)\n",
        "\n",
        "print(\"Sorted 2D array along rows:\")\n",
        "print(sorted_array_2d_rows)\n",
        "\n",
        "# Sorting along the columns (axis=1)\n",
        "sorted_array_2d_cols = np.sort(array_2d, axis=1)\n",
        "\n",
        "print(\"Sorted 2D array along columns:\")\n",
        "print(sorted_array_2d_cols)\n"
      ],
      "metadata": {
        "id": "uHyV-WmsEO57"
      },
      "id": "uHyV-WmsEO57",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "NumPy's sorting functions are highly optimized and efficient for handling large arrays. You can choose different sorting algorithms using the **kind** parameter, which includes options like '**quicksort**', '**mergesort**', or '**heapsort**'. You can also use the order parameter to specify the field to use when sorting structured arrays."
      ],
      "metadata": {
        "id": "UYrt7zd4EsOY"
      },
      "id": "UYrt7zd4EsOY"
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Using the '**quicksort'** algorithm:"
      ],
      "metadata": {
        "id": "uVirqKODE2iq"
      },
      "id": "uVirqKODE2iq"
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "# Create an array\n",
        "arr = np.array([3, 1, 4, 1, 5, 9, 2, 6, 5])\n",
        "\n",
        "# Sorting with quicksort algorithm\n",
        "sorted_array_quicksort = np.sort(arr, kind='quicksort')\n",
        "\n",
        "print(\"Sorted array using quicksort:\")\n",
        "print(sorted_array_quicksort)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PSGlheuxEzjP",
        "outputId": "c6ea9865-7779-4291-8fba-072dc5fd1fa4"
      },
      "id": "PSGlheuxEzjP",
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Sorted array using quicksort:\n",
            "[1 1 2 3 4 5 5 6 9]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Using the '**mergesort**' algorithm:"
      ],
      "metadata": {
        "id": "5ivXQa4RE8Ay"
      },
      "id": "5ivXQa4RE8Ay"
    },
    {
      "cell_type": "code",
      "source": [
        "# Sorting with mergesort algorithm\n",
        "sorted_array_mergesort = np.sort(arr, kind='mergesort')\n",
        "\n",
        "print(\"Sorted array using mergesort:\")\n",
        "print(sorted_array_mergesort)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uBpCsGLVE_YA",
        "outputId": "010f9cdd-2d1a-4b4f-a5a6-9cccba46a4c5"
      },
      "id": "uBpCsGLVE_YA",
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Sorted array using mergesort:\n",
            "[1 1 2 3 4 5 5 6 9]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Using the '**heapsort**' algorithm:"
      ],
      "metadata": {
        "id": "lOxZ82VLFDoP"
      },
      "id": "lOxZ82VLFDoP"
    },
    {
      "cell_type": "code",
      "source": [
        "# Sorting with heapsort algorithm\n",
        "sorted_array_heapsort = np.sort(arr, kind='heapsort')\n",
        "\n",
        "print(\"Sorted array using heapsort:\")\n",
        "print(sorted_array_heapsort)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "I46X3hlPFFUp",
        "outputId": "caa74c3b-5114-49e2-8917-337b8e38e1de"
      },
      "id": "I46X3hlPFFUp",
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Sorted array using heapsort:\n",
            "[9 6 5 5 4 3 2 1 1]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "By default, NumPy's sort function uses **quicksort**. However, you can choose a different algorithm based on your requirements. For example, **mergesort** is a stable algorithm and is generally preferred when stability is required. **Heapsort** has a guaranteed worst-case performance and is useful for sorting in the presence of memory constraints.\n",
        "\n",
        "Choosing the appropriate sorting algorithm depends on various factors, including the size of the data, the desired stability of the sort, and the memory constraints."
      ],
      "metadata": {
        "id": "llhRp4U_FGtt"
      },
      "id": "llhRp4U_FGtt"
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.9.10"
    },
    "colab": {
      "provenance": []
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}