Day_7_Numpy_Part_3.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Day_7_Numpy_Part_3.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Tjukq5BlGUNj",
        "colab_type": "text"
      },
      "source": [
        "## **Boolean Indexing:**\n",
        "There are many situations in which we don't know the indices of the elements we want to select. For example, suppose we have a 10,000 x 10,000 ndarray of random integers ranging from 1 to 15,000 and we only want to select those integers that are less than 20. Boolean indexing can help us in these cases, by allowing us select elements using logical arguments instead of explicit indices. Let's see some examples:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YzTXz6bzF06E",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 352
        },
        "outputId": "eaa87520-4f12-467a-f56d-cee00dd5000f"
      },
      "source": [
        "import numpy as np\n",
        "\n",
        "# We create a 5 x 5 ndarray that contains integers from 0 to 24\n",
        "X = np.arange(25).reshape(5, 5)\n",
        "\n",
        "# We print X\n",
        "print()\n",
        "print('Original X = \\n', X)\n",
        "print()\n",
        "\n",
        "# We use Boolean indexing to select elements in X:\n",
        "print('The elements in X that are greater than 10:', X[X > 10])\n",
        "print('The elements in X that less than or equal to 7:', X[X <= 7])\n",
        "print('The elements in X that are between 10 and 17:', X[(X > 10) & (X < 17)])\n",
        "\n",
        "# We use Boolean indexing to assign the elements that are between 10 and 17 the value of -1\n",
        "X[(X > 10) & (X < 17)] = -1\n",
        "\n",
        "# We print X\n",
        "print()\n",
        "print('X = \\n', X)\n",
        "print()"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Original 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",
            " [20 21 22 23 24]]\n",
            "\n",
            "The elements in X that are greater than 10: [11 12 13 14 15 16 17 18 19 20 21 22 23 24]\n",
            "The elements in X that less than or equal to 7: [0 1 2 3 4 5 6 7]\n",
            "The elements in X that are between 10 and 17: [11 12 13 14 15 16]\n",
            "\n",
            "X = \n",
            " [[ 0  1  2  3  4]\n",
            " [ 5  6  7  8  9]\n",
            " [10 -1 -1 -1 -1]\n",
            " [-1 -1 17 18 19]\n",
            " [20 21 22 23 24]]\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m8AEouL3G-s5",
        "colab_type": "text"
      },
      "source": [
        "## **Set Operations:**\n",
        "\n",
        "In addition to Boolean Indexing NumPy also allows for set operations. This useful when comparing ndarrays, for example, to find common elements between two ndarrays. Let's see some examples:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KZBTpYh9GjU0",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 170
        },
        "outputId": "f053f3cc-e5fe-4090-ba2e-2ccb3a02c91f"
      },
      "source": [
        "# We create a rank 1 ndarray\n",
        "x = np.array([1,2,3,4,5])\n",
        "\n",
        "# We create a rank 1 ndarray\n",
        "y = np.array([6,7,2,8,4])\n",
        "\n",
        "# We print x\n",
        "print()\n",
        "print('x = ', x)\n",
        "\n",
        "# We print y\n",
        "print()\n",
        "print('y = ', y)\n",
        "\n",
        "# We use set operations to compare x and y:\n",
        "print()\n",
        "print('The elements that are both in x and y:', np.intersect1d(x,y))\n",
        "print('The elements that are in x that are not in y:', np.setdiff1d(x,y))\n",
        "print('All the elements of x and y:',np.union1d(x,y))"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "x =  [1 2 3 4 5]\n",
            "\n",
            "y =  [6 7 2 8 4]\n",
            "\n",
            "The elements that are both in x and y: [2 4]\n",
            "The elements that are in x that are not in y: [1 3 5]\n",
            "All the elements of x and y: [1 2 3 4 5 6 7 8]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r39N_VAmHYnN",
        "colab_type": "text"
      },
      "source": [
        "## **Sort():**\n",
        "\n",
        "We can also sort ndarrays in NumPy. We will learn how to use the np.sort() function to sort rank 1 and rank 2 ndarrays in different ways. Like with other functions we saw before, the sort function can also be used as a method. However, there is a big difference on how the data is stored in memory in this case. \n",
        "- When np.sort() is used as a function, it sorts the ndrrays out of place, meaning, that it doesn't change the original ndarray being sorted. \n",
        "- However, when you use sort as a method, ndarray.sort() sorts the ndarray in place, meaning, that the original array will be changed to the sorted one. \n",
        "\n",
        "Let's see some examples:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XOSbzTsSHK7U",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 137
        },
        "outputId": "40e08849-c383-4111-d028-9df536f3f2a1"
      },
      "source": [
        "# We create an unsorted rank 1 ndarray\n",
        "x = np.random.randint(1,11,size=(10,))\n",
        "\n",
        "# We print x\n",
        "print()\n",
        "print('Original x = ', x)\n",
        "\n",
        "# We sort x and print the sorted array using sort as a function.\n",
        "print()\n",
        "print('Sorted x (out of place):', np.sort(x))\n",
        "\n",
        "# When we sort out of place the original array remains intact. To see this we print x again\n",
        "print()\n",
        "print('x after sorting:', x)"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Original x =  [ 2  2  7  9  8  4  2 10  5  7]\n",
            "\n",
            "Sorted x (out of place): [ 2  2  2  4  5  7  7  8  9 10]\n",
            "\n",
            "x after sorting: [ 2  2  7  9  8  4  2 10  5  7]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QbBU9jOtH7pq",
        "colab_type": "text"
      },
      "source": [
        "let's see how we can sort ndarrays in place, by using sort as a method:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1Mbvj8oWHwEt",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 104
        },
        "outputId": "8fa1372b-1832-4f78-b02f-221aa47ab809"
      },
      "source": [
        "# We create an unsorted rank 1 ndarray\n",
        "x = np.random.randint(1,11,size=(10,))\n",
        "\n",
        "# We print x\n",
        "print()\n",
        "print('Original x = ', x)\n",
        "\n",
        "# We sort x and print the sorted array using sort as a method.\n",
        "x.sort()\n",
        "\n",
        "# When we sort in place the original array is changed to the sorted array. To see this we print x again\n",
        "print()\n",
        "print('x after sorting:', x)"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Original x =  [ 6 10  8 10  2  9  1  6  6  2]\n",
            "\n",
            "x after sorting: [ 1  2  2  6  6  6  8  9 10 10]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dELVwDysIAhs",
        "colab_type": "text"
      },
      "source": [
        "Notice that np.sort() sorts the array but, if the ndarray being sorted has repeated values, np.sort() leaves those values in the sorted array. However, if desired, we can sort only the unique elements in x by combining the sort function with the unique function. Let's see how we can sort the unique elements of x above:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Wny5spAFH-lL",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 87
        },
        "outputId": "2147cde2-1890-4cd4-deb2-d791996e1cf0"
      },
      "source": [
        "# We create an unsorted rank 1 ndarray\n",
        "x = np.random.randint(1,11,size=(10,))\n",
        "\n",
        "# We print x\n",
        "print()\n",
        "print('Original x = ', x)\n",
        "\n",
        "# We sort x but only keep the unique elements in x\n",
        "print(np.sort(np.unique(x)))"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Original x =  [8 6 2 8 1 6 2 1 8 6]\n",
            "[1 2 6 8]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3SSiV4EoKRWZ",
        "colab_type": "text"
      },
      "source": [
        "When sorting rank 2 ndarrays, we need to specify to the np.sort() function whether we are sorting by rows or columns. This is done by using the axis keyword. Let's see some examples:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XdZi81Q4IFv7",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a4201ae6-6e75-4632-9e4c-86476dcc73f9"
      },
      "source": [
        "# We create an unsorted rank 2 ndarray\n",
        "X = np.random.randint(1,11,size=(5,5))\n",
        "\n",
        "# We print X\n",
        "print()\n",
        "print('Original X = \\n', X)\n",
        "print()\n",
        "\n",
        "# We sort the columns of X and print the sorted array\n",
        "print()\n",
        "print('X with sorted columns :\\n', np.sort(X, axis = 0))\n",
        "\n",
        "# We sort the rows of X and print the sorted array\n",
        "print()\n",
        "print('X with sorted rows :\\n', np.sort(X, axis = 1))"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Original X = \n",
            " [[ 2  5  9  1  7]\n",
            " [10  7  6  9  6]\n",
            " [ 4  8  3  8  2]\n",
            " [ 9  1  5  6 10]\n",
            " [ 5  5 10  6  9]]\n",
            "\n",
            "\n",
            "X with sorted columns :\n",
            " [[ 2  1  3  1  2]\n",
            " [ 4  5  5  6  6]\n",
            " [ 5  5  6  6  7]\n",
            " [ 9  7  9  8  9]\n",
            " [10  8 10  9 10]]\n",
            "\n",
            "X with sorted rows :\n",
            " [[ 1  2  5  7  9]\n",
            " [ 6  6  7  9 10]\n",
            " [ 2  3  4  8  8]\n",
            " [ 1  5  6  9 10]\n",
            " [ 5  5  6  9 10]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8B06V3sgKeSG",
        "colab_type": "text"
      },
      "source": [
        "## **Question:**\n",
        "Create a 5 x 5 ndarray with consecutive integers from 1 to 25 (inclusive). Afterwards use Boolean indexing to pick out only the odd numbers in the array"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9KW7DdSEKUqW",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import numpy as np\n",
        "\n",
        "# Create a 5 x 5 ndarray with consecutive integers from 1 to 25 (inclusive).\n",
        "X = \n",
        "\n",
        "# Use Boolean indexing to pick out only the odd numbers in the array\n",
        "Y = "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l2f8f9ZUKwKH",
        "colab_type": "text"
      },
      "source": [
        "## **Arithmtic Operations:**\n",
        "Let's start by doing element-wise addition, subtraction, multiplication, and division, between ndarrays. To do this, NumPy provides a functional approach, where we use functions such as np.add(), or by using arithmetic symbols, such as +, that resembles more how we write mathematical equations. Both forms will do the same operation, the only difference is that if you use the function approach, the functions usually have options that you can tweak using keywords. It is important to note that when performing element-wise operations, the shapes of the ndarrays being operated on, must have the same shape or be broadcastable. We'll explain more about this later in this lesson. Let's start by performing element-wise arithmetic operations on rank 1 ndarrays:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0Uk3Dg4qNcYK",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 302
        },
        "outputId": "53e7a86b-6ef4-41c7-929e-cab4602253d4"
      },
      "source": [
        "# We create two rank 1 ndarrays\n",
        "x = np.array([1,2,3,4])\n",
        "y = np.array([5.5,6.5,7.5,8.5])\n",
        "\n",
        "# We print x\n",
        "print()\n",
        "print('x = ', x)\n",
        "\n",
        "# We print y\n",
        "print()\n",
        "print('y = ', y)\n",
        "print()\n",
        "\n",
        "# We perfrom basic element-wise operations using arithmetic symbols and functions\n",
        "print('x + y = ', x + y)\n",
        "print('add(x,y) = ', np.add(x,y))\n",
        "print()\n",
        "print('x - y = ', x - y)\n",
        "print('subtract(x,y) = ', np.subtract(x,y))\n",
        "print()\n",
        "print('x * y = ', x * y)\n",
        "print('multiply(x,y) = ', np.multiply(x,y))\n",
        "print()\n",
        "print('x / y = ', x / y)\n",
        "print('divide(x,y) = ', np.divide(x,y))"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "x =  [1 2 3 4]\n",
            "\n",
            "y =  [5.5 6.5 7.5 8.5]\n",
            "\n",
            "x + y =  [ 6.5  8.5 10.5 12.5]\n",
            "add(x,y) =  [ 6.5  8.5 10.5 12.5]\n",
            "\n",
            "x - y =  [-4.5 -4.5 -4.5 -4.5]\n",
            "subtract(x,y) =  [-4.5 -4.5 -4.5 -4.5]\n",
            "\n",
            "x * y =  [ 5.5 13.  22.5 34. ]\n",
            "multiply(x,y) =  [ 5.5 13.  22.5 34. ]\n",
            "\n",
            "x / y =  [0.18181818 0.30769231 0.4        0.47058824]\n",
            "divide(x,y) =  [0.18181818 0.30769231 0.4        0.47058824]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Cv-lLIRANh6q",
        "colab_type": "text"
      },
      "source": [
        "We can also perform the same element-wise arithmetic operations on rank 2 ndarrays. Again, remember that in order to do these operations the shapes of the ndarrays being operated on, must have the same shape or be broadcastable."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aM5ZOfYBNfRr",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 699
        },
        "outputId": "fceff7d7-b52b-433c-aeaa-801c7e61a834"
      },
      "source": [
        "# We create two rank 2 ndarrays\n",
        "X = np.array([1,2,3,4]).reshape(2,2)\n",
        "Y = np.array([5.5,6.5,7.5,8.5]).reshape(2,2)\n",
        "\n",
        "# We print X\n",
        "print()\n",
        "print('X = \\n', X)\n",
        "\n",
        "# We print Y\n",
        "print()\n",
        "print('Y = \\n', Y)\n",
        "print()\n",
        "\n",
        "# We perform basic element-wise operations using arithmetic symbols and functions\n",
        "print('X + Y = \\n', X + Y)\n",
        "print()\n",
        "print('add(X,Y) = \\n', np.add(X,Y))\n",
        "print()\n",
        "print('X - Y = \\n', X - Y)\n",
        "print()\n",
        "print('subtract(X,Y) = \\n', np.subtract(X,Y))\n",
        "print()\n",
        "print('X * Y = \\n', X * Y)\n",
        "print()\n",
        "print('multiply(X,Y) = \\n', np.multiply(X,Y))\n",
        "print()\n",
        "print('X / Y = \\n', X / Y)\n",
        "print()\n",
        "print('divide(X,Y) = \\n', np.divide(X,Y))"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "X = \n",
            " [[1 2]\n",
            " [3 4]]\n",
            "\n",
            "Y = \n",
            " [[5.5 6.5]\n",
            " [7.5 8.5]]\n",
            "\n",
            "X + Y = \n",
            " [[ 6.5  8.5]\n",
            " [10.5 12.5]]\n",
            "\n",
            "add(X,Y) = \n",
            " [[ 6.5  8.5]\n",
            " [10.5 12.5]]\n",
            "\n",
            "X - Y = \n",
            " [[-4.5 -4.5]\n",
            " [-4.5 -4.5]]\n",
            "\n",
            "subtract(X,Y) = \n",
            " [[-4.5 -4.5]\n",
            " [-4.5 -4.5]]\n",
            "\n",
            "X * Y = \n",
            " [[ 5.5 13. ]\n",
            " [22.5 34. ]]\n",
            "\n",
            "multiply(X,Y) = \n",
            " [[ 5.5 13. ]\n",
            " [22.5 34. ]]\n",
            "\n",
            "X / Y = \n",
            " [[0.18181818 0.30769231]\n",
            " [0.4        0.47058824]]\n",
            "\n",
            "divide(X,Y) = \n",
            " [[0.18181818 0.30769231]\n",
            " [0.4        0.47058824]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sB3FyKXnNokr",
        "colab_type": "text"
      },
      "source": [
        "We can also apply mathematical functions, such as sqrt(x), to all elements of an ndarray at once."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gUpizA7QNmKU",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 170
        },
        "outputId": "ac45f76b-69e7-4682-d310-e86fbc2f1c43"
      },
      "source": [
        "# We create a rank 1 ndarray\n",
        "x = np.array([1,2,3,4])\n",
        "\n",
        "# We print x\n",
        "print()\n",
        "print('x = ', x)\n",
        "\n",
        "# We apply different mathematical functions to all elements of x\n",
        "print()\n",
        "print('EXP(x) =', np.exp(x))\n",
        "print()\n",
        "print('SQRT(x) =',np.sqrt(x))\n",
        "print()\n",
        "print('POW(x,2) =',np.power(x,2)) # We raise all elements to the power of 2"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "x =  [1 2 3 4]\n",
            "\n",
            "EXP(x) = [ 2.71828183  7.3890561  20.08553692 54.59815003]\n",
            "\n",
            "SQRT(x) = [1.         1.41421356 1.73205081 2.        ]\n",
            "\n",
            "POW(x,2) = [ 1  4  9 16]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HEHDlHpONvWn",
        "colab_type": "text"
      },
      "source": [
        "Another great feature of NumPy is that it has a wide variety of statistical functions. Statistical functions provide us with statistical information about the elements in an ndarray. Let's see some examples:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iaPpIpT1Nrqu",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 500
        },
        "outputId": "ed914324-a640-407e-eab1-927dc5a5e414"
      },
      "source": [
        "# We create a 2 x 2 ndarray\n",
        "X = np.array([[1,2], [3,4]])\n",
        "\n",
        "# We print x\n",
        "print()\n",
        "print('X = \\n', X)\n",
        "print()\n",
        "\n",
        "print('Average of all elements in X:', X.mean())\n",
        "print('Average of all elements in the columns of X:', X.mean(axis=0))\n",
        "print('Average of all elements in the rows of X:', X.mean(axis=1))\n",
        "print()\n",
        "print('Sum of all elements in X:', X.sum())\n",
        "print('Sum of all elements in the columns of X:', X.sum(axis=0))\n",
        "print('Sum of all elements in the rows of X:', X.sum(axis=1))\n",
        "print()\n",
        "print('Standard Deviation of all elements in X:', X.std())\n",
        "print('Standard Deviation of all elements in the columns of X:', X.std(axis=0))\n",
        "print('Standard Deviation of all elements in the rows of X:', X.std(axis=1))\n",
        "print()\n",
        "print('Median of all elements in X:', np.median(X))\n",
        "print('Median of all elements in the columns of X:', np.median(X,axis=0))\n",
        "print('Median of all elements in the rows of X:', np.median(X,axis=1))\n",
        "print()\n",
        "print('Maximum value of all elements in X:', X.max())\n",
        "print('Maximum value of all elements in the columns of X:', X.max(axis=0))\n",
        "print('Maximum value of all elements in the rows of X:', X.max(axis=1))\n",
        "print()\n",
        "print('Minimum value of all elements in X:', X.min())\n",
        "print('Minimum value of all elements in the columns of X:', X.min(axis=0))\n",
        "print('Minimum value of all elements in the rows of X:', X.min(axis=1))"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "X = \n",
            " [[1 2]\n",
            " [3 4]]\n",
            "\n",
            "Average of all elements in X: 2.5\n",
            "Average of all elements in the columns of X: [2. 3.]\n",
            "Average of all elements in the rows of X: [1.5 3.5]\n",
            "\n",
            "Sum of all elements in X: 10\n",
            "Sum of all elements in the columns of X: [4 6]\n",
            "Sum of all elements in the rows of X: [3 7]\n",
            "\n",
            "Standard Deviation of all elements in X: 1.118033988749895\n",
            "Standard Deviation of all elements in the columns of X: [1. 1.]\n",
            "Standard Deviation of all elements in the rows of X: [0.5 0.5]\n",
            "\n",
            "Median of all elements in X: 2.5\n",
            "Median of all elements in the columns of X: [2. 3.]\n",
            "Median of all elements in the rows of X: [1.5 3.5]\n",
            "\n",
            "Maximum value of all elements in X: 4\n",
            "Maximum value of all elements in the columns of X: [3 4]\n",
            "Maximum value of all elements in the rows of X: [2 4]\n",
            "\n",
            "Minimum value of all elements in X: 1\n",
            "Minimum value of all elements in the columns of X: [1 2]\n",
            "Minimum value of all elements in the rows of X: [1 3]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rQnXwgohN5VQ",
        "colab_type": "text"
      },
      "source": [
        "Finally, let's see how NumPy can perform arithmetics between a single numbers and all the elements of an ndarray without the use of complicated loops."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KPLD2A_UN0Fe",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 368
        },
        "outputId": "67f75eba-a2ea-4f34-b65a-d298d39a74a1"
      },
      "source": [
        "# We create a 2 x 2 ndarray\n",
        "X = np.array([[1,2], [3,4]])\n",
        "\n",
        "# We print x\n",
        "print()\n",
        "print('X = \\n', X)\n",
        "print()\n",
        "\n",
        "print('3 * X = \\n', 3 * X)\n",
        "print()\n",
        "print('3 + X = \\n', 3 + X)\n",
        "print()\n",
        "print('X - 3 = \\n', X - 3)\n",
        "print()\n",
        "print('X / 3 = \\n', X / 3)"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "X = \n",
            " [[1 2]\n",
            " [3 4]]\n",
            "\n",
            "3 * X = \n",
            " [[ 3  6]\n",
            " [ 9 12]]\n",
            "\n",
            "3 + X = \n",
            " [[4 5]\n",
            " [6 7]]\n",
            "\n",
            "X - 3 = \n",
            " [[-2 -1]\n",
            " [ 0  1]]\n",
            "\n",
            "X / 3 = \n",
            " [[0.33333333 0.66666667]\n",
            " [1.         1.33333333]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rK7le2G5OQUm",
        "colab_type": "text"
      },
      "source": [
        "## **Broadcasting:**\n",
        "In order to do element-wise operations, NumPy sometimes uses something called Broadcasting. Broadcasting is the term used to describe how NumPy handles element-wise arithmetic operations with ndarrays of different shapes. For example, broadcasting is used implicitly when doing arithmetic operations between scalars and ndarrays.\n",
        "\n",
        "In the examples above, NumPy is working behind the scenes to broadcast 3 along the ndarray so that they have the same shape. This allows us to add 3 to each element of X with just one line of code.\n",
        "\n",
        "Subject to certain constraints, Numpy can do the same for two ndarrays of different shapes, as we can see below."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sZdEElKmOIJE",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 434
        },
        "outputId": "0ea5fd84-3656-4e88-d073-71d226fb872f"
      },
      "source": [
        "# We create a rank 1 ndarray\n",
        "x = np.array([1,2,3])\n",
        "\n",
        "# We create a 3 x 3 ndarray\n",
        "Y = np.array([[1,2,3],[4,5,6],[7,8,9]])\n",
        "\n",
        "# We create a 3 x 1 ndarray\n",
        "Z = np.array([1,2,3]).reshape(3,1)\n",
        "\n",
        "# We print x\n",
        "print()\n",
        "print('x = ', x)\n",
        "print()\n",
        "\n",
        "# We print Y\n",
        "print()\n",
        "print('Y = \\n', Y)\n",
        "print()\n",
        "\n",
        "# We print Z\n",
        "print()\n",
        "print('Z = \\n', Z)\n",
        "print()\n",
        "\n",
        "print('x + Y = \\n', x + Y)\n",
        "print()\n",
        "print('Z + Y = \\n',Z + Y)"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "x =  [1 2 3]\n",
            "\n",
            "\n",
            "Y = \n",
            " [[1 2 3]\n",
            " [4 5 6]\n",
            " [7 8 9]]\n",
            "\n",
            "\n",
            "Z = \n",
            " [[1]\n",
            " [2]\n",
            " [3]]\n",
            "\n",
            "x + Y = \n",
            " [[ 2  4  6]\n",
            " [ 5  7  9]\n",
            " [ 8 10 12]]\n",
            "\n",
            "Z + Y = \n",
            " [[ 2  3  4]\n",
            " [ 6  7  8]\n",
            " [10 11 12]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LeeZLIXoOvzb",
        "colab_type": "text"
      },
      "source": [
        "As before, NumPy is able to add 1 x 3 and 3 x 1 ndarrays to 3 x 3 ndarrays by broadcasting the smaller ndarrays along the big ndarray so that they have compatible shapes. In general, NumPy can do this provided that the smaller ndarray, such as the 1 x 3 ndarray in our example, can be expanded to the shape of the larger ndarray in such a way that the resulting broadcast is unambiguous."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9kNw90GNO6-i",
        "colab_type": "text"
      },
      "source": [
        "## **Assignment:**\n",
        "Make sure you check out the NumPy Documentation for more information on Broadcasting and its rules: [Here](https://docs.scipy.org/doc/numpy-1.13.0/user/basics.broadcasting.html)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "atR6p2-EPLjC",
        "colab_type": "text"
      },
      "source": [
        "## **Question:**\n",
        "Use Broadcasting to create a 4 x 4 ndarray that has its first column full of 1s, its second column full of 2s, its third column full of 3s, etc.. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5VV4j0doOiSS",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import numpy as np\n",
        "\n",
        "X = "
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}