Day_6_Numpy_Part_2.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Day_6_Numpy_Part_2.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KhRg_FoegBcB",
        "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": "lc4fxGwif5cA",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 203
        },
        "outputId": "d9d39440-2958-4728-d4e7-0602af77e232"
      },
      "source": [
        "import numpy as np\n",
        "\n",
        "# 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": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "x =  [1 2 3 4 5]\n",
            "\n",
            "This is First Element in x: 1\n",
            "This is Second Element in x: 2\n",
            "This is Fifth (Last) Element in x: 5\n",
            "\n",
            "This is First Element in x: 1\n",
            "This is Second Element in x: 2\n",
            "This is Fifth (Last) Element in x: 5\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J63vXlFvgFj3",
        "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": "ymAvKfjYgIPx",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e1151b9b-ddeb-4a1f-de17-01404e54c134"
      },
      "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": "Ls3Hb7yYgWXC",
        "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": "g4i2Y5hMgKuh",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 186
        },
        "outputId": "1673c165-a109-49f3-b63e-81fed6b04d74"
      },
      "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": "TN6nKaJFgbyq",
        "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": "0MDXllAHgZLR",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 236
        },
        "outputId": "4b8a724a-6b76-4f48-92b5-5931ad25928a"
      },
      "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": "_bMnSvxFggxp",
        "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": "_SYPaPx0geSl",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 335
        },
        "outputId": "a0c70b67-45c8-48b1-baf7-6b36730549a8"
      },
      "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": "cO9iDGKXgm62",
        "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": "nvvBHVntgkDg",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 352
        },
        "outputId": "b3608a27-c248-4d0f-99eb-2d53608f27db"
      },
      "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": "WkxJUwqpgr99",
        "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": "bRSlXaH-gpZu",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 319
        },
        "outputId": "2489f6e0-398c-42d7-9c16-7f04904da4b9"
      },
      "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": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Original x =  [1 2 5 6 7]\n",
            "\n",
            "x =  [1 2 3 4 5 6 7]\n",
            "\n",
            "Original Y = \n",
            " [[1 2 3]\n",
            " [7 8 9]]\n",
            "\n",
            "w = \n",
            " [[1 2 3]\n",
            " [4 5 6]\n",
            " [7 8 9]]\n",
            "\n",
            "v = \n",
            " [[1 5 2 3]\n",
            " [7 5 8 9]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-R27FObOgx6r",
        "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": "Ws9LlpROguyX",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 286
        },
        "outputId": "20d645ba-b751-4b4f-aece-1dad9f10153a"
      },
      "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": null,
      "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": "markdown",
      "metadata": {
        "id": "guOiIr6vuJVV",
        "colab_type": "text"
      },
      "source": [
        "## **Slicing ndarrays:**\n",
        "As we mentioned earlier, in addition to being able to access individual elements one at a time, NumPy provides a way to access subsets of ndarrays. This is known as slicing. Slicing is performed by combining indices with the colon : symbol inside the square brackets. In general you will come across three types of slicing:\n",
        "\n",
        "```\n",
        "1. ndarray[start:end]\n",
        "2. ndarray[start:]\n",
        "3. ndarray[:end]\n",
        "```\n",
        "The first method is used to select elements between the start and end indices. The second method is used to select all elements from the start index till the last index. The third method is used to select all elements from the first index till the end index. We should note that in methods one and three, the end index is excluded. We should also note that since ndarrays can be multidimensional, when doing slicing you usually have to specify a slice for each dimension of the array.\n",
        "\n",
        "We will now see some examples of how to use the above methods to select different subsets of a rank 2 ndarray.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HP1atdZBg0Tg",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "96beec84-9af1-40ba-9f06-bd04c4e12e16"
      },
      "source": [
        "# We create a 4 x 5 ndarray that contains integers from 0 to 19\n",
        "X = np.arange(20).reshape(4, 5)\n",
        "\n",
        "# We print X\n",
        "print()\n",
        "print('X = \\n', X)\n",
        "print()\n",
        "\n",
        "# We select all the elements that are in the 2nd through 4th rows and in the 3rd to 5th columns\n",
        "Z = X[1:4,2:5]\n",
        "\n",
        "# We print Z\n",
        "print('Z = \\n', Z)\n",
        "\n",
        "# We can select the same elements as above using method 2\n",
        "W = X[1:,2:5]\n",
        "\n",
        "# We print W\n",
        "print()\n",
        "print('W = \\n', W)\n",
        "\n",
        "# We select all the elements that are in the 1st through 3rd rows and in the 3rd to 4th columns\n",
        "Y = X[:3,2:5]\n",
        "\n",
        "# We print Y\n",
        "print()\n",
        "print('Y = \\n', Y)\n",
        "\n",
        "# We select all the elements in the 3rd row\n",
        "v = X[2,:]\n",
        "\n",
        "# We print v\n",
        "print()\n",
        "print('v = ', v)\n",
        "\n",
        "# We select all the elements in the 3rd column\n",
        "q = X[:,2]\n",
        "\n",
        "# We print q\n",
        "print()\n",
        "print('q = ', q)\n",
        "\n",
        "# We select all the elements in the 3rd column but return a rank 2 ndarray\n",
        "R = X[:,2:3]\n",
        "\n",
        "# We print R\n",
        "print()\n",
        "print('R = \\n', R)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "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",
            "Z = \n",
            " [[ 7  8  9]\n",
            " [12 13 14]\n",
            " [17 18 19]]\n",
            "\n",
            "W = \n",
            " [[ 7  8  9]\n",
            " [12 13 14]\n",
            " [17 18 19]]\n",
            "\n",
            "Y = \n",
            " [[ 2  3  4]\n",
            " [ 7  8  9]\n",
            " [12 13 14]]\n",
            "\n",
            "v =  [10 11 12 13 14]\n",
            "\n",
            "q =  [ 2  7 12 17]\n",
            "\n",
            "R = \n",
            " [[ 2]\n",
            " [ 7]\n",
            " [12]\n",
            " [17]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CVF0BaLRy-9h",
        "colab_type": "text"
      },
      "source": [
        "Notice that when we selected all the elements in the 3rd column, variable q above, the slice returned a rank 1 ndarray instead of a rank 2 ndarray. However, slicing X in a slightly different way, variable R above, we can actually get a rank 2 ndarray instead.\n",
        "\n",
        "It is important to note that when we perform slices on ndarrays and save them into new variables, as we did above, the data is not copied into the new variable. This is one feature that often causes confusion for beginners. Therefore, we will look at this in a bit more detail.\n",
        "\n",
        "In the above examples, when we make assignments, such as:\n",
        "```\n",
        "Z = X[1:4,2:5]\n",
        "```\n",
        "the slice of the original array X is not copied in the variable Z. Rather, X and Z are now just two different names for the same ndarray. We say that slicing only creates a view of the original array. This means that if you make changes in Z you will be in effect changing the elements in X as well. Let's see this with an example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Qw29pEh6ylQg",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 368
        },
        "outputId": "420a0a64-f8b3-4fd7-bea8-8b1ca87d2b53"
      },
      "source": [
        "# We create a 4 x 5 ndarray that contains integers from 0 to 19\n",
        "X = np.arange(20).reshape(4, 5)\n",
        "\n",
        "# We print X\n",
        "print()\n",
        "print('X = \\n', X)\n",
        "print()\n",
        "\n",
        "# We select all the elements that are in the 2nd through 4th rows and in the 3rd to 4th columns\n",
        "Z = X[1:4,2:5]\n",
        "\n",
        "# We print Z\n",
        "print()\n",
        "print('Z = \\n', Z)\n",
        "print()\n",
        "\n",
        "# We change the last element in Z to 555\n",
        "Z[2,2] = 555\n",
        "\n",
        "# We print X\n",
        "print()\n",
        "print('X = \\n', X)\n",
        "print()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "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",
            "\n",
            "Z = \n",
            " [[ 7  8  9]\n",
            " [12 13 14]\n",
            " [17 18 19]]\n",
            "\n",
            "\n",
            "X = \n",
            " [[  0   1   2   3   4]\n",
            " [  5   6   7   8   9]\n",
            " [ 10  11  12  13  14]\n",
            " [ 15  16  17  18 555]]\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "C0kEw4Fx0B-g",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}