Python_Numpy.ipynb

{
  "cells": [
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "v_5a6dEGYukp"
      },
      "source": [
        "# <center> Numpy Basics </center>"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "S6iHwE_iYukt"
      },
      "source": [
        "Welcome to section of Numpy. This is one of the \n",
        "the most used Python libraries for data science. NumPy consists of a powerful data structure called multidimensional arrays. Pandas is another powerful Python library that provides fast and easy data analysis platform.\n",
        "\n",
        "NumPy is a library written for scientific computing and data analysis. It stands for numerical python and also known as array oriented computing.\n",
        "\n",
        "The most basic object in NumPy is the ndarray, or simply an array which is an n-dimensional, homogeneous array. By homogenous, we mean that all the elements in a NumPy array have to be of the same data type, which is commonly numeric (float or integer).\n",
        "\n",
        "\n",
        " # Why Numpy?\n",
        " convenience & speed\n",
        " \n",
        " Numpy is much faster than the standard python ways to do computations.\n",
        " \n",
        "Vectorised code typically does not contain explicit looping and indexing etc. (all of this happens behind the scenes, in precompiled C-code), and thus it is much more concise.\n",
        "\n",
        "Also, many Numpy operations are implemented in C which is basically being executed behind the scenes, avoiding the general cost of loops in Python, pointer indirection and per-element dynamic type checking. The speed boost depends on which operations you're performing.\n",
        " \n",
        " NumPy arrays are more compact than lists, i.e. they take much lesser storage space than lists\n",
        " \n",
        " ***Let's get started  with our Numpy Assigment**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "NnhU92SsYukv"
      },
      "outputs": [],
      "source": [
        "#import numpy module with alias np\n",
        "\n",
        "import numpy as np"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "onEY9HMeYuk0"
      },
      "source": [
        "We can create a NumPy ndarray object by using the array() function.\n",
        "To create an ndarray, we can pass a list, tuple or any array-like object into the array() method, and it will be converted into an ndarray:\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "BCdPh0rqYuk0"
      },
      "outputs": [],
      "source": [
        "# Define a numpy array passing a list with  1,2 and 3 as elements in it\n",
        "a = np.array([1,2,3])\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "up-97mFyYuk1",
        "outputId": "f125e677-246c-4b43-a969-daa0d9dba379"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([1, 2, 3])"
            ]
          },
          "execution_count": 8,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# print a\n",
        "a\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "I5wC2n70Yuk2"
      },
      "source": [
        "## Dimensions in Arrays\n",
        "\n",
        "\n",
        "Numpy array can be of n dimentions\n",
        "\n",
        "Lets create arrays of different dimentions.\n",
        "\n",
        "a=A numpy array with one single integer 10\n",
        "\n",
        "b=A numpy array passing a list having a list= [1,2,3]\n",
        "\n",
        "c=A numpy array passing nested list having [[1, 2, 3], [4, 5, 6]] as elements\n",
        "\n",
        "d=A numpy array passing nested list having [[[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]]] as elements"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "75VeuGacYuk3"
      },
      "outputs": [],
      "source": [
        "#define a,b,c and d as instructed above\n",
        "import numpy as np\n",
        "\n",
        "a = np.array(10)\n",
        "b = np.array([1,2,3])\n",
        "c = np.array([[1, 2, 3], [4, 5, 6]])\n",
        "d = np.array([[[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]]])\n",
        "\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "qtUQhJgsYuk5"
      },
      "source": [
        "Are you ready to check its dimention? Use ndim attribute on each variable to check its dimention"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WqRlO_elYuk6",
        "outputId": "6283fedf-d789-4379-8fa2-a4ebfdf6c568"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            " a dimention: 0\n",
            " b dimention: 1\n",
            " c dimention: 2\n",
            " d dimention: 3\n"
          ]
        }
      ],
      "source": [
        "#print dimentions of a,b, c and d\n",
        "print(f\" a dimention: {a.ndim}\")\n",
        "print(f\" b dimention: {b.ndim}\")\n",
        "print(f\" c dimention: {c.ndim}\")\n",
        "print(f\" d dimention: {d.ndim}\")\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "GdfDcthEYuk7"
      },
      "source": [
        "Hey hey. Did you see! you have created 0-D,1-DeprecationWarning, 2-D and 3-D arrays.\n",
        "\n",
        "Lets print there shape as well. You can check shape using shape attribute\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Dbo7BMcNYuk8",
        "outputId": "c661c700-837c-49b7-f40d-635e08083966"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            " shape of a: ()\n",
            " shape of b: (3,)\n",
            " shape of c: (2, 3)\n",
            " shape of d: (2, 2, 3)\n"
          ]
        }
      ],
      "source": [
        "# print shape of each a,b ,c and d\n",
        "print(f\" shape of a: {a.shape}\")\n",
        "print(f\" shape of b: {b.shape}\")\n",
        "print(f\" shape of c: {c.shape}\")\n",
        "print(f\" shape of d: {d.shape}\")"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "zznIHO2BYuk8"
      },
      "source": [
        "Lets check data type passed in our array. To check data type you can use dtype attribute"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IqR87PE-Yuk9",
        "outputId": "5390e709-7b25-4ce0-b1dd-f8468a778aae"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "int64\n",
            "int64\n"
          ]
        }
      ],
      "source": [
        "# print data type of c and d\n",
        "\n",
        "print(c.dtype)\n",
        "print(d.dtype)\n",
        "\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "bvZI9gIfYuk9"
      },
      "source": [
        "Above output mean our array is having int type elements in it."
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "JTIMcpHZYuk9"
      },
      "source": [
        "Lets check the type of our variable. To check type of any numpy variable use type() function "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4XscrKR9Yuk9",
        "outputId": "975878fe-dd8c-42d7-8ad1-e5b7001f2fba"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "<class 'numpy.ndarray'>\n",
            "<class 'numpy.ndarray'>\n"
          ]
        }
      ],
      "source": [
        "#print type of a and b variable\n",
        "\n",
        "print(type(a))\n",
        "print(type(b))\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cmEidey1Yuk9",
        "outputId": "f48f343a-0e1b-4292-a007-09cf91652234"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "execution_count": 14,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Lets check length of array b, using len() function\n",
        "len(b)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "8k-sX7zmYuk-"
      },
      "source": [
        "Bravo!You have Defined ndarray i.e numpy array in variable a nd b. Also you have successfully learned how to create numpy. "
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "ujRS0oa7Yuk-"
      },
      "source": [
        "## Performance measurement\n",
        "\n",
        "I mentioned that the key advantages of numpy are convenience and speed of computation.\n",
        "\n",
        "You'll often work with extremely large datasets, and thus it is important point for you to understand how much computation time (and memory) you can save using numpy, compared to standard python lists."
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "bl8PwahHYuk-"
      },
      "source": [
        "Create two list l1 and l2 where, l1=[10,20,30] and l2=[40,50,60]\n",
        "Also define two numpy arrays l3,l4 where l3 has l1 as element and l4 has l2 as element\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "id": "-cZT6aZlYuk-"
      },
      "outputs": [],
      "source": [
        "# Define l1,l2,l3 and l4 as stated above.\n",
        "l1 = [10,20,30]\n",
        "l2 = [40,50,60]\n",
        "l3 = np.array(l1)\n",
        "l4 = np.array(l2)\n",
        "\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "9muN0ZR5Yuk-"
      },
      "source": [
        "Lets multiply each elements of l1 with corresponding elements of l2\n",
        "\n",
        "Here use list comprehention to do so. Lets see how much you remember your work in other assignments.\n",
        "\n",
        "Note: use %timeit as prefix before your line of code inorder to calculate total time taken to run that line<br>\n",
        "eg. %timeit my_code"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Gt0o_ZSCYuk_",
        "outputId": "d4e9de00-bcef-447f-d98e-922f8b248d6f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "1.41 µs ± 460 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
          ]
        }
      ],
      "source": [
        "#code here as instructed above\n",
        "%timeit [a*b for a in l1 for b in l2]\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "xT45pl-RYuk_"
      },
      "source": [
        "Lets mulptiply l3 and l4\n",
        "\n",
        "Note: use %timeit as prefix before your line of code inorder to calculate total time taken to run that line"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SceA6IrwYuk_",
        "outputId": "e3142808-8e26-4525-e8fe-5615994d5336"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "489 ns ± 6.26 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n",
            "507 ns ± 7.25 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n"
          ]
        }
      ],
      "source": [
        "\n",
        "%timeit l3*l4\n",
        "%timeit np.multiply(l3,l4)\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "CJrqooYWYuk_"
      },
      "source": [
        "Don't worry if still your one line of code is running. Its because your system is calculating total time taken to run your code.\n",
        "\n",
        "Did you notice buddy! time taken to multiply two lists takes more time than multiplyimg two numpy array.\n",
        "Hence proved that numpy arrays are faster than lists.\n",
        "\n",
        "**Fun Fact time!:**\n",
        "\n",
        "You know in many data science interviews it is asked that what is the difference between list and array.<br>\n",
        "\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "7ANGM0NaYuk_"
      },
      "source": [
        "so in numpy arrays I can do everything without even writing a loop? yes... ohh wao"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "tmLk0UDSYuk_"
      },
      "source": [
        "### Creating Numpy array\n",
        "\n",
        "There are multiple ways to create numpy array. Lets walk over them\n",
        "\n",
        "1. Using arrange() function <br>\n",
        "Refer: https://numpy.org/doc/stable/reference/generated/numpy.arange.html"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BnwTOtdDYulA",
        "outputId": "537f7926-b0a1-4d5f-a7ec-1359668c6565"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10])"
            ]
          },
          "execution_count": 18,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "#Create a numpy array using arange with 1 and 11 as parameter in it\n",
        "import numpy as np\n",
        "np.arange(1,11)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "QiuRfP4OYulA"
      },
      "source": [
        "This means using arrange we get evenly spaced values within a given interval. Interval? Yes you can mention interval as well as third parameter in it."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TDdTXBZcYulA",
        "outputId": "53c2a87b-13ef-4395-b020-fa6ac6597f33"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([1, 3, 5, 7, 9])"
            ]
          },
          "execution_count": 19,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Create an array using arange passing 1,11 and 2 as parameter in iter\n",
        "import numpy as np\n",
        "np.arange(1,11,2)\n",
        "\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "CrR5M5_3YulA"
      },
      "source": [
        "Did you see? you got all odd numbers as you had mentioned interval between 1 and 10. Also note that 11 is excluded and hence arrange function counted till 10\n",
        "\n",
        "2. Using eye Function <br>\n",
        "Refer: https://numpy.org/devdocs/reference/generated/numpy.eye.html"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IFYEePpeYulA",
        "outputId": "cc40d20d-7ce9-444a-8f1e-a924bcebf95e"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[1., 0., 0.],\n",
              "       [0., 1., 0.],\n",
              "       [0., 0., 1.]])"
            ]
          },
          "execution_count": 20,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# create numpy array using eye function with 3 as passed parameter\n",
        "import numpy as np\n",
        "np.eye(3)\n",
        "\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "wq8pa7MFYulA"
      },
      "source": [
        "Wohoo! eye return a 2-D array with ones on the diagonal and zeros elsewhere.\n",
        "\n",
        "3. Using zero function<br>\n",
        "Refer: https://numpy.org/doc/stable/reference/generated/numpy.zeros.html"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PMINZ5kSYulB",
        "outputId": "78c2de48-e4f9-43df-d623-e9b8fc2ac630"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[0., 0.],\n",
              "       [0., 0.],\n",
              "       [0., 0.]])"
            ]
          },
          "execution_count": 21,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "#create a numpy array using zero function with (3,2) as passed parameter\n",
        "import numpy as np\n",
        "np.zeros((3,2))\n",
        "\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "yZpGcv4JYulB"
      },
      "source": [
        "Zero function returns a new array of given shape and type, filled with zeros.\n",
        "\n",
        "4. Using ones Function <br>\n",
        "Refer: https://numpy.org/doc/stable/reference/generated/numpy.ones.html"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lC7wHtySYulB",
        "outputId": "06a1f659-0380-4182-c08b-698017838a47"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[1., 1.],\n",
              "       [1., 1.],\n",
              "       [1., 1.]])"
            ]
          },
          "execution_count": 22,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "#create a numpy array using ones function with (3,2) as passed parameter\n",
        "\n",
        "import numpy as np\n",
        "np.ones((3,2))\n",
        "\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "LpZnp5Y-YulB"
      },
      "source": [
        "You noticed! ones function returns a new array of given shape and type, filled with ones.\n",
        "\n",
        "5. Using full Function<br>\n",
        "Refer: https://numpy.org/doc/stable/reference/generated/numpy.full.html"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pyjhQr6lYulB",
        "outputId": "0acde114-8724-43d6-ab1d-32e27dced670"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[2, 2, 2],\n",
              "       [2, 2, 2],\n",
              "       [2, 2, 2]])"
            ]
          },
          "execution_count": 23,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "#create a numpy array using full function with (3,2) and 2 as passed parameter\n",
        "\n",
        "import numpy as np\n",
        "np.full((3,3),2)\n",
        "\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "UMa7IWdXYulB"
      },
      "source": [
        "Yeah! full function return a new array of given shape and type, filled with fill_value, here it is 2\n",
        "\n",
        "6. Using diag function<br>\n",
        "Refer: https://numpy.org/doc/stable/reference/generated/numpy.diag.html"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rL49TQxvYulB",
        "outputId": "beb79085-ca16-47b1-c1f8-70e8b87973f4"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[1, 0, 0, 0, 0],\n",
              "       [0, 2, 0, 0, 0],\n",
              "       [0, 0, 3, 0, 0],\n",
              "       [0, 0, 0, 4, 0],\n",
              "       [0, 0, 0, 0, 5]])"
            ]
          },
          "execution_count": 24,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "#create a numpy array using diag function passing a list [1,2,3,4,5]\n",
        "import numpy as np\n",
        "np.diag([1,2,3,4,5])\n",
        "\n",
        "\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "0PmYFmtYYulC"
      },
      "source": [
        "Oh yeah! diag function extract a diagonal or construct a diagonal array.\n",
        "\n",
        " 7. Using tile function<br>\n",
        "    Refer: https://numpy.org/doc/stable/reference/generated/numpy.tile.html"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 25,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QuYuqowmYulC",
        "outputId": "cc48c453-fe38-4aa5-cc77-92cdc83d47d5"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[1, 2, 3],\n",
              "       [1, 2, 3],\n",
              "       [1, 2, 3]])"
            ]
          },
          "execution_count": 25,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Create a numpy array v with [1,2,3] as its elements\n",
        "v = [1,2,3]\n",
        "\n",
        "\n",
        "#Use tile function of numpy and pass v and (3,1) as its parametrs\n",
        "np.tile(v,(3,1))\n",
        "\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "4sp6NFLTYulC"
      },
      "source": [
        "Returns an array by repeating an input array the number of times given by mentioned shape.\n",
        "Here you can see that you stacked 3 copies of v on top of each other\n",
        "\n",
        "8. Using linspace Function<br>\n",
        "Refer: https://numpy.org/doc/stable/reference/generated/numpy.linspace.html"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 26,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gcv8tcEEYulC",
        "outputId": "3a0b8f6c-356b-4f0f-9c90-12e3a2233b8c"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([ 1.        ,  1.49494949,  1.98989899,  2.48484848,  2.97979798,\n",
              "        3.47474747,  3.96969697,  4.46464646,  4.95959596,  5.45454545,\n",
              "        5.94949495,  6.44444444,  6.93939394,  7.43434343,  7.92929293,\n",
              "        8.42424242,  8.91919192,  9.41414141,  9.90909091, 10.4040404 ,\n",
              "       10.8989899 , 11.39393939, 11.88888889, 12.38383838, 12.87878788,\n",
              "       13.37373737, 13.86868687, 14.36363636, 14.85858586, 15.35353535,\n",
              "       15.84848485, 16.34343434, 16.83838384, 17.33333333, 17.82828283,\n",
              "       18.32323232, 18.81818182, 19.31313131, 19.80808081, 20.3030303 ,\n",
              "       20.7979798 , 21.29292929, 21.78787879, 22.28282828, 22.77777778,\n",
              "       23.27272727, 23.76767677, 24.26262626, 24.75757576, 25.25252525,\n",
              "       25.74747475, 26.24242424, 26.73737374, 27.23232323, 27.72727273,\n",
              "       28.22222222, 28.71717172, 29.21212121, 29.70707071, 30.2020202 ,\n",
              "       30.6969697 , 31.19191919, 31.68686869, 32.18181818, 32.67676768,\n",
              "       33.17171717, 33.66666667, 34.16161616, 34.65656566, 35.15151515,\n",
              "       35.64646465, 36.14141414, 36.63636364, 37.13131313, 37.62626263,\n",
              "       38.12121212, 38.61616162, 39.11111111, 39.60606061, 40.1010101 ,\n",
              "       40.5959596 , 41.09090909, 41.58585859, 42.08080808, 42.57575758,\n",
              "       43.07070707, 43.56565657, 44.06060606, 44.55555556, 45.05050505,\n",
              "       45.54545455, 46.04040404, 46.53535354, 47.03030303, 47.52525253,\n",
              "       48.02020202, 48.51515152, 49.01010101, 49.50505051, 50.        ])"
            ]
          },
          "execution_count": 26,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Create an array with 100 values between 1 and 50 using linspace\n",
        "\n",
        "np.linspace(1,50,num=100,dtype=float)\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "zLCrrhK2YulC"
      },
      "source": [
        "Wao! linspace returns evenly spaced numbers over a specified interval.\n",
        "\n",
        "Hey but you saw some similar defination for arrange function\n",
        "\n",
        "The main difference both of them is that arange return values with in a range which has a space between values (in other words the step) and linspace returns set of samples with in a given interval.\n",
        "\n",
        "## Numpy Random numbers\n",
        "\n",
        "\n",
        "Fun Fact:\n",
        "\n",
        "You can create a numpy array with random numbers also. How? Uisng random function<br>\n",
        "Lets see how\n",
        "Refer: https://numpy.org/doc/stable/reference/random/generated/numpy.random.rand.html"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 27,
      "metadata": {
        "id": "a3Dn3SUbYulC"
      },
      "outputs": [],
      "source": [
        "# Generate one random number between 0 and 1 using numpy's random.rand() function.\n",
        "import numpy as np\n",
        "l=np.random.rand()\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 28,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8mvfqpIQYulC",
        "outputId": "a12d5b83-ed3c-4e54-f1ac-54d66eeb2935"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "0.5539208470947463"
            ]
          },
          "execution_count": 28,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "\n",
        "l\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "Oum8rSKWYulD"
      },
      "source": [
        "Run the above cell again and check if number changes.\n",
        "\n",
        "Yeah it changes. That's so random :)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 29,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "f1Go-2JMYulD",
        "outputId": "af58cedb-49fe-4950-fea6-5da20fcdb2ac"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "28.588200660547823\n"
          ]
        }
      ],
      "source": [
        "# so let say I want a random value between 2 and 50\n",
        "\n",
        "scaled_num = 2 + 48 * l\n",
        "print(scaled_num)\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "PBN2TFr_YulD"
      },
      "source": [
        "Run the above cell again and check if number changes and its between 2 to 50.\n",
        "\n",
        "Now lets create an array with random numbers 0 to 1 of shape 3X3"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 30,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rPRFdcKuYulD",
        "outputId": "d6e0406c-cfae-49d3-a449-5bc239fc1a93"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[0.79821095, 0.24336158, 0.41669875],\n",
              "       [0.62371922, 0.2130458 , 0.77906589],\n",
              "       [0.60828875, 0.72149808, 0.54742984]])"
            ]
          },
          "execution_count": 30,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "#get an array as stated above\n",
        "\n",
        "np.random.rand(3,3)\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "YrY0GegxYulD"
      },
      "source": [
        "Smile! you got it how to create a numpy array with random numbers.\n",
        "\n",
        "## Numpy Reshape\n",
        "\n",
        "\n",
        "reference doc: https://numpy.org/doc/stable/reference/generated/numpy.reshape.html\n",
        "\n",
        "Reshaping means changing the shape of an array.\n",
        "The shape of an array is the number of elements in each dimension.\n",
        "By reshaping we can add or remove dimensions or change number of elements in each dimension."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 31,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rXpUyqTYYulD",
        "outputId": "06107549-d9d7-4b44-8645-1e181f59089b"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[ 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16]\n"
          ]
        }
      ],
      "source": [
        "# Using arange() to generate numpy array x with numbers between 1 to 16\n",
        "import numpy as np\n",
        "x=np.arange(1,17)\n",
        "print(x)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "1oCbGuYkYulD"
      },
      "source": [
        "So here x is our 1-D array along with being sweet sixteen array ;). Lets reshape our x into 2-D and 3-D array using Reshape\n",
        "\n",
        "1. Reshaping 1-D to 2-D"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 32,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JkQG8RyFYulE",
        "outputId": "8aae2128-74c3-42cd-f631-f47382e92fd5"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[ 1,  2,  3,  4,  5,  6,  7,  8],\n",
              "       [ 9, 10, 11, 12, 13, 14, 15, 16]])"
            ]
          },
          "execution_count": 32,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Reshape x with 2 rows and 8 columns\n",
        "np.reshape(x,(2,-1))\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "Eu-DgBCRYulE"
      },
      "source": [
        "As you can see above that our x changed into 2D matrix\n",
        "\n",
        "2. Reshaping 1-D to 3-D array\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 33,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ue760dxYYulE",
        "outputId": "44dc37a4-8884-435c-a722-05edf7bad21c"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[[ 1,  2],\n",
              "        [ 3,  4],\n",
              "        [ 5,  6],\n",
              "        [ 7,  8]],\n",
              "\n",
              "       [[ 9, 10],\n",
              "        [11, 12],\n",
              "        [13, 14],\n",
              "        [15, 16]]])"
            ]
          },
          "execution_count": 33,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# reshaoe x with dimension that will have 2 arrays that contains 4 arrays, each with 2 elements:\n",
        "\n",
        "np.reshape(x,(2,4,2))\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "crO_YY_XYulE"
      },
      "source": [
        "**Fun Fact:**\n",
        "\n",
        "<u>Unknown Dimension</u>\n",
        "\n",
        "You are allowed to have one \"unknown\" dimension.Meaning that you do not have to specify an exact number for one of the dimensions in the reshape method.\n",
        "Pass -1 as the value, and NumPy will calculate this number for you. Awesome right?\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 34,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xlfI-eC2YulE",
        "outputId": "6ee430fc-27bd-4c0a-e1be-845ddd75d1ad"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[ 1,  2,  3,  4],\n",
              "       [ 5,  6,  7,  8],\n",
              "       [ 9, 10, 11, 12],\n",
              "       [13, 14, 15, 16]])"
            ]
          },
          "execution_count": 34,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Use unknown dimention to reshape x into 2-D numpy array with shape 4*4\n",
        "\n",
        "np.reshape(x,(4,-1))\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 35,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NDRDRGkUYulE",
        "outputId": "8034dd19-d5c4-454f-f492-19f362f54202"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[[ 1  2]\n",
            "  [ 3  4]\n",
            "  [ 5  6]\n",
            "  [ 7  8]]\n",
            "\n",
            " [[ 9 10]\n",
            "  [11 12]\n",
            "  [13 14]\n",
            "  [15 16]]]\n"
          ]
        }
      ],
      "source": [
        "# Use unknown dimention to  reshape x into 3-D numpy array with 2 arrays that contains 4 arrays\n",
        "y=np.reshape(x,(2,4,-1))\n",
        "\n",
        "\n",
        "# print y\n",
        "print(y)\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "bZjzi4A0YulE"
      },
      "source": [
        "Note: We can not pass -1 to more than one dimension.\n",
        "\n",
        "Another cool Fact: -1 can be used to flatten an array which means converting a multidimensional array into a 1D array.\n",
        "\n",
        "    Lets apply this technique on y which is 3-D array"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 36,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iHuEimtTYulF",
        "outputId": "43741601-f95e-4f64-a8c4-d5b9c1fb00a7"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16])"
            ]
          },
          "execution_count": 36,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Flattening y\n",
        "\n",
        "np.reshape(y,-1)\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "ZdXFadQfYulF"
      },
      "source": [
        "Awesome work!\n",
        "\n",
        "## NumPy Array Indexing\n",
        "\n",
        "\n",
        "Array indexing is the same as accessing an array element. You can access an array element by referring to its index number.\n",
        "\n",
        "The indexes in NumPy arrays start with 0, meaning that the first element has index 0, and the second has index 1 etc."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 37,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "liRM5zN0YulF",
        "outputId": "a5473085-f326-452c-bccc-c84cc71b7199"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[ 2  4  6  8 10 12 14 16]\n"
          ]
        }
      ],
      "source": [
        "# Create an array a with all even numbers between 1 to 17\n",
        "import numpy as np\n",
        "\n",
        "a = np.array([x for x in range(2,17,2)])\n",
        "\n",
        "\n",
        "# print a\n",
        "print(a)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 38,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GysmjjOQYulF",
        "outputId": "7735a4aa-b809-4ee8-c6a0-f2fb3963f7ee"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "6"
            ]
          },
          "execution_count": 38,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Get third element in array a\n",
        "a[2]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 39,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QJDw7E2VYulF",
        "outputId": "6cc3c3dc-c32f-432d-bd29-09c45ca9b306"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[ 6 10 14]\n"
          ]
        }
      ],
      "source": [
        "#Print 3rd, 5th, and 7th element in array a\n",
        "\n",
        "print(a[2:7:2])\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "6FauyJCQYulF"
      },
      "source": [
        "Lets check the same for 2 D array"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 40,
      "metadata": {
        "id": "yomRzY6aYulF"
      },
      "outputs": [],
      "source": [
        "# Define an array 2-D a with [[1,2,3],[4,5,6],[7,8,9]] as its elements.\n",
        "a = np.array([[1,2,3],[4,5,6],[7,8,9]])\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 41,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VTGpLidrYulF",
        "outputId": "cfe9fac7-a015-4358-e82d-7035646642ed"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "9\n"
          ]
        }
      ],
      "source": [
        "# print the 3rd element from the 3rd row of a\n",
        "\n",
        "print(a[-1][-1])"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "-fPw_4ZBYulF"
      },
      "source": [
        "Well done!\n",
        "\n",
        "Now lets check indexing for 3 D array "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 42,
      "metadata": {
        "id": "VISPaw3PYulG"
      },
      "outputs": [],
      "source": [
        "# Define an array b again with [[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]] as its elements.\n",
        "b =  np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 43,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UrFj656mYulG",
        "outputId": "3928d074-a9d0-4e46-9cd2-ef7bfcea2adc"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "6\n"
          ]
        }
      ],
      "source": [
        "# Print 3rd element from 2nd list which is 1st list in nested list passed. Confusing right? 'a' have nested array.Understand the braket differences.\n",
        "\n",
        "print(b[0][1][2])\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "2KH9uUABYulG"
      },
      "source": [
        "Well done.!\n",
        "\n",
        "Have you heared about **negative indexing?**\n",
        "\n",
        "\n",
        "We can use negative indexing to access an array from the end."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 44,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "a_5YgcInYulG",
        "outputId": "497d015f-f278-4938-c10a-adcb97aa6cd0"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "5\n"
          ]
        }
      ],
      "source": [
        "# Print the second last element from the 2nd dim using negative indexing\n",
        "\n",
        "print(b[-2][-1][-2])\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "vbmm4pVzYulG"
      },
      "source": [
        "Great job! \n",
        "So now you have learned how to to indexing on various dimentions of numpy array.\n",
        "\n",
        "## NumPy Array Slicing\n",
        "\n",
        "\n",
        "Slicing in python means taking elements from one given index to another given index.\n",
        "\n",
        "    1. We pass slice instead of index like this: [start:end].\n",
        "    2. We can also define the step, like this: [start:end:step].\n",
        "    3. If we don't pass start its considered 0\n",
        "    4. If we don't pass end its considered length of array in that dimension\n",
        "    5. If we don't pass step its considered 1\n",
        "    \n",
        "1. **Array slicing in 1-D array.**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 45,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9ZadW42fYulG",
        "outputId": "be56f91e-8042-4abc-824c-d86b16017c90"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10])"
            ]
          },
          "execution_count": 45,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "import numpy as np\n",
        "arr = np.array([x for x in range(1,11)])\n",
        "arr\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 46,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fm2dtL6EYulG",
        "outputId": "ce60850a-4850-40e0-b660-0d4030f5c976"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([1, 2, 3, 4, 5])"
            ]
          },
          "execution_count": 46,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Slice elements from 1st to 5th element from the following array:\n",
        "\n",
        "\n",
        "arr[0:5]\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "ghqluYgMYulG"
      },
      "source": [
        "Note: The result includes the start index, but excludes the end index.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 47,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "g4uVBo1oYulH",
        "outputId": "10e18bf8-454f-444b-b42a-d10f2cef2fe3"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([ 6,  7,  8,  9, 10])"
            ]
          },
          "execution_count": 47,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Slice elements from index 5 to the end of the array:\n",
        "\n",
        "arr[5:]\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 48,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1t4V3OSaYulH",
        "outputId": "7b79010b-1b93-447d-e607-4dc24255ea48"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([1, 2, 3, 4, 5])"
            ]
          },
          "execution_count": 48,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Slice elements from the beginning to index 5 (not included):\n",
        "\n",
        "\n",
        "arr[:5]\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "o8csRulLYulH"
      },
      "source": [
        "Have you heared about **Negative Slicing?**\n",
        "\n",
        "We can use the minus operator to refer to an index from the end:\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 49,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "p8rngJgxYulH",
        "outputId": "e23b1c61-44d6-42f4-d5f5-383fea0aca69"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([8, 9])"
            ]
          },
          "execution_count": 49,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Slice from the index 3 from the end to index 1 from the end:\n",
        "\n",
        "\n",
        "arr[-3:-1]\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "_sk9yNamYulH"
      },
      "source": [
        "**STEP**\n",
        "\n",
        "Use the step value to determine the step of the slicing:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 50,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1OXANncfYulH",
        "outputId": "5ab8e7f9-19de-41e3-dccb-0aeb443ce6b3"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([2, 4, 6])"
            ]
          },
          "execution_count": 50,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Print every other element from index 1 to index 7:\n",
        "\n",
        "arr[1:7:2]\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "mpk1-Nd2YulH"
      },
      "source": [
        "Did you see? using step you were able to get alternate elements within specified index numbers."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 51,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HxPLcXudYulH",
        "outputId": "3936bd16-dfc2-4fa7-94f2-cda76d0f26b6"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([1, 3, 5, 7, 9])"
            ]
          },
          "execution_count": 51,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Return every other element from the entire array arr:\n",
        "\n",
        "arr[::2]\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "d3m3TAVKYulH"
      },
      "source": [
        "well done!\n",
        "\n",
        "Lets do some slicing on 2-D array also. We already have 'a' as our 2-D array. We will use it here.\n",
        "\n",
        "**2. Array slicing in 2-D array.**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 52,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rPVvZ707YulI",
        "outputId": "7b9317ca-8718-4539-a476-99d8764b27fb"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[1, 2, 3],\n",
              "       [4, 5, 6],\n",
              "       [7, 8, 9]])"
            ]
          },
          "execution_count": 52,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Print array a\n",
        "import numpy as np\n",
        "\n",
        "a = np.reshape([x for x in range(1,10)],(3,-1))\n",
        "\n",
        "a\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 53,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uGHClMHiYulI",
        "outputId": "ac5ca35c-8d37-4627-a8b0-86d801c8c609"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[8, 9]])"
            ]
          },
          "execution_count": 53,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# From the third element, slice elements from index 1 to index 5 (not included) from array 'a'\n",
        "\n",
        "a[2:,1:]\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 54,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mApmbts7YulI",
        "outputId": "37f03c73-6de8-4928-be85-d1e3351f2f12"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[3],\n",
              "       [6],\n",
              "       [9]])"
            ]
          },
          "execution_count": 54,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# In array 'a' print index 2 from all the elements :\n",
        "\n",
        "a[:,-1:]\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 55,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XupmT4oLYulI",
        "outputId": "9b503f54-4835-4a82-a90f-724c2dbef322"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[2, 3],\n",
              "       [5, 6],\n",
              "       [8, 9]])"
            ]
          },
          "execution_count": 55,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# From all the elements in 'a', slice index 1 till end, this will return a 2-D array:\n",
        "\n",
        "a[:,1:]\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "3-YDc-LnYulI"
      },
      "source": [
        "Hurray! You have learned Slicing in Numpy array. Now you know to access any numpy array."
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "kCiQoJ7DYulI"
      },
      "source": [
        "## Numpy copy vs view\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 56,
      "metadata": {
        "id": "qMAPlnpnYulI"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "x1= np.arange(0,10)\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 57,
      "metadata": {
        "id": "Fjjpvmw4YulI"
      },
      "outputs": [],
      "source": [
        "# assign x2 = x1\n",
        "\n",
        "x2 = x1"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 58,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CZ8h9KxSYulI",
        "outputId": "7ddfaaf3-a656-4f4b-c6b0-1c2bd9553472"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[0 1 2 3 4 5 6 7 8 9]\n",
            "[0 1 2 3 4 5 6 7 8 9]\n"
          ]
        }
      ],
      "source": [
        "#print x1 and x2\n",
        "\n",
        "print(x1)\n",
        "print(x2)\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "CAOn1lSVYulI"
      },
      "source": [
        "Ok now you have seen that both of them are same "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 59,
      "metadata": {
        "id": "H12TCKrSYulJ"
      },
      "outputs": [],
      "source": [
        "# change 1st element of x2 as 10\n",
        "\n",
        "x2[0] = 10\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 60,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jO5qSqZVYulJ",
        "outputId": "a68618fb-de97-4f22-8c39-cc90219622b4"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[10  1  2  3  4  5  6  7  8  9]\n",
            "[10  1  2  3  4  5  6  7  8  9]\n"
          ]
        }
      ],
      "source": [
        "#Again print x1 and x2\n",
        "\n",
        "print(x1)\n",
        "print(x2)\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "I6f78s_QYulJ"
      },
      "source": [
        "Wait a minute. Just check your above result on change of x2, x1 also got changed. Why?\n",
        "\n",
        "Lets check if both the variables shares memory. Use numpy shares_memory() function to check if both x1 and x2 shares a  memory.\n",
        "\n",
        "Refer: https://numpy.org/doc/stable/reference/generated/numpy.shares_memory.html"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 61,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wruaMhObYulJ",
        "outputId": "e358b8c8-0849-4dbb-ffec-18ba900d5f2f"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "execution_count": 61,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Check memory share between x1 and x2\n",
        "np.shares_memory(x1,x2)\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "8FfiAWw_YulJ"
      },
      "source": [
        "Hey It's True they both share memory\n",
        "\n",
        "Shall we try **view()** function also likwise."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 62,
      "metadata": {
        "id": "ylweEJUtYulJ"
      },
      "outputs": [],
      "source": [
        "# Create a view of x1 and store it in x3.\n",
        "x3 = x1.view()\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 63,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "La-iF23VYulJ",
        "outputId": "09196e72-39c2-4f8c-db4f-1381c02239ea"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "execution_count": 63,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Again check memory share between x1 and x3\n",
        "\n",
        "np.shares_memory(x1,x3)\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "vkE_1h-5YulJ"
      },
      "source": [
        "Woh! simple assignment is similar to view. That means \n",
        "The view does not own the data and any changes made to the view will affect the original array, and any changes made to the original array will affect the view.\n",
        "\n",
        "Don't agree? ok lets change x3 and see if original array i.e. x1 also changes"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 64,
      "metadata": {
        "id": "34UnXXvwYulJ"
      },
      "outputs": [],
      "source": [
        "#Change 1st element of x3=100\n",
        "\n",
        "x3[0]=100"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 65,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "p64U7WsGYulJ",
        "outputId": "f455ccca-e6a0-4e62-ceaa-1fd6abc999fb"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[100   1   2   3   4   5   6   7   8   9]\n",
            "[100   1   2   3   4   5   6   7   8   9]\n"
          ]
        }
      ],
      "source": [
        "#print x1 and x3 to check if changes reflected in both\n",
        "print(x1)\n",
        "print(x3)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "aPgZUErOYulK"
      },
      "source": [
        "Now its proved.\n",
        "\n",
        "Lets see how **Copy()** function works"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 66,
      "metadata": {
        "id": "AB_dXmMrYulK"
      },
      "outputs": [],
      "source": [
        "# Now create an array x4 which is copy of x1\n",
        "\n",
        "x4=x1.copy()\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 67,
      "metadata": {
        "id": "8_Ub7cuZYulK"
      },
      "outputs": [],
      "source": [
        "# Change the last element of x4 as 900\n",
        "x4[-1]=900\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 68,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xEUDBraHYulK",
        "outputId": "c674b6ca-174b-4e68-d94a-9de7ee71a0d3"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[100   1   2   3   4   5   6   7   8   9]\n",
            "[100   1   2   3   4   5   6   7   8 900]\n"
          ]
        }
      ],
      "source": [
        "# print both x1 and x4 to check if changes reflected in both\n",
        "\n",
        "print(x1)\n",
        "print(x4)\n",
        "\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "uMfFQMlNYulK"
      },
      "source": [
        "Hey! such an intresting output. You noticed buddy! your original array didn't get changed on change of its copy ie. x4.\n",
        "\n",
        "Still not convinced? Ok lets see if they both share memory or not"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 69,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VZbJx19hYulK",
        "outputId": "db9676a9-675c-4133-effd-71fba2457a65"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "execution_count": 69,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "#Check memory share between x1 and x4\n",
        "\n",
        "np.shares_memory(x1,x4)\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "RJ3WXKIjYulK"
      },
      "source": [
        "You see! x1 and x4 don't share its memory. \n",
        "\n",
        "So with all our outputs we can takeaway few points:\n",
        "\n",
        "    1. The main difference between a copy and a view of an array is that the copy is a new array, and the view is just a view of the original array.\n",
        "\n",
        "    2. The copy owns the data and any changes made to the copy will not affect original array, and any changes made to the original array will not affect the copy.\n",
        "\n",
        "    3. The view does not own the data and any changes made to the view will affect the original array, and any changes made to the original array will affect the view."
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "ByEnSeiBYulL"
      },
      "source": [
        "## More operations on Numpy\n",
        "\n",
        "**1. Applying conditions**\n",
        "\n",
        "Reference: https://thispointer.com/python-numpy-select-elements-or-indices-by-conditions-from-numpy-array/"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 70,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XQJuDfwNYulL",
        "outputId": "de8f5a7e-45ec-49f3-af05-a34bf5213ce6"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[1, 2, 3],\n",
              "       [4, 5, 6],\n",
              "       [7, 8, 9]])"
            ]
          },
          "execution_count": 70,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "#print a\n",
        "import numpy as np\n",
        "\n",
        "a = np.reshape([x for x in range(1,10)],(3,-1))\n",
        "\n",
        "a\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "2YTPBtyxYulL"
      },
      "source": [
        "We are going to use 'a' array for all our array condition operations.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 71,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 53
        },
        "id": "JQSbD9JZYulL",
        "outputId": "cb3e6647-8861-41ef-8efa-d51c6ed0ede4"
      },
      "outputs": [
        {
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'\\nComparison Operator will be applied to each element in array and number of elements in returned bool Numpy Array will be same as original Numpy Array. \\nBut but for every element that satisfies the condition there will be True in array and False for Others in the returned array.\\n'"
            ]
          },
          "execution_count": 71,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Check if every element in array a greater than 3 or not Using '>' notation\n",
        "\n",
        "boolArr1 = a > 3 \n",
        "\n",
        "boolArr1\n",
        "\n",
        "\"\"\"\n",
        "Comparison Operator will be applied to each element in array and number of elements in returned bool Numpy Array will be same as original Numpy Array. \n",
        "But but for every element that satisfies the condition there will be True in array and False for Others in the returned array.\n",
        "\"\"\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 72,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TpfwOR_yYulL",
        "outputId": "1cb1ffad-fad5-4ee9-ca21-164bb3762b30"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([4, 5, 6, 7, 8, 9])"
            ]
          },
          "execution_count": 72,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Get a list with all elements of array 'a' grater than 3\n",
        "\n",
        "newArray = a[a>3]\n",
        "\n",
        "newArray\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 73,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2GYqOEcBYulL",
        "outputId": "d8ab737e-329c-4d6b-92d6-30c71823bc04"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([4, 5])"
            ]
          },
          "execution_count": 73,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Get a list with all elements of array 'a' greater than 3 but less than 6\n",
        "\n",
        "newArray = a[(a>3) & (a<6)]\n",
        "\n",
        "newArray\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 74,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "x7Aa1gSQYulL",
        "outputId": "f0e2d8b5-8dde-409c-ee64-b16b40268e89"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([ True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
              "       False])"
            ]
          },
          "execution_count": 74,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# check if each elements in array 'x1' equals array 'x4' using '==' notation\n",
        "\n",
        "boolArr2 = x1==x4\n",
        "\n",
        "boolArr2\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "TdNqXx9WYulM"
      },
      "source": [
        "You can see in above output that the last element is not same in both x1 and x4\n",
        "\n",
        "Well done so far.\n",
        "\n",
        "Lets check how to transpose an array\n",
        "\n",
        "**2. Transposing array**\n",
        "\n",
        "Reference: https://www.geeksforgeeks.org/python-numpy-numpy-transpose/\n",
        "           https://numpy.org/doc/stable/reference/generated/numpy.transpose.html\n",
        "           https://numpy.org/doc/stable/reference/generated/numpy.ndarray.T.html"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 75,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "grdPKy65YulM",
        "outputId": "5913804e-da36-4d5e-f1b7-5298dee879a8"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[1 4 7]\n",
            " [2 5 8]\n",
            " [3 6 9]]\n",
            "-----------------\n",
            "[[1 2 3]\n",
            " [4 5 6]\n",
            " [7 8 9]]\n"
          ]
        }
      ],
      "source": [
        "# Print Transpose of array 'a'\n",
        "print(np.transpose(a))\n",
        "\n",
        "#print array 'a'\n",
        "print(\"-----------------\")\n",
        "\n",
        "print(a)\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "i8NBkK3OYulM"
      },
      "source": [
        "In above output all the rows became columns by transposing "
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "1vgtMyk8YulM"
      },
      "source": [
        "**3. hstack vs vstack function**\n",
        "\n",
        "\n",
        "Stacking is same as concatenation, the only difference is that stacking is done along a new axis.\n",
        "\n",
        "NumPy provides a helper function: \n",
        "\n",
        "1. hstack() to stack along rows.\n",
        "2. vstack()  to stack along columns\n",
        "\n",
        "You wanna see how? Then here we go...!\n",
        "\n",
        "reference doc: https://scipython.com/book/chapter-6-numpy/examples/vstack-and-hstack/"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 76,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8iXSmEsmYulM",
        "outputId": "0b83453b-a80c-4676-91ef-a93a7fca9910"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[100,   1,   2,   3,   4,   5,   6,   7,   8,   9],\n",
              "       [100,   1,   2,   3,   4,   5,   6,   7,   8, 900]])"
            ]
          },
          "execution_count": 76,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# stack x1 and x4 along columns.\n",
        "x5 = np.vstack((x1,x4))\n",
        "x5"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 77,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VQpItcdCYulM",
        "outputId": "070da109-6ecd-4efa-bcbe-ffedbac67772"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([100,   1,   2,   3,   4,   5,   6,   7,   8,   9, 100,   1,   2,\n",
              "         3,   4,   5,   6,   7,   8, 900])"
            ]
          },
          "execution_count": 77,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "#stack x1 and x4 along rows\n",
        "x6 = np.hstack((x1,x4))\n",
        "x6"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "YJD_N7B_YulM"
      },
      "source": [
        "We hope now you saw the difference between them.\n",
        "\n",
        "Fun fact! you can even use concatenate() function to join 2 arrays along with the axis. If axis is not explicitly passed, it is taken as 0 ie. along column\n",
        "\n",
        "Lets try this function as well\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 78,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "P2SNMvTaYulM",
        "outputId": "d8718bd2-b35d-40fb-f19f-abf2684827b1"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[1, 2, 5, 6],\n",
              "       [3, 4, 7, 8]])"
            ]
          },
          "execution_count": 78,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "import numpy as np\n",
        "\n",
        "arr1 = [[1, 2], [3, 4]]\n",
        "\n",
        "\n",
        "arr2 = [[5, 6], [7, 8]]\n",
        "\n",
        "\n",
        "##join arr1 and arr2 along rows using concatenate() function\n",
        "\n",
        "arr = np.concatenate((arr1,arr2), axis =1)\n",
        "\n",
        "arr"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 79,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dbf1xSfeYulN",
        "outputId": "3656f4f2-8db6-4b53-f168-c0a93bc3115c"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[1, 2],\n",
              "       [3, 4],\n",
              "       [5, 6],\n",
              "       [7, 8]])"
            ]
          },
          "execution_count": 79,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "##join arr1 and arr2 along columns using concatenate() function\n",
        "\n",
        "arr = np.concatenate((arr1,arr2), axis =0)\n",
        "\n",
        "arr"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "WKy9Lu4vYulN"
      },
      "source": [
        "## Adding, Insert and delete Numpy array\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "_W4bZ70AYulN"
      },
      "source": [
        "You can also add 2 arrays using append() function also. This function appends values to end of array\n",
        "\n",
        "Lets see how"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 80,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yC1yIKfPYulN",
        "outputId": "02297f47-1a0a-42cf-f847-4cd5296d3745"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([1, 2, 3, 4, 5, 6, 7, 8])"
            ]
          },
          "execution_count": 80,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# append arr2 to arr1\n",
        "\n",
        "arr = np.append(arr1,arr2)\n",
        "arr"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "Jb4EPxL4YulN"
      },
      "source": [
        "Lets use insert() function which Inserts values into array before specified index value"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 85,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2pF_KctFYulN",
        "outputId": "3fac04e4-a564-46fc-fd34-b0aab136b97f"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([100,   1,   2,   3, 100,   1,   2,   3,   4,   5,   6,   7,   8,\n",
              "       900,   4,   5,   6,   7,   8,   9])"
            ]
          },
          "execution_count": 85,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Inserts values into array x1 before index 4 with elements of x4\n",
        "\n",
        "np.insert(x1,[4],x4)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "uTDcvWAPYulN"
      },
      "source": [
        "You can see in above output we have inserted all the elements of x4 before index 4 in array x1."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 86,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "btEqORsVYulN",
        "outputId": "986fda4d-14bd-48a2-89c4-fe03042c0f0c"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([100,   1,   3,   4,   5,   6,   7,   8,   9])"
            ]
          },
          "execution_count": 86,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# delete 2nd element from array x2\n",
        "\n",
        "np.delete(x2,2)\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "HcSC-kfxYulO"
      },
      "source": [
        "Did you see? 2 value is deleted from x2 which was at index position 2"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "4pOQseKpYulO"
      },
      "source": [
        "## Mathmatical operations on Numpy array\n",
        "\n",
        "Reference doc for Numpy Mathmatical functions: https://numpy.org/doc/stable/reference/routines.math.html"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 88,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bNI8S0McYulO",
        "outputId": "3176b106-cc90-4fc1-f4d0-57fb4be6785e"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[1, 2, 3],\n",
              "       [4, 5, 6],\n",
              "       [7, 8, 9]])"
            ]
          },
          "execution_count": 88,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "a= np.array([[1,2,3],[4,5,6],[7,8,9]])\n",
        "a"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 89,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Zr_V_3txYulO",
        "outputId": "d318d210-777e-496c-8ace-785f27b77dab"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[ 0.84147098,  0.90929743,  0.14112001],\n",
              "       [-0.7568025 , -0.95892427, -0.2794155 ],\n",
              "       [ 0.6569866 ,  0.98935825,  0.41211849]])"
            ]
          },
          "execution_count": 89,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# print trigonometric sin value of each element of a\n",
        "\n",
        "np.sin(a)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 90,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PC1Tbwj9YulO",
        "outputId": "77181901-d9bf-4f64-a16d-c9068091b724"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[ 0.54030231, -0.41614684, -0.9899925 ],\n",
              "       [-0.65364362,  0.28366219,  0.96017029],\n",
              "       [ 0.75390225, -0.14550003, -0.91113026]])"
            ]
          },
          "execution_count": 90,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# print trigonometric cos value of each element of a\n",
        "\n",
        "np.cos(a)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 91,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "63iIO3f9YulO",
        "outputId": "709d7d3f-d9d7-459e-f283-25275a010180"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[2.71828183e+00, 7.38905610e+00, 2.00855369e+01],\n",
              "       [5.45981500e+01, 1.48413159e+02, 4.03428793e+02],\n",
              "       [1.09663316e+03, 2.98095799e+03, 8.10308393e+03]])"
            ]
          },
          "execution_count": 91,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Print exponential value of each elements of a\n",
        "np.exp(a)\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "wm0g6ThYYulO"
      },
      "source": [
        "Referal: https://numpy.org/doc/stable/reference/generated/numpy.sum.html"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 92,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "s3B4bFujYulO",
        "outputId": "8f1f6a4e-8699-443b-dfa1-f5534d4081d7"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "45"
            ]
          },
          "execution_count": 92,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# print total sum of elements of a\n",
        "\n",
        "np.sum(a)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 93,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dUTtv9SqYulO",
        "outputId": "5c29b245-da46-4368-a8ba-7ae20dbbcf8b"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([ 6, 15, 24])"
            ]
          },
          "execution_count": 93,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Print sum in array a column wise\n",
        "np.nansum(a,axis=1)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 94,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "x0lJolWRYulP",
        "outputId": "20e668f7-0ed2-49a9-9870-d708dee4ada0"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([12, 15, 18])"
            ]
          },
          "execution_count": 94,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Print sum in array a row wise\n",
        "\n",
        "np.nansum(a,axis=0)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "TXULCGQyYulP"
      },
      "source": [
        "Refrence doc: https://numpy.org/doc/stable/reference/generated/numpy.median.html"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 95,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xOUP_dbpYulP",
        "outputId": "1e660db9-fb16-4851-aa3d-3248f618486e"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "5.0"
            ]
          },
          "execution_count": 95,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# print median of array a\n",
        "\n",
        "np.median(a)\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "6tnsJXeMYulP"
      },
      "source": [
        "Refrence doc: https://numpy.org/doc/stable/reference/generated/numpy.std.html"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 96,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ThkUIu5GYulP",
        "outputId": "e0a84edf-430b-440e-fb25-96541706451d"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "2.581988897471611"
            ]
          },
          "execution_count": 96,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# print standard deviation of array a\n",
        "\n",
        "np.std(a)\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "ehT4vuIWYulP"
      },
      "source": [
        "Refrence doc: https://numpy.org/doc/stable/reference/generated/numpy.linalg.det.html"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 97,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aDaeOUNxYulQ",
        "outputId": "c9aa25f4-0d0a-4dd3-c927-689ed3b74ea0"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "0.0"
            ]
          },
          "execution_count": 97,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# print the determinant of array a\n",
        "\n",
        "np.linalg.det(a)\n",
        "\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "iLO4Wqjvi81-"
      },
      "source": [
        "### **`Note: If your output is zero, it's correct. Our value is negligible too.`**"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "FCKIlHTLYulQ"
      },
      "source": [
        "reference doc: https://numpy.org/doc/stable/reference/generated/numpy.linalg.inv.html"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 98,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 380
        },
        "id": "x3O3hN-GYulQ",
        "outputId": "7a9536d6-50f3-416a-e51f-e6346d9ffd3a"
      },
      "outputs": [
        {
          "ename": "LinAlgError",
          "evalue": "ignored",
          "output_type": "error",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mLinAlgError\u001b[0m                               Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-98-e724b9cebcbe>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# print the (multiplicative) inverse of array a\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlinalg\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minv\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m<__array_function__ internals>\u001b[0m in \u001b[0;36minv\u001b[0;34m(*args, **kwargs)\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/numpy/linalg/linalg.py\u001b[0m in \u001b[0;36minv\u001b[0;34m(a)\u001b[0m\n\u001b[1;32m    543\u001b[0m     \u001b[0msignature\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'D->D'\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0misComplexType\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0;34m'd->d'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    544\u001b[0m     \u001b[0mextobj\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_linalg_error_extobj\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_raise_linalgerror_singular\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 545\u001b[0;31m     \u001b[0mainv\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_umath_linalg\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minv\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msignature\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0msignature\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mextobj\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mextobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    546\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mwrap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mainv\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mastype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresult_t\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcopy\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    547\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/numpy/linalg/linalg.py\u001b[0m in \u001b[0;36m_raise_linalgerror_singular\u001b[0;34m(err, flag)\u001b[0m\n\u001b[1;32m     86\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     87\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_raise_linalgerror_singular\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0merr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mflag\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 88\u001b[0;31m     \u001b[0;32mraise\u001b[0m \u001b[0mLinAlgError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Singular matrix\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     89\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     90\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_raise_linalgerror_nonposdef\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0merr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mflag\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mLinAlgError\u001b[0m: Singular matrix"
          ]
        }
      ],
      "source": [
        "# print the (multiplicative) inverse of array a\n",
        "\n",
        "np.linalg.inv(a)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "PSdNwhMCjG_8"
      },
      "source": [
        "### **`Note: If your output is throwing error, it's correct. Once determinant is zero, it's inverse does not exist. Our value is negligible too.`**"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "8QDcUvZaYulQ"
      },
      "source": [
        "Reference doc: https://numpy.org/doc/stable/reference/generated/numpy.linalg.eig.html"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 99,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pSsF337GYulQ",
        "outputId": "a5c2c627-5929-4ed2-8a84-72ed07914cc7"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(array([ 1.61168440e+01, -1.11684397e+00, -1.30367773e-15]),\n",
              " array([[-0.23197069, -0.78583024,  0.40824829],\n",
              "        [-0.52532209, -0.08675134, -0.81649658],\n",
              "        [-0.8186735 ,  0.61232756,  0.40824829]]))"
            ]
          },
          "execution_count": 99,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Print the eigenvalues and right eigenvectors of array a.\n",
        "np.linalg.eig(a)\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "90M-qatlYulQ"
      },
      "source": [
        "Reference doc: https://numpy.org/doc/stable/reference/generated/numpy.dot.html"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 100,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YvK35W7xYulQ",
        "outputId": "4ff3568e-da3c-41a2-946e-036f3e09b36a"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[19, 22],\n",
              "       [43, 50]])"
            ]
          },
          "execution_count": 100,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# compute dot product of arr1 and arr2\n",
        "\n",
        "np.dot(arr1,arr2)\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "7FtPtN2RYulR"
      },
      "source": [
        "reference doc: https://numpy.org/doc/stable/reference/generated/numpy.ndarray.max.html"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 101,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "puuomFoWYulR",
        "outputId": "13368d2d-620d-49b2-ba4a-bdbffe0ba6b4"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "9"
            ]
          },
          "execution_count": 101,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "#print largest element present in array a\n",
        "\n",
        "np.ndarray.max(a)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "idjVls_yYulR"
      },
      "source": [
        "Reference doc: https://numpy.org/doc/stable/reference/generated/numpy.argmax.html"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 102,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iPerydXGYulR",
        "outputId": "81599ab8-5d08-4208-e0ea-cc95ee61be7f"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "8"
            ]
          },
          "execution_count": 102,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "#print index of largest element present in array a \n",
        "\n",
        "np.argmax(a)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "rdIfEac-YulR"
      },
      "source": [
        "Reference doc: https://numpy.org/doc/stable/reference/generated/numpy.sort.html"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 103,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JgVZXhepYulR",
        "outputId": "aad4a330-c54e-480e-95bd-49ee63948e6a"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([  1,   2,   3,   4,   5,   6,   7,   8, 100, 900])"
            ]
          },
          "execution_count": 103,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# print sorted x4 array\n",
        "\n",
        "np.sort(x4)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "1GXRAgFaYulR"
      },
      "source": [
        "Reference doc: https://numpy.org/doc/stable/reference/generated/numpy.argsort.html"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 105,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cYG_VojYYulR",
        "outputId": "69c0f9ca-b882-4e7e-9d96-df3c743aef60"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([1, 2, 3, 4, 5, 6, 7, 8, 0, 9])"
            ]
          },
          "execution_count": 105,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# print indices of each sorted element in x4 array\n",
        "\n",
        "np.argsort(x4)\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "UqIBFqzqYulR"
      },
      "source": [
        "## Searching Arrays\n",
        "\n",
        "Reference: \n",
        "- https://www.geeksforgeeks.org/numpy-where-in-python/\n",
        "- https://numpy.org/doc/stable/reference/generated/numpy.where.html\n",
        "\n",
        "You can search an array for a certain value, and return the indexes that get a match.\n",
        "\n",
        "To search an array, use the where() method."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 107,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Os0xU99BYulS",
        "outputId": "2d0fc669-97db-4c1c-e653-2b59939d58fc"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(array([4]),)"
            ]
          },
          "execution_count": 107,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# print the indexes where the value is 4 in array x1\n",
        "\n",
        "np.where(x1==4)\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "WzPpYWvJYulS"
      },
      "source": [
        "Which means that the value 4 is present at index 4\n",
        "\n",
        "You can check it by printing array x1"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 108,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DnoJA3iQYulS",
        "outputId": "2d5c1b3f-bd7d-40ad-b23f-d3cd2ba9376e"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[100   1   2   3   4   5   6   7   8   9]\n"
          ]
        }
      ],
      "source": [
        "#print array x1\n",
        "\n",
        "print(x1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 109,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GGOLxwKAYulS",
        "outputId": "a07ceabc-d20b-4f63-fa62-5b54daef0b1d"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(array([0, 2, 4, 6, 8]),)"
            ]
          },
          "execution_count": 109,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Print the indexes where the values are even in array x1\n",
        "\n",
        "np.where(x1%2==0)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 120,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZVjXEAYQYulS",
        "outputId": "6fc9a6ea-4640-4885-a394-1dfcb390fb49"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([100,   0,   0,   0,   0,   0,   6,   7,   8,   9])"
            ]
          },
          "execution_count": 120,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Print x1 where x1 is greater than 5, also if number is less than 5 then replace it with 0\n",
        "b = np.where(x1>5,x1,0)\n",
        "b"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "3XDGaMkZYulS"
      },
      "source": [
        "Good Job learner! \n",
        "\n",
        "---------------------\n",
        "# Bam! Congratulations You have completed your milestone challenge too!\n",
        "\n",
        "----------------------"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "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.8.5"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}