Day_5_Numpy_Part_1.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Day_5_Numpy_Part_1.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yNMy_TNjUrdd",
        "colab_type": "text"
      },
      "source": [
        "## **Introduction to NumPy:**\n",
        "```NumPy``` stands for *Numerical Python* and it's a fundamental package for scientific computing in Python. NumPy provides Python with an extensive math library capable of performing numerical computations effectively and efficiently. These lessons are intended as a basic overview of NumPy and introduces some of its most important features.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oPnpCMIeYA90",
        "colab_type": "text"
      },
      "source": [
        "## **Why Numpy:**\n",
        "You may be wondering why people use NumPy - after all, Python can handle lists, as you learned in the Intro to Python lessons.\n",
        "\n",
        "Even though Python lists are great on their own, NumPy has a number of key features that give it great advantages over Python lists. One such feature is speed. When performing operations on large arrays NumPy can often perform several orders of magnitude faster than Python lists. This speed comes from the nature of NumPy arrays being memory-efficient and from optimized algorithms used by NumPy for doing arithmetic, statistical, and linear algebra operations."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1D9wUejeTCUi",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import time\n",
        "import numpy as np"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cx33B30cYJzv",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x = np.random.rand(1000000000)"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xXpuBxHLYOWg",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 54
        },
        "outputId": "e72cc273-38e1-4398-8aa1-6f08f9a776f3"
      },
      "source": [
        "start = time.time()\n",
        "mean = sum(x)/len(x)\n",
        "print(time.time() - start)"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "164.07553839683533\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zwi39jQRYkye",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 54
        },
        "outputId": "11d53351-1df7-4e2c-e5cb-71c9ffd2185d"
      },
      "source": [
        "start = time.time()\n",
        "mean_np = np.mean(x)\n",
        "print(time.time() - start)"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0.6675674915313721\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Dibh7I4LcMdb",
        "colab_type": "text"
      },
      "source": [
        "## **Creating NumPy ndarrays:**\n",
        "At the core of NumPy is the ndarray, where nd stands for n-dimensional. An ndarray is a multidimensional array of elements all of the same type. In other words, an ndarray is a grid that can take on many shapes and can hold either numbers or strings. In many Machine Learning problems you will often find yourself using ndarrays in many different ways. For instance, you might use an ndarray to hold the pixel values of an image that will be fed into a Neural Network for image classification."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6XWJHaq0cabp",
        "colab_type": "text"
      },
      "source": [
        "There are several ways to create ndarrays in NumPy. In the following lessons we will see two ways to create ndarrays:\n",
        "\n",
        "1. Using regular Python lists\n",
        "\n",
        "2. Using built-in NumPy functions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "itKv0T1acqnf",
        "colab_type": "text"
      },
      "source": [
        "In this section, we will create ndarrays by providing Python lists to the NumPy np.array() function, it is just a function that returns an ndarray. We should note that for the purposes of clarity, the examples throughout these lessons will use small and simple ndarrays. Let's start by creating 1-Dimensional (1D) ndarrays."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bUHEilP2ZN5J",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 54
        },
        "outputId": "13235ae1-b467-40b6-9c17-18f8082e2ef8"
      },
      "source": [
        "# We import NumPy into Python\n",
        "import numpy as np\n",
        "\n",
        "# We create a 1D ndarray that contains only integers\n",
        "x = np.array([1, 2, 3, 4, 5])\n",
        "\n",
        "# Let's print the ndarray we just created using the print() command\n",
        "print('x = ', x)"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "x =  [1 2 3 4 5]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Oi4x0r2fvwSd",
        "colab_type": "text"
      },
      "source": [
        "## **Shape of an ndarray:**\n",
        "Another important property of arrays is their shape. The shape of an array is the size along each of its dimensions. As you will see, NumPy ndarrays have attributes that allows us to get information about them in a very intuitive way. For example, the shape of an ndarray can be obtained using the .shape attribute. The shape attribute returns a tuple of N positive integers that specify the sizes of each dimension."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xskCTsNRc2HK",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 137
        },
        "outputId": "fc340f5a-ff85-47f0-bb26-306106ad797e"
      },
      "source": [
        "# We create a 1D ndarray that contains only integers\n",
        "x = np.array([1, 2, 3, 4, 5])\n",
        "\n",
        "# We print x\n",
        "print()\n",
        "print('x = ', x)\n",
        "print()\n",
        "\n",
        "# We print information about x\n",
        "print('x has dimensions:', x.shape)\n",
        "print('x is an object of type:', type(x))\n",
        "print('The elements in x are of type:', x.dtype)"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "x =  [1 2 3 4 5]\n",
            "\n",
            "x has dimensions: (5,)\n",
            "x is an object of type: <class 'numpy.ndarray'>\n",
            "The elements in x are of type: int64\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MLYrG8oLwXb2",
        "colab_type": "text"
      },
      "source": [
        "We can see that the shape attribute returns the tuple (5,) telling us that x is of rank 1 (i.e. x only has 1 dimension ) and it has 5 elements. The type() function tells us that x is indeed a NumPy ndarray. Finally, the .dtype attribute tells us that the elements of x are stored in memory as signed 64-bit integers. Another great advantage of NumPy is that it can handle more data-types than Python lists.[here](https://docs.scipy.org/doc/numpy-1.13.0/user/basics.types.html)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DTCnuASsz3mq",
        "colab_type": "text"
      },
      "source": [
        "As mentioned earlier, ndarrays can also hold strings. Let's see how we can create a rank 1 ndarray of strings in the same manner as before, by providing the np.array() function a Python list of strings."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "W3rhKGfAwAOH",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 137
        },
        "outputId": "c7b085a7-ac97-4e3d-aa93-8757291e7ef4"
      },
      "source": [
        "# We create a rank 1 ndarray that only contains strings\n",
        "x = np.array(['Hello', 'World'])\n",
        "\n",
        "# We print x\n",
        "print()\n",
        "print('x = ', x)\n",
        "print()\n",
        "\n",
        "# We print information about x\n",
        "print('x has dimensions:', x.shape)\n",
        "print('x is an object of type:', type(x))\n",
        "print('The elements in x are of type:', x.dtype)"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "x =  ['Hello' 'World']\n",
            "\n",
            "x has dimensions: (2,)\n",
            "x is an object of type: <class 'numpy.ndarray'>\n",
            "The elements in x are of type: <U5\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XaJ8fHUx0Ey7",
        "colab_type": "text"
      },
      "source": [
        "It is important to remember that one big difference between Python lists and ndarrays, is that unlike Python lists, all the elements of an ndarray must be of the same type. So, while we can create Python lists with both integers and strings, we can't mix types in ndarrays. If you provide the np.array() function with a Python list that has both integers and strings, NumPy will interpret all elements as strings. We can see this in the next example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ACE0Mqcrz5-E",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 137
        },
        "outputId": "f20b73e7-fd02-47f1-d9ed-20923c0da42d"
      },
      "source": [
        "# We create a rank 1 ndarray from a Python list that contains integers and strings\n",
        "x = np.array([1, 2, 'World'])\n",
        "\n",
        "# We print the ndarray\n",
        "print()\n",
        "print('x = ', x)\n",
        "print()\n",
        "\n",
        "# We print information about x\n",
        "print('x has dimensions:', x.shape)\n",
        "print('x is an object of type:', type(x))\n",
        "print('The elements in x are of type:', x.dtype)"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "x =  ['1' '2' 'World']\n",
            "\n",
            "x has dimensions: (3,)\n",
            "x is an object of type: <class 'numpy.ndarray'>\n",
            "The elements in x are of type: <U21\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PFK0xNh-1hkE",
        "colab_type": "text"
      },
      "source": [
        "Let us now look at how we can create a rank 2 ndarray from a nested Python list."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mCEls7XS0IDI",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 220
        },
        "outputId": "600e0e6e-35cc-4bea-e8c5-85cfc3fca72a"
      },
      "source": [
        "# We create a rank 2 ndarray that only contains integers\n",
        "Y = np.array([[1,2,3],[4,5,6],[7,8,9], [10,11,12]])\n",
        "\n",
        "# We print Y\n",
        "print()\n",
        "print('Y = \\n', Y)\n",
        "print()\n",
        "\n",
        "# We print information about Y\n",
        "print('Y has dimensions:', Y.shape)\n",
        "print('Y has a total of', Y.size, 'elements')\n",
        "print('Y is an object of type:', type(Y))\n",
        "print('The elements in Y are of type:', Y.dtype)"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Y = \n",
            " [[ 1  2  3]\n",
            " [ 4  5  6]\n",
            " [ 7  8  9]\n",
            " [10 11 12]]\n",
            "\n",
            "Y has dimensions: (4, 3)\n",
            "Y has a total of 12 elements\n",
            "Y is an object of type: <class 'numpy.ndarray'>\n",
            "The elements in Y are of type: int64\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BEGW5NcV1uK5",
        "colab_type": "text"
      },
      "source": [
        "Up to now, we have only created ndarrays with integers and strings. We saw that when we create an ndarray with only integers, NumPy will automatically assign the dtype int64 to its elements. Let's see what happens when we create ndarrays with floats and integers."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bb26oQPg1jty",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 87
        },
        "outputId": "9a62d4b3-72e7-4ace-c6c0-e9c518b0e34f"
      },
      "source": [
        "# We create a rank 1 ndarray that contains integers\n",
        "x = np.array([1,2,3])\n",
        "\n",
        "# We create a rank 1 ndarray that contains floats\n",
        "y = np.array([1.0,2.0,3.0])\n",
        "\n",
        "# We create a rank 1 ndarray that contains integers and floats\n",
        "z = np.array([1, 2.5, 4])\n",
        "\n",
        "# We print the dtype of each ndarray\n",
        "print('The elements in x are of type:', x.dtype)\n",
        "print('The elements in y are of type:', y.dtype)\n",
        "print('The elements in z are of type:', z.dtype)"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The elements in x are of type: int64\n",
            "The elements in y are of type: float64\n",
            "The elements in z are of type: float64\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0z7cLmFD17Kw",
        "colab_type": "text"
      },
      "source": [
        "Notice that when we create an ndarray with both floats and integers, as we did with the z ndarray above, NumPy assigns its elements a *float64* dtype as well. This is called upcasting. Since all the elements of an ndarray must be of the same type, in this case NumPy upcasts the integers in z to floats in order to avoid losing precision in numerical computations."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XUmzWrvr2AVp",
        "colab_type": "text"
      },
      "source": [
        "Even though NumPy automatically selects the dtype of the ndarray, NumPy also allows you to specify the particular dtype you want to assign to the elements of the ndarray. You can specify the dtype when you create the ndarray using the keyword dtype in the np.array() function. Let's see an example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_BSEAZgQ1wsx",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 104
        },
        "outputId": "da136eb8-2dd9-4c3b-f048-1fa9b9e5a740"
      },
      "source": [
        "# We create a rank 1 ndarray of floats but set the dtype to int64\n",
        "x = np.array([1.5, 2.2, 3.7, 4.0, 5.9], dtype = np.int64)\n",
        "\n",
        "# We print x\n",
        "print()\n",
        "print('x = ', x)\n",
        "print()\n",
        "\n",
        "# We print the dtype x\n",
        "print('The elements in x are of type:', x.dtype)"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "x =  [1 2 3 4 5]\n",
            "\n",
            "The elements in x are of type: int64\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IIo6BbvW23A3",
        "colab_type": "text"
      },
      "source": [
        "Once you create an ndarray, you may want to save it to a file to be read later or to be used by another program. NumPy provides a way to save the arrays into files for later use - let's see how this is done."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "heCxnnFC2UcA",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# We create a rank 1 ndarray\n",
        "x = np.array([1, 2, 3, 4, 5])\n",
        "\n",
        "# We save x into the current directory as \n",
        "np.save('my_array', x)"
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2zclAmaE28Ki",
        "colab_type": "text"
      },
      "source": [
        "The above saves the x ndarray into a file named my_array.npy. You can load the saved ndarray into a variable by using the load() function."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fqT_YREU3Bug",
        "colab_type": "text"
      },
      "source": [
        "> When loading an array from a file, make sure you include the name of the file together with the extension .npy, otherwise you will get an error."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "A0LqlywX26AG",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8971e9de-9229-4e21-aab8-53b548734066"
      },
      "source": [
        "# We load the saved array from our current directory into variable y\n",
        "y = np.load('my_array.npy')\n",
        "\n",
        "# We print y\n",
        "print()\n",
        "print('y = ', y)\n",
        "print()\n",
        "\n",
        "# We print information about the ndarray we loaded\n",
        "print('y is an object of type:', type(y))\n",
        "print('The elements in y are of type:', y.dtype)"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "y =  [1 2 3 4 5]\n",
            "\n",
            "y is an object of type: <class 'numpy.ndarray'>\n",
            "The elements in y are of type: int64\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rotqBT2MFNux",
        "colab_type": "text"
      },
      "source": [
        "## **Specialized ndarrays:**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BeRM9Yu7FKVR",
        "colab_type": "text"
      },
      "source": [
        "One great time-saving feature of NumPy is its ability to create ndarrays using built-in functions. These functions allow us to create certain kinds of ndarrays with just one line of code. Below we will see a few of the most useful built-in functions for creating ndarrays that you will come across when doing AI programming.\n",
        "\n",
        "### **np.zeros():**\n",
        "\n",
        "Let's start by creating an ndarray with a specified shape that is full of zeros. We can do this by using the np.zeros() function. The function np.zeros(shape) creates an ndarray full of zeros with the given shape. So, for example, if you wanted to create a rank 2 array with 3 rows and 4 columns, you will pass the shape to the function in the form of (rows, columns), as in the example below:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w97eI9UE2_CQ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ca316a4f-5f98-4e1b-a04f-0104403b3864"
      },
      "source": [
        "# We create a 3 x 4 ndarray full of zeros. \n",
        "X = np.zeros((3,4))\n",
        "\n",
        "# We print X\n",
        "print()\n",
        "print('X = \\n', X)\n",
        "print()\n",
        "\n",
        "# We print information about X\n",
        "print('X has dimensions:', X.shape)\n",
        "print('X is an object of type:', type(X))\n",
        "print('The elements in X are of type:', X.dtype)\n"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "X = \n",
            " [[0. 0. 0. 0.]\n",
            " [0. 0. 0. 0.]\n",
            " [0. 0. 0. 0.]]\n",
            "\n",
            "X has dimensions: (3, 4)\n",
            "X is an object of type: <class 'numpy.ndarray'>\n",
            "The elements in X are of type: float64\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eriuCEtcFah5",
        "colab_type": "text"
      },
      "source": [
        "> As we can see, the np.zeros() function creates by default an array with dtype float64. If desired, the data type can be changed by using the keyword dtype.\n",
        "\n",
        "### **np.ones:**\n",
        "\n",
        "Similarly, we can create an ndarray with a specified shape that is full of ones. We can do this by using the np.ones() function. Just like the np.zeros() function, the np.ones() function takes as an argument the shape of the ndarray you want to make. Let's see an example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iupUtBcYFXWM",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 186
        },
        "outputId": "5eacb580-002e-44bd-eca3-a234b9b15c4a"
      },
      "source": [
        "# We create a 3 x 2 ndarray full of ones. \n",
        "X = np.ones((3,2))\n",
        "\n",
        "# We print X\n",
        "print()\n",
        "print('X = \\n', X)\n",
        "print()\n",
        "\n",
        "# We print information about X\n",
        "print('X has dimensions:', X.shape)\n",
        "print('X is an object of type:', type(X))\n",
        "print('The elements in X are of type:', X.dtype) "
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "X = \n",
            " [[1. 1.]\n",
            " [1. 1.]\n",
            " [1. 1.]]\n",
            "\n",
            "X has dimensions: (3, 2)\n",
            "X is an object of type: <class 'numpy.ndarray'>\n",
            "The elements in X are of type: float64\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XVoiNeI3GJx6",
        "colab_type": "text"
      },
      "source": [
        "### **np.full():**\n",
        "We can also create an ndarray with a specified shape that is full of any number we want. We can do this by using the np.full() function. The np.full(shape, constant value) function takes two arguments. The first argument is the shape of the ndarray you want to make and the second is the constant value you want to populate the array with. Let's see an example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "91DRW1O1Fy9A",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 170
        },
        "outputId": "0da40471-a0eb-4de4-f9bf-a60de030bae6"
      },
      "source": [
        "# We create a 2 x 3 ndarray full of fives. \n",
        "X = np.full((2,3), 5) \n",
        "\n",
        "# We print X\n",
        "print()\n",
        "print('X = \\n', X)\n",
        "print()\n",
        "\n",
        "# We print information about X\n",
        "print('X has dimensions:', X.shape)\n",
        "print('X is an object of type:', type(X))\n",
        "print('The elements in X are of type:', X.dtype)"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "X = \n",
            " [[5 5 5]\n",
            " [5 5 5]]\n",
            "\n",
            "X has dimensions: (2, 3)\n",
            "X is an object of type: <class 'numpy.ndarray'>\n",
            "The elements in X are of type: int64\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Iq62WNEdGcds",
        "colab_type": "text"
      },
      "source": [
        "### **np.eye():**\n",
        "An Identity matrix is a square matrix that has only 1s in its main diagonal and zeros everywhere else. The function np.eye(N) creates a square N x N ndarray corresponding to the Identity matrix. Since all Identity Matrices are square, the np.eye() function only takes a single integer as an argument. Let's see an example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MqrDmyhxGcIO",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 220
        },
        "outputId": "87689d57-208e-43d2-9c2a-16b663980a32"
      },
      "source": [
        "# We create a 5 x 5 Identity matrix. \n",
        "X = np.eye(5)\n",
        "\n",
        "# We print X\n",
        "print()\n",
        "print('X = \\n', X)\n",
        "print()\n",
        "\n",
        "# We print information about X\n",
        "print('X has dimensions:', X.shape)\n",
        "print('X is an object of type:', type(X))\n",
        "print('The elements in X are of type:', X.dtype)  "
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "X = \n",
            " [[1. 0. 0. 0. 0.]\n",
            " [0. 1. 0. 0. 0.]\n",
            " [0. 0. 1. 0. 0.]\n",
            " [0. 0. 0. 1. 0.]\n",
            " [0. 0. 0. 0. 1.]]\n",
            "\n",
            "X has dimensions: (5, 5)\n",
            "X is an object of type: <class 'numpy.ndarray'>\n",
            "The elements in X are of type: float64\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "28i2JuXSGtyZ",
        "colab_type": "text"
      },
      "source": [
        "### **np.diag():**\n",
        "We can also create diagonal matrices by using the np.diag() function. A diagonal matrix is a square matrix that only has values in its main diagonal. The np.diag() function creates an ndarray corresponding to a diagonal matrix , as shown in the example below:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kZ8T3h4pGR29",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "14c149c9-8ac3-4378-da44-4943c08ff295"
      },
      "source": [
        "# Create a 4 x 4 diagonal matrix\n",
        "# on its main diagonal\n",
        "X = np.diag([10,20,30,50])\n",
        "\n",
        "# We print X\n",
        "print()\n",
        "print('X = \\n', X)\n",
        "print()"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "X = \n",
            " [[10  0  0  0]\n",
            " [ 0 20  0  0]\n",
            " [ 0  0 30  0]\n",
            " [ 0  0  0 50]]\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7mcJx5xHHY0Z",
        "colab_type": "text"
      },
      "source": [
        "### **np.arange():**\n",
        "NumPy also allows you to create ndarrays that have evenly spaced values within a given interval. NumPy's np.arange() function is very versatile and can be used with either one, two, or three arguments. Below we will see examples of each case and how they are used to create different kinds of ndarrays.\n",
        "\n",
        "Let's start by using np.arange() with only one argument. When used with only one argument, np.arange(N) will create a rank 1 ndarray with consecutive integers between 0 and N - 1. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "i4ZA3x60Hjpe",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 137
        },
        "outputId": "06d5088a-103a-40f6-a508-ec1da572041f"
      },
      "source": [
        "# We create a rank 1 ndarray that has sequential integers from 0 to 9\n",
        "x = np.arange(10)\n",
        "\n",
        "# We print the ndarray\n",
        "print()\n",
        "print('x = ', x)\n",
        "print()\n",
        "\n",
        "# We print information about the ndarray\n",
        "print('x has dimensions:', x.shape)\n",
        "print('x is an object of type:', type(x))\n",
        "print('The elements in x are of type:', x.dtype) "
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "x =  [0 1 2 3 4 5 6 7 8 9]\n",
            "\n",
            "x has dimensions: (10,)\n",
            "x is an object of type: <class 'numpy.ndarray'>\n",
            "The elements in x are of type: int64\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mYqdyfZTHxqP",
        "colab_type": "text"
      },
      "source": [
        "When used with two arguments, np.arange(start,stop) will create a rank 1 ndarray with evenly spaced values within the half-open interval [start, stop). This means the evenly spaced numbers will include start but exclude stop. Let's see an example"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UBcnbmquHrgl",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 137
        },
        "outputId": "3a181743-e07d-4347-ac5d-03a49d53302e"
      },
      "source": [
        "# We create a rank 1 ndarray that has sequential integers from 4 to 9. \n",
        "x = np.arange(4,10)\n",
        "\n",
        "# We print the ndarray\n",
        "print()\n",
        "print('x = ', x)\n",
        "print()\n",
        "\n",
        "# We print information about the ndarray\n",
        "print('x has dimensions:', x.shape)\n",
        "print('x is an object of type:', type(x))\n",
        "print('The elements in x are of type:', x.dtype) "
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "x =  [4 5 6 7 8 9]\n",
            "\n",
            "x has dimensions: (6,)\n",
            "x is an object of type: <class 'numpy.ndarray'>\n",
            "The elements in x are of type: int64\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-k99cyrkH7EE",
        "colab_type": "text"
      },
      "source": [
        "Finally, when used with three arguments, np.arange(start,stop,step) will create a rank 1 ndarray with evenly spaced values within the half-open interval [start, stop) with step being the distance between two adjacent values. Let's see an example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7AnrqDCQH34G",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f83bba5c-73cf-49ea-9666-dd1b9a5d1d60"
      },
      "source": [
        "# We create a rank 1 ndarray that has evenly spaced \n",
        "# integers from 1 to 13 in steps of 3.\n",
        "x = np.arange(1,14,3)\n",
        "\n",
        "# We print the ndarray\n",
        "print()\n",
        "print('x = ', x)\n",
        "print()\n",
        "\n",
        "# We print information about the ndarray\n",
        "print('x has dimensions:', x.shape)\n",
        "print('x is an object of type:', type(x))\n",
        "print('The elements in x are of type:', x.dtype) "
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "x =  [ 1  4  7 10 13]\n",
            "\n",
            "x has dimensions: (5,)\n",
            "x is an object of type: <class 'numpy.ndarray'>\n",
            "The elements in x are of type: int64\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8ViXZqneuL7i",
        "colab_type": "text"
      },
      "source": [
        "## **np.linspace():**\n",
        "\n",
        "Even though the np.arange() function allows for non-integer steps, such as 0.3, the output is usually inconsistent, due to the finite floating point precision. For this reason, in the cases where non-integer steps are required, it is usually better to use the function np.linspace(). The np.linspace(start, stop, N) function returns N evenly spaced numbers over the closed interval [start, stop]. This means that both the start and thestop values are included. We should also note the np.linspace() function needs to be called with at least two arguments in the form np.linspace(start,stop). In this case, the default number of elements in the specified interval will be N= 50. The reason np.linspace() works better than the np.arange() function, is that np.linspace() uses the number of elements we want in a particular interval, instead of the step between values. Let's see some examples:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rVOpuq8zIBhQ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 170
        },
        "outputId": "80ccf81a-0bf7-4619-f190-5acb958abf5e"
      },
      "source": [
        "# We create a rank 1 ndarray that has 10 integers evenly spaced between 0 and 25.\n",
        "x = np.linspace(0,25,10)\n",
        "\n",
        "# We print the ndarray\n",
        "print()\n",
        "print('x = \\n', x)\n",
        "print()\n",
        "\n",
        "# We print information about the ndarray\n",
        "print('x has dimensions:', x.shape)\n",
        "print('x is an object of type:', type(x))\n",
        "print('The elements in x are of type:', x.dtype)"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "x = \n",
            " [ 0.          2.77777778  5.55555556  8.33333333 11.11111111 13.88888889\n",
            " 16.66666667 19.44444444 22.22222222 25.        ]\n",
            "\n",
            "x has dimensions: (10,)\n",
            "x is an object of type: <class 'numpy.ndarray'>\n",
            "The elements in x are of type: float64\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DDgc6lKNv5m8",
        "colab_type": "text"
      },
      "source": [
        "As we can see from the above example, the function np.linspace(0,25,10) returns an ndarray with 10 evenly spaced numbers in the closed interval [0, 25]. We can also see that both the start and end points, 0 and 25 in this case, are included. However, you can let the endpoint of the interval be excluded (just like in the np.arange() function) by setting the keyword endpoint = False in the np.linspace() function. Let's create the same x ndarray we created above but now with the endpoint excluded:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cakMmQmdvy1t",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 137
        },
        "outputId": "eeda1f25-0941-451c-c3ba-b99c12b17355"
      },
      "source": [
        "# We create a rank 1 ndarray that has 10 integers evenly spaced between 0 and 25,\n",
        "# with 25 excluded.\n",
        "x = np.linspace(0,25,10, endpoint = False)\n",
        "\n",
        "# We print the ndarray\n",
        "print()\n",
        "print('x = ', x)\n",
        "print()\n",
        "\n",
        "# We print information about the ndarray\n",
        "print('x has dimensions:', x.shape)\n",
        "print('x is an object of type:', type(x))\n",
        "print('The elements in x are of type:', x.dtype)"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "x =  [ 0.   2.5  5.   7.5 10.  12.5 15.  17.5 20.  22.5]\n",
            "\n",
            "x has dimensions: (10,)\n",
            "x is an object of type: <class 'numpy.ndarray'>\n",
            "The elements in x are of type: float64\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xHA3hotizZoq",
        "colab_type": "text"
      },
      "source": [
        "## **np.reshape():**\n",
        "So far, we have only used the built-in functions np.arange() and np.linspace() to create rank 1 ndarrays. However, we can use these functions to create rank 2 ndarrays of any shape by combining them with the np.reshape() function. The np.reshape(ndarray, new_shape) function converts the given ndarray into the specified new_shape. It is important to note that the new_shape should be compatible with the number of elements in the given ndarray."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CBGX8P2Bzaf_",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 253
        },
        "outputId": "da911b43-4adb-40e9-bc4d-7ab97a5863ea"
      },
      "source": [
        "# We create a rank 1 ndarray with sequential integers from 0 to 19\n",
        "x = np.arange(20)\n",
        "\n",
        "# We print x\n",
        "print()\n",
        "print('Original x = ', x)\n",
        "print()\n",
        "\n",
        "# We reshape x into a 4 x 5 ndarray \n",
        "x = np.reshape(x, (4,5))\n",
        "\n",
        "# We print the reshaped x\n",
        "print()\n",
        "print('Reshaped x = \\n', x)\n",
        "print()\n",
        "\n",
        "# We print information about the reshaped x\n",
        "print('x has dimensions:', x.shape)\n",
        "print('x is an object of type:', type(x))\n",
        "print('The elements in x are of type:', x.dtype) "
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Original x =  [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]\n",
            "\n",
            "\n",
            "Reshaped x = \n",
            " [[ 0  1  2  3  4]\n",
            " [ 5  6  7  8  9]\n",
            " [10 11 12 13 14]\n",
            " [15 16 17 18 19]]\n",
            "\n",
            "x has dimensions: (4, 5)\n",
            "x is an object of type: <class 'numpy.ndarray'>\n",
            "The elements in x are of type: int64\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EZHoy2duz-v6",
        "colab_type": "text"
      },
      "source": [
        "One great feature about NumPy, is that some functions can also be applied as methods. This allows us to apply different functions in sequence in just one line of code. ndarray methods are similar to ndarray attributes in that they are both applied using dot notation (.). Let's see how we can accomplish the same result as in the above example, but in just one line of code:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vm5wTd5oze11",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 203
        },
        "outputId": "8f12e4a7-53e8-48bf-9e62-93b0487aba85"
      },
      "source": [
        "# We create a a rank 1 ndarray with sequential integers from 0 to 19 and\n",
        "# reshape it to a 4 x 5 array \n",
        "Y = np.arange(20).reshape(4, 5)\n",
        "\n",
        "# We print Y\n",
        "print()\n",
        "print('Y = \\n', Y)\n",
        "print()\n",
        "\n",
        "# We print information about Y\n",
        "print('Y has dimensions:', Y.shape)\n",
        "print('Y is an object of type:', type(Y))\n",
        "print('The elements in Y are of type:', Y.dtype)"
      ],
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Y = \n",
            " [[ 0  1  2  3  4]\n",
            " [ 5  6  7  8  9]\n",
            " [10 11 12 13 14]\n",
            " [15 16 17 18 19]]\n",
            "\n",
            "Y has dimensions: (4, 5)\n",
            "Y is an object of type: <class 'numpy.ndarray'>\n",
            "The elements in Y are of type: int64\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "T2vboYR30a__",
        "colab_type": "text"
      },
      "source": [
        "In the same manner, we can also combine reshape() with np.linspace() to create rank 2 arrays, as shown in the next example."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uZgWrDH10b6b",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 220
        },
        "outputId": "81263851-5635-42b7-84c6-15ed65de6ce4"
      },
      "source": [
        "# We create a rank 1 ndarray with 10 integers evenly spaced between 0 and 50,\n",
        "# with 50 excluded. We then reshape it to a 5 x 2 ndarray\n",
        "X = np.linspace(0,50,10, endpoint=False).reshape(5,2)\n",
        "\n",
        "# We print X\n",
        "print()\n",
        "print('X = \\n', X)\n",
        "print()\n",
        "\n",
        "# We print information about X\n",
        "print('X has dimensions:', X.shape)\n",
        "print('X is an object of type:', type(X))\n",
        "print('The elements in X are of type:', X.dtype)"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "X = \n",
            " [[ 0.  5.]\n",
            " [10. 15.]\n",
            " [20. 25.]\n",
            " [30. 35.]\n",
            " [40. 45.]]\n",
            "\n",
            "X has dimensions: (5, 2)\n",
            "X is an object of type: <class 'numpy.ndarray'>\n",
            "The elements in X are of type: float64\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "krYChE6J0vVv",
        "colab_type": "text"
      },
      "source": [
        "## **Random:**\n",
        "The last type of ndarrays we are going to create are random ndarrays. Random ndarrays are arrays that contain random numbers. Often in Machine Learning, you need to create random matrices, for example, when initializing the weights of a Neural Network. NumPy offers a variety of random functions to help us create random ndarrays of any shape."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ve4OSL3J0fFq",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 186
        },
        "outputId": "fdc37494-1104-4b50-dec4-233aacc89929"
      },
      "source": [
        "# We create a 3 x 3 ndarray with random floats in the half-open interval [0.0, 1.0).\n",
        "X = np.random.random((3,3))\n",
        "\n",
        "# We print X\n",
        "print()\n",
        "print('X = \\n', X)\n",
        "print()\n",
        "\n",
        "# We print information about X\n",
        "print('X has dimensions:', X.shape)\n",
        "print('X is an object of type:', type(X))\n",
        "print('The elements in x are of type:', X.dtype)"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "X = \n",
            " [[0.70511948 0.40550946 0.58073781]\n",
            " [0.67423937 0.03346497 0.12587685]\n",
            " [0.31964513 0.15787991 0.39406672]]\n",
            "\n",
            "X has dimensions: (3, 3)\n",
            "X is an object of type: <class 'numpy.ndarray'>\n",
            "The elements in x are of type: float64\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wOgmWsMW2lMA",
        "colab_type": "text"
      },
      "source": [
        "NumPy also allows us to create ndarrays with random integers within a particular interval. The function np.random.randint(start, stop, size = shape) creates an ndarray of the given shape with random integers in the half-open interval [start, stop). Let's see an example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8JluLn5s2huf",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 186
        },
        "outputId": "3ba3833a-2ac5-40ae-834d-995fb1e6217c"
      },
      "source": [
        "# We create a 3 x 2 ndarray with random integers in the half-open interval [4, 15).\n",
        "X = np.random.randint(4,15,size=(3,2))\n",
        "\n",
        "# We print X\n",
        "print()\n",
        "print('X = \\n', X)\n",
        "print()\n",
        "\n",
        "# We print information about X\n",
        "print('X has dimensions:', X.shape)\n",
        "print('X is an object of type:', type(X))\n",
        "print('The elements in X are of type:', X.dtype)"
      ],
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "X = \n",
            " [[ 8  5]\n",
            " [ 4 12]\n",
            " [ 7  8]]\n",
            "\n",
            "X has dimensions: (3, 2)\n",
            "X is an object of type: <class 'numpy.ndarray'>\n",
            "The elements in X are of type: int64\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Kh37ENWG5NG2",
        "colab_type": "text"
      },
      "source": [
        "In some cases, you may need to create ndarrays with random numbers that satisfy certain statistical properties. For example, you may want the random numbers in the ndarray to have an average of 0. NumPy allows you create random ndarrays with numbers drawn from various probability distributions. The function np.random.normal(mean, standard deviation, size=shape), for example, creates an ndarray with the given shape that contains random numbers picked from a normal (Gaussian) distribution with the given mean and standard deviation."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XyqTesTi2pIf",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 434
        },
        "outputId": "d1b19885-6ae1-4f58-828d-e51a7d65f321"
      },
      "source": [
        "# We create a 1000 x 1000 ndarray of random floats drawn from normal (Gaussian) distribution\n",
        "# with a mean of zero and a standard deviation of 0.1.\n",
        "X = np.random.normal(0, 0.1, size=(1000,1000))\n",
        "\n",
        "# We print X\n",
        "print()\n",
        "print('X = \\n', X)\n",
        "print()\n",
        "\n",
        "# We print information about X\n",
        "print('X has dimensions:', X.shape)\n",
        "print('X is an object of type:', type(X))\n",
        "print('The elements in X are of type:', X.dtype)\n",
        "print('The elements in X have a mean of:', X.mean())\n",
        "print('The maximum value in X is:', X.max())\n",
        "print('The minimum value in X is:', X.min())\n",
        "print('X has', (X < 0).sum(), 'negative numbers')\n",
        "print('X has', (X > 0).sum(), 'positive numbers')"
      ],
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "X = \n",
            " [[ 0.06038575  0.07058648  0.00651944 ... -0.11510515  0.03274108\n",
            "  -0.04948388]\n",
            " [-0.0427396   0.01963788 -0.08193541 ...  0.22104453  0.00997958\n",
            "  -0.17775136]\n",
            " [ 0.08125654  0.01597223 -0.00085445 ... -0.1888355  -0.0522047\n",
            "  -0.03611404]\n",
            " ...\n",
            " [-0.05934912 -0.0268068   0.13427054 ... -0.0735276  -0.04742756\n",
            "  -0.07159635]\n",
            " [ 0.1307405  -0.07065583 -0.17023093 ...  0.03329357 -0.06680952\n",
            "  -0.06895992]\n",
            " [ 0.04490569  0.1388507   0.06680477 ... -0.0169742  -0.04751616\n",
            "   0.142401  ]]\n",
            "\n",
            "X has dimensions: (1000, 1000)\n",
            "X is an object of type: <class 'numpy.ndarray'>\n",
            "The elements in X are of type: float64\n",
            "The elements in X have a mean of: 0.00010345992650649735\n",
            "The maximum value in X is: 0.49171050961052176\n",
            "The minimum value in X is: -0.4572065155534312\n",
            "X has 499752 negative numbers\n",
            "X has 500248 positive numbers\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OGKlN5Ui5ZC0",
        "colab_type": "text"
      },
      "source": [
        "## **Question:**\n",
        "Using the Built-in functions you learned about in the\n",
        "previous lesson, create a 4 x 4 ndarray that only\n",
        "contains consecutive even numbers from 2 to 32 (inclusive)\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fFpdoCad5S37",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import numpy as np\n",
        "\n",
        "X = "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "B2q9JDTa5kuw",
        "colab_type": "text"
      },
      "source": [
        "## **Question:**\n",
        "Try creating the same array using the np.linspace() function."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "U9LPnzMm5qJL",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import numpy as np\n",
        "\n",
        "X = "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wIbAPL5A7V1N",
        "colab_type": "text"
      },
      "source": [
        "## **Accessing Elements in ndarays:**\n",
        "Elements can be accessed using indices inside square brackets, [ ]. NumPy allows you to use both positive and negative indices to access elements in the ndarray. Positive indices are used to access elements from the beginning of the array, while negative indices are used to access elements from the end of the array. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZfjHHvWs7vYO",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# We create a rank 1 ndarray that contains integers from 1 to 5\n",
        "x = np.array([1, 2, 3, 4, 5])\n",
        "\n",
        "# We print x\n",
        "print()\n",
        "print('x = ', x)\n",
        "print()\n",
        "\n",
        "# Let's access some elements with positive indices\n",
        "print('This is First Element in x:', x[0]) \n",
        "print('This is Second Element in x:', x[1])\n",
        "print('This is Fifth (Last) Element in x:', x[4])\n",
        "print()\n",
        "\n",
        "# Let's access the same elements with negative indices\n",
        "print('This is First Element in x:', x[-5])\n",
        "print('This is Second Element in x:', x[-4])\n",
        "print('This is Fifth (Last) Element in x:', x[-1])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bbYr59qc8arb",
        "colab_type": "text"
      },
      "source": [
        "## Modifying ndarrays:\n",
        "Now let's see how we can change the elements in rank 1 ndarrays. We do this by accessing the element we want to change and then using the = sign to assign the new value:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yQwCZwSD85Q5",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 137
        },
        "outputId": "c7855e58-b67e-46cc-b966-f39ca0180d0a"
      },
      "source": [
        "# We create a rank 1 ndarray that contains integers from 1 to 5\n",
        "x = np.array([1, 2, 3, 4, 5])\n",
        "\n",
        "# We print the original x\n",
        "print()\n",
        "print('Original:\\n x = ', x)\n",
        "print()\n",
        "\n",
        "# We change the fourth element in x from 4 to 20\n",
        "x[3] = 20\n",
        "\n",
        "# We print x after it was modified \n",
        "print('Modified:\\n x = ', x)\n"
      ],
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Original:\n",
            " x =  [1 2 3 4 5]\n",
            "\n",
            "Modified:\n",
            " x =  [ 1  2  3 20  5]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W-G-2CNy8-Kn",
        "colab_type": "text"
      },
      "source": [
        "Similarly, we can also access and modify specific elements of rank 2 ndarrays. To access elements in rank 2 ndarrays we need to provide 2 indices in the form [row, column]. Let's see some examples"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fHV8Q1Ik863v",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 186
        },
        "outputId": "e580a229-0b25-40ff-f7a8-20749eb84ea3"
      },
      "source": [
        "# We create a 3 x 3 rank 2 ndarray that contains integers from 1 to 9\n",
        "X = np.array([[1,2,3],[4,5,6],[7,8,9]])\n",
        "\n",
        "# We print X\n",
        "print()\n",
        "print('X = \\n', X)\n",
        "print()\n",
        "\n",
        "# Let's access some elements in X\n",
        "print('This is (0,0) Element in X:', X[0,0])\n",
        "print('This is (0,1) Element in X:', X[0,1])\n",
        "print('This is (2,2) Element in X:', X[2,2])"
      ],
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "X = \n",
            " [[1 2 3]\n",
            " [4 5 6]\n",
            " [7 8 9]]\n",
            "\n",
            "This is (0,0) Element in X: 1\n",
            "This is (0,1) Element in X: 2\n",
            "This is (2,2) Element in X: 9\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kgQ4DUxZ9FPK",
        "colab_type": "text"
      },
      "source": [
        "Elements in rank 2 ndarrays can be modified in the same way as with rank 1 ndarrays. Let's see an example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uMP5cJ-P9A1P",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 236
        },
        "outputId": "b0faf293-8a41-49b6-fe30-6f498201538e"
      },
      "source": [
        "# We create a 3 x 3 rank 2 ndarray that contains integers from 1 to 9\n",
        "X = np.array([[1,2,3],[4,5,6],[7,8,9]])\n",
        "\n",
        "# We print the original x\n",
        "print()\n",
        "print('Original:\\n X = \\n', X)\n",
        "print()\n",
        "\n",
        "# We change the (0,0) element in X from 1 to 20\n",
        "X[0,0] = 20\n",
        "\n",
        "# We print X after it was modified \n",
        "print('Modified:\\n X = \\n', X)\n"
      ],
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Original:\n",
            " X = \n",
            " [[1 2 3]\n",
            " [4 5 6]\n",
            " [7 8 9]]\n",
            "\n",
            "Modified:\n",
            " X = \n",
            " [[20  2  3]\n",
            " [ 4  5  6]\n",
            " [ 7  8  9]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZWSEPc159LEG",
        "colab_type": "text"
      },
      "source": [
        "## **Adding and Deleting elements:**\n",
        "Now, let's take a look at how we can add and delete elements from ndarrays. We can delete elements using the np.delete(ndarray, elements, axis) function. This function deletes the given list of elements from the given ndarray along the specified axis. For rank 1 ndarrays the axis keyword is not required. For rank 2 ndarrays, axis = 0 is used to select rows, and axis = 1 is used to select columns. Let's see some examples:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DRB_V6dd9HlM",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 335
        },
        "outputId": "b266340c-159d-42ee-d627-a109d0ccb75b"
      },
      "source": [
        "# We create a rank 1 ndarray \n",
        "x = np.array([1, 2, 3, 4, 5])\n",
        "\n",
        "# We create a rank 2 ndarray\n",
        "Y = np.array([[1,2,3],[4,5,6],[7,8,9]])\n",
        "\n",
        "# We print x\n",
        "print()\n",
        "print('Original x = ', x)\n",
        "\n",
        "# We delete the first and last element of x\n",
        "x = np.delete(x, [0,4])\n",
        "\n",
        "# We print x with the first and last element deleted\n",
        "print()\n",
        "print('Modified x = ', x)\n",
        "\n",
        "# We print Y\n",
        "print()\n",
        "print('Original Y = \\n', Y)\n",
        "\n",
        "# We delete the first row of y\n",
        "w = np.delete(Y, 0, axis=0)\n",
        "\n",
        "# We delete the first and last column of y\n",
        "v = np.delete(Y, [0,2], axis=1)\n",
        "\n",
        "# We print w\n",
        "print()\n",
        "print('w = \\n', w)\n",
        "\n",
        "# We print v\n",
        "print()\n",
        "print('v = \\n', v)"
      ],
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Original x =  [1 2 3 4 5]\n",
            "\n",
            "Modified x =  [2 3 4]\n",
            "\n",
            "Original Y = \n",
            " [[1 2 3]\n",
            " [4 5 6]\n",
            " [7 8 9]]\n",
            "\n",
            "w = \n",
            " [[4 5 6]\n",
            " [7 8 9]]\n",
            "\n",
            "v = \n",
            " [[2]\n",
            " [5]\n",
            " [8]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Nqqwxir99XFI",
        "colab_type": "text"
      },
      "source": [
        "We can append values to ndarrays using the np.append(ndarray, elements, axis) function. This function appends the given list of elements to ndarray along the specified axis. Let's see some examples:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Jv73CPgz9UYw",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 352
        },
        "outputId": "06adb68e-fe58-42eb-ee4e-56c8b2958ca8"
      },
      "source": [
        "# We create a rank 1 ndarray \n",
        "x = np.array([1, 2, 3, 4, 5])\n",
        "\n",
        "# We create a rank 2 ndarray \n",
        "Y = np.array([[1,2,3],[4,5,6]])\n",
        "\n",
        "# We print x\n",
        "print()\n",
        "print('Original x = ', x)\n",
        "\n",
        "# We append the integer 6 to x\n",
        "x = np.append(x, 6)\n",
        "\n",
        "# We print x\n",
        "print()\n",
        "print('x = ', x)\n",
        "\n",
        "# We append the integer 7 and 8 to x\n",
        "x = np.append(x, [7,8])\n",
        "\n",
        "# We print x\n",
        "print()\n",
        "print('x = ', x)\n",
        "\n",
        "# We print Y\n",
        "print()\n",
        "print('Original Y = \\n', Y)\n",
        "\n",
        "# We append a new row containing 7,8,9 to y\n",
        "v = np.append(Y, [[7,8,9]], axis=0)\n",
        "\n",
        "# We append a new column containing 9 and 10 to y\n",
        "q = np.append(Y,[[9],[10]], axis=1)\n",
        "\n",
        "# We print v\n",
        "print()\n",
        "print('v = \\n', v)\n",
        "\n",
        "# We print q\n",
        "print()\n",
        "print('q = \\n', q)"
      ],
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Original x =  [1 2 3 4 5]\n",
            "\n",
            "x =  [1 2 3 4 5 6]\n",
            "\n",
            "x =  [1 2 3 4 5 6 7 8]\n",
            "\n",
            "Original Y = \n",
            " [[1 2 3]\n",
            " [4 5 6]]\n",
            "\n",
            "v = \n",
            " [[1 2 3]\n",
            " [4 5 6]\n",
            " [7 8 9]]\n",
            "\n",
            "q = \n",
            " [[ 1  2  3  9]\n",
            " [ 4  5  6 10]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WsIxKWUN9gRr",
        "colab_type": "text"
      },
      "source": [
        "Now let's see now how we can insert values to ndarrays. We can insert values to ndarrays using the np.insert(ndarray, index, elements, axis) function. This function inserts the given list of elements to ndarray right before the given index along the specified axis. Let's see some examples:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7oFcymIm9bTR",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# We create a rank 1 ndarray \n",
        "x = np.array([1, 2, 5, 6, 7])\n",
        "\n",
        "# We create a rank 2 ndarray \n",
        "Y = np.array([[1,2,3],[7,8,9]])\n",
        "\n",
        "# We print x\n",
        "print()\n",
        "print('Original x = ', x)\n",
        "\n",
        "# We insert the integer 3 and 4 between 2 and 5 in x. \n",
        "x = np.insert(x,2,[3,4])\n",
        "\n",
        "# We print x with the inserted elements\n",
        "print()\n",
        "print('x = ', x)\n",
        "\n",
        "# We print Y\n",
        "print()\n",
        "print('Original Y = \\n', Y)\n",
        "\n",
        "# We insert a row between the first and last row of y\n",
        "w = np.insert(Y,1,[4,5,6],axis=0)\n",
        "\n",
        "# We insert a column full of 5s between the first and second column of y\n",
        "v = np.insert(Y,1,5, axis=1)\n",
        "\n",
        "# We print w\n",
        "print()\n",
        "print('w = \\n', w)\n",
        "\n",
        "# We print v\n",
        "print()\n",
        "print('v = \\n', v)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S0z5oy379mKd",
        "colab_type": "text"
      },
      "source": [
        "NumPy also allows us to stack ndarrays on top of each other, or to stack them side by side. The stacking is done using either the np.vstack() function for vertical stacking, or the np.hstack() function for horizontal stacking. It is important to note that in order to stack ndarrays, the shape of the ndarrays must match. Let's see some examples:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J4iQxGR_9n9A",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 286
        },
        "outputId": "ae6d63e0-d787-4128-b42d-850bb8cfe617"
      },
      "source": [
        "# We create a rank 1 ndarray \n",
        "x = np.array([1,2])\n",
        "\n",
        "# We create a rank 2 ndarray \n",
        "Y = np.array([[3,4],[5,6]])\n",
        "\n",
        "# We print x\n",
        "print()\n",
        "print('x = ', x)\n",
        "\n",
        "# We print Y\n",
        "print()\n",
        "print('Y = \\n', Y)\n",
        "\n",
        "# We stack x on top of Y\n",
        "z = np.vstack((x,Y))\n",
        "\n",
        "# We stack x on the right of Y. We need to reshape x in order to stack it on the right of Y. \n",
        "w = np.hstack((Y,x.reshape(2,1)))\n",
        "\n",
        "# We print z\n",
        "print()\n",
        "print('z = \\n', z)\n",
        "\n",
        "# We print w\n",
        "print()\n",
        "print('w = \\n', w)"
      ],
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "x =  [1 2]\n",
            "\n",
            "Y = \n",
            " [[3 4]\n",
            " [5 6]]\n",
            "\n",
            "z = \n",
            " [[1 2]\n",
            " [3 4]\n",
            " [5 6]]\n",
            "\n",
            "w = \n",
            " [[3 4 1]\n",
            " [5 6 2]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NoFIMQQu9ptw",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}