Day_5_Numpy_Part_1 (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"
      },
      "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"
      },
      "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"
      },
      "source": [
        "import time\n",
        "import numpy as np"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cx33B30cYJzv"
      },
      "source": [
        "x = np.random.rand(1000000000)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xXpuBxHLYOWg",
        "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": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "164.07553839683533\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zwi39jQRYkye",
        "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": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0.6675674915313721\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Dibh7I4LcMdb"
      },
      "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"
      },
      "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"
      },
      "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": {
          "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": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "x =  [1 2 3 4 5]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Oi4x0r2fvwSd"
      },
      "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": {
          "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": null,
      "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"
      },
      "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"
      },
      "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": {
          "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": null,
      "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"
      },
      "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": {
          "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": null,
      "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"
      },
      "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": {
          "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": null,
      "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"
      },
      "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": {
          "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": null,
      "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"
      },
      "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"
      },
      "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": {
          "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": null,
      "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"
      },
      "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"
      },
      "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": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2zclAmaE28Ki"
      },
      "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"
      },
      "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": {
          "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": null,
      "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": "xHA3hotizZoq"
      },
      "source": [
        "## **np.reshape():**\n",
        "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": {
          "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": null,
      "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"
      },
      "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": {
          "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": null,
      "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": "wIbAPL5A7V1N"
      },
      "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"
      },
      "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"
      },
      "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": {
          "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": null,
      "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"
      },
      "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": {
          "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": null,
      "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"
      },
      "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": {
          "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": null,
      "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"
      },
      "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": {
          "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": null,
      "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"
      },
      "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": {
          "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": null,
      "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"
      },
      "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"
      },
      "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": "code",
      "metadata": {
        "id": "NoFIMQQu9ptw"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}