2_Numpy_and_some_basic_concepts.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Numpy and some basic concepts.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "tAccmTzVzeWB",
        "XVfWRXmxzeWk",
        "mA2r_jq7zeWt",
        "akPqb4qmzeXu"
      ]
    },
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.7.1"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "bF5UmzCczeTU"
      },
      "source": [
        "## Numpy\n",
        "So we are here with Numpy, our first library to learn, which is the fundamental package for scientific computing with Python.<br>\n",
        "Let's start!<br><br>\n",
        "<b>Note</b>: Some of the topics here are followed by some simple problems with instuctions, examples, sample outputs and expected outputs for you to practice along, so that you get clear with the concepts then and there! And also if it's not given, make sure you understand it well and you can also create new cells and practice on your own to clear your doubts!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "Z72zWbuazeTZ"
      },
      "source": [
        "1.Import the Numpy library using the syntax given below:<br>\n",
        "**import numpy as np**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "I2nbrVnfzeTc",
        "colab": {}
      },
      "source": [
        "#Enter the syntax below and run the cell\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "fe2qVIP4zeTx"
      },
      "source": [
        "###### Creating an ndarray(n-dimensional array) from a list\n",
        "The most important object defined in NumPy is an **N-dimensional array** type called **ndarray**. It describes the **collection of items of the same type**. Items in the collection can be accessed using a **zero-based index**(implies, the index of elements begins with 0 and not 1).<br><br>\n",
        "We use the **array()** function of NumPy here.<br>\n",
        "Note that, to access numpy's functions, we will use **np.function_name** syntax, where np is, you can say a shortform we use instead of writing numpy everytime.<br>\n",
        "2.Create a **1D array** using the syntax given below:<br>\n",
        "**array_name = np.array([list_elements])**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "FA3pJW42zeTz",
        "colab": {}
      },
      "source": [
        "#Enter your code below\n",
        "\n",
        "#Example: a = np.array([5,10,15])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "NNadZVO7zeT-",
        "colab": {}
      },
      "source": [
        "#You can print your 1D array here below:\n",
        "\n",
        "#Example: print(a) or just type a and run the cell\n",
        "#Sample Output: ([5,10,15])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "CLuP8EvqzeUG"
      },
      "source": [
        "###### Creating an ndarray from a list of lists(Multidimensional arrays)\n",
        "Same **array()** function is to be used here.<br><br>\n",
        "3.Create a **2D array** using the syntax given below:<br>\n",
        "**array_name = np.array([[elements_of_first_row], [elements_of_second_row], [...], ...])**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "qLBf-KmbzeUH",
        "colab": {}
      },
      "source": [
        "#Enter your code below\n",
        "\n",
        "#Example: b = np.array([[1,2,3],[2,4,6],[3,6,9]])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "_k4SWcBUzeUN",
        "colab": {}
      },
      "source": [
        "#You can print your 2D array here below:\n",
        "\n",
        "#Example: print(b) or just type b and run the cell\n",
        "#Sample Output: ([[1,2,3],[2,4,6],[3,6,9]])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F0IJJ3zj1Lzn",
        "colab_type": "text"
      },
      "source": [
        "<b>Note:</b> I will be using these arrys, i.e, <b>a</b> and <b>b</b> in the following examples"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "fdcc9wVbzeUT"
      },
      "source": [
        "###### Dimensions of the array\n",
        "We use the **shape** attribute of array here.<br>\n",
        "It returns a tuple with 2 elements,where first element equals to number of rows in the array and the second element equals to number of columns in the array.<br><br>\n",
        "3.Print dimensions of your array using the syntax below:<br>\n",
        "**array_name.shape**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "OpjZMDtrzeUU",
        "colab": {}
      },
      "source": [
        "#Enter your code below\n",
        "\n",
        "#Example1: a.shape\n",
        "#Sample Output1:(3,)\n",
        "\n",
        "#Example2: b.shape\n",
        "#Sample Output2:(3,3)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "2JJoyKRmzeUf"
      },
      "source": [
        "###### arange(start,stop,step)\n",
        "Like range function in python, the arange() function of Numpy gives us an array of evenly spaced elements within the interval [start,stop)(i.e, interval including start and excluding stop), instead of a list.<br>\n",
        "'Step' is the spacing or difference between adjacent values.<br><br>\n",
        "4.Create an array of **first 5 positive numbers divisible by 4** using the syntax given below:<br>\n",
        "**array_name = np.arange(start,stop,step)**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "pYQ581eWzeUh",
        "colab": {}
      },
      "source": [
        "#Enter your code below\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "vND-Kx3BzeUp",
        "colab": {}
      },
      "source": [
        "#Print your array here below\n",
        "\n",
        "#Expected Output: ([4,8,12,16,20])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "S8Pq0x_lzeUv"
      },
      "source": [
        "##### reshape(new_row_size,new_column_size)\n",
        "The reshape() function is used to give a new shape to an array without changing its data.<br><br>\n",
        "5.Reshape the below array, 'data' into an array with row size = <b>6</b> and column size = <b>2</b> using the syntax given below:<br>\n",
        "**array_name.reshape(new_row_size,new_column_size)**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "jKkLU6YGzeUw",
        "outputId": "c74d5c77-14c5-42f5-9428-7be2422c5c05",
        "scrolled": true,
        "colab": {}
      },
      "source": [
        "#Run this cell\n",
        "\n",
        "data = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])\n",
        "print('My ndarray is \\n',data)\n",
        "print(\"\\n Its size is:\",data.shape)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "My ndarray is\n",
            " [[ 1  2  3  4]\n",
            " [ 5  6  7  8]\n",
            " [ 9 10 11 12]]\n",
            "\n",
            "Its size is: (3, 4)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "tyG5KPU2zeU2",
        "colab": {}
      },
      "source": [
        "#Enter your code here below\n",
        "\n",
        "#Expected Output:([[1,2],[3,4],[5,6],[7,8],[9,10],[11,12]])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ul_jzjgr1L0n",
        "colab_type": "text"
      },
      "source": [
        "<b>Note</b>: (old_row_size * old_column_size) = (new_row_size * new_column_size)<br>\n",
        "i.e, number of elements should not change while reshaping."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "VFh1iBrtzeVZ"
      },
      "source": [
        "#### arange(start,stop,step).reshape(row_size,column_size)\n",
        "Now we will use the **arange()**  and the **reshape()** functions together to create some ordered ndarray of required size as shown below using an example.<br>\n",
        "So, look at the code below:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "E_xpI1JHzeVa",
        "colab": {}
      },
      "source": [
        "#Run this cell\n",
        "\n",
        "c = np.arange(30).reshape(5,6)\n",
        "print(c)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AUFgbT9w1L0x",
        "colab_type": "text"
      },
      "source": [
        "So, here we have a (5 * 6) ndarray with elements ranging from 0 to 29.Now you can practice on your own, but make sure that the **number of elements generated by the arange function should be equal to (row_size * column_size) given in the reshape function.**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "Gn7WZm_vzeVe"
      },
      "source": [
        "Now, go through these functions and attributes with their syntax and explanation on your own and practice in the following cells, which include sufficient examples;<br>\n",
        "<ul>\n",
        "    <li><b>len(array_name)</b> - Gives length of array</li>\n",
        "    <li><b>array_name.ndim</b> - Gives array dimensions</li>\n",
        "    <li><b>array_name.size</b> - Gives the size of array(Total elements)</li>\n",
        "    <li><b>array_name.dtype</b>- Gives the datatype of the elements</li>\n",
        "    <li><b>type(array_name)</b>- Gives type of array</li>\n",
        "</ul>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "gHHoQuhNzeVe",
        "colab": {}
      },
      "source": [
        "#Enter your code here\n",
        "\n",
        "#Example: len(b)\n",
        "#Sample Output: 3"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "RsIvSuntzeVi",
        "colab": {}
      },
      "source": [
        "#Enter you code here\n",
        "\n",
        "#Example: b.ndim\n",
        "#Sample Output: 2 "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "s6ymF6ipzeVy",
        "colab": {}
      },
      "source": [
        "#Enter your code here\n",
        "\n",
        "#Example: b.size\n",
        "#Sample Output: 9"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "p0MPPbh-zeV4",
        "colab": {}
      },
      "source": [
        "#Enter your code here\n",
        "\n",
        "#Example: b.dtype\n",
        "#Sample Output: int32"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "XTIJuB8ozeV8",
        "colab": {}
      },
      "source": [
        "#Enter your code here\n",
        "\n",
        "#Example: type(b)\n",
        "#Sample Output: numpy.ndarray"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "tAccmTzVzeWB"
      },
      "source": [
        "#### Placeholders\n",
        "In computer programming, a placeholder is a character, word, or string of characters that temporarily takes the place of the final data. Say, a programmer may know that he/she needs a certain number of values or variables, but doesn't yet know what to input. So one can use a placeholder in this case as a temporary solution until a proper value or variable can be assigned.<br>\n",
        "Example: I want an array with three elements but their values get updated only later along the course, so i set a placeholder for it as<br>\n",
        "***three_element_array = [0,0,0]***<br><br>\n",
        "Now try out these different placeholders in Numpy along with the examples followed:<br>\n",
        "<ul>\n",
        "    <li><b>np.linspace(start, stop, length)</b> - Add evenly spaced values btw interval[start,stop] to  an array of length</li>\n",
        "    <li><b>np.zeros((row_size, cloumn_size))</b> - Creates an array filled with zeros</li>\n",
        "    <li><b>np.ones((row_size, column_size))</b> - Creates an array filled with ones</li>\n",
        "    <li><b>np.random.random((row_size, column_size))</b> - Creates a random array</li>\n",
        "    <li><b>np.empty((row_size, column_size))</b> - Creates an empty array</li>\n",
        "    <li><b>np.full((row_size, column_size),fill_value,dtype)</b> - Creates a new array of given shape and type, filled with fill_value.</li>\n",
        "</ul>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "BjQkG-CPzeWC",
        "colab": {}
      },
      "source": [
        "#Enter your code here\n",
        "\n",
        "#Example: np.linspace(0,10,6)\n",
        "#Sample Output: ([ 0.,  2.,  4.,  6.,  8., 10.])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "cEVPID77zeWG",
        "colab": {}
      },
      "source": [
        "#Enter your code here\n",
        "\n",
        "#Example: np.zeros((1,2))\n",
        "#Sample Output: ([[0.,0.]])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "5_H7uegTzeWK",
        "colab": {}
      },
      "source": [
        "#Enter your code here\n",
        "\n",
        "#Example: np.ones((1,3))\n",
        "#Sample Output:([[1.,1.,1.]])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "jyLC3rw4zeWN",
        "colab": {}
      },
      "source": [
        "#Enter your code here\n",
        "\n",
        "#Example: np.random.random((1,2))\n",
        "#Sample Output: ([[0.55824656, 0.39591466]])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "zsJQRuK_zeWR",
        "colab": {}
      },
      "source": [
        "#Enter your code here\n",
        "\n",
        "#Example: np.empty((1,2))\n",
        "#Sample Output: ([[0.55824656, 0.39591466]])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "Qe_oKuOJzeWV"
      },
      "source": [
        "Note - **np.empty(())** returns uninitialized(arbitrary) data of the given shape"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "hKMRWyqczeWX"
      },
      "source": [
        "#### Horizontal and vertical stacking\n",
        "We will now combine two arrays vertically and horizontally.<br>\n",
        "<ul><li><b>np.hstack((first_array,second_array))</b> - Combine/Stack array column wise</li>\n",
        "    <li><b>np.vstack((first_array,second_array))</b> - Combine/Stack array row-wise</li></ul>\n",
        "Follow the steps with instructions along with examples and come on let's <b>practice</b>:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "vT6Gc7Q6zeWX"
      },
      "source": [
        "**Note**:<ul>\n",
        "    <li>For vertical stacking, number of columns should be same.</li>\n",
        "<li>And for horizontal stacking, number of rows should be same.</li></ul>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "T78GvGadzeWY",
        "colab": {}
      },
      "source": [
        "#First create two arrays\n",
        "#Enter your code below\n",
        "\n",
        "#Example: x=np.arange(1,5) and y=np.arange(2,9,2)\n",
        "#x=([1,2,3,4]) and y=([2,4,6,8])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "rsjrPfuSzeWc",
        "colab": {}
      },
      "source": [
        "#Vertical stacking\n",
        "#Enter your code below\n",
        "\n",
        "#Example: v = np.vstack((x,y))\n",
        "#Print v\n",
        "#Sample Output: ([[1, 2, 3, 4],[2, 4, 6, 8]])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "nASTTLxIzeWh",
        "colab": {}
      },
      "source": [
        "#Horizontal stacking\n",
        "#Enter your code below\n",
        "\n",
        "#Example: h = np.hstack((x,y))\n",
        "#Print h\n",
        "#Sample Output: ([1, 2, 3, 4, 2, 4, 6, 8])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4plEnUZu2vty",
        "colab_type": "text"
      },
      "source": [
        "To get a better understanding of what actually happens when we use these functions, have a look at the pictorial representions of [horizontal stacking](https://www.w3resource.com/numpy/manipulation/hstack.php) and [vertical stacking](https://www.w3resource.com/numpy/manipulation/vstack.php)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "XVfWRXmxzeWk"
      },
      "source": [
        "#### Horizontal and vertical splitting\n",
        "Now, we can split the arrays we combined using the functions given below.\n",
        "<ul>\n",
        "    <li><b>np.hsplit(array,indices_or_sections)</b> - used to split an array into multiple sub-arrays horizontally (column-wise)</li>\n",
        "    <li><b>np.vsplit(array,indices_or_sections)</b> - used to split an array into multiple sub-arrays vertically (row-wise)</li>\n",
        "</ul>\n",
        "We use the stacked arrays <b>h</b> and <b>v</b> here again in the examples,<br>\n",
        "where, <b>v = ([[1, 2, 3, 4],[2, 4, 6, 8]])</b> and <b>h = ([1, 2, 3, 4, 2, 4, 6, 8])</b><br>\n",
        "You can also do the same with your examples or create new ndarrays if u want."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "kua6C-X6zeWl",
        "colab": {}
      },
      "source": [
        "#Vertical splitting\n",
        "#Enter your code here\n",
        "\n",
        "#Example: np.vsplit(v,2)\n",
        "#Sample Output: [array([[1, 2, 3, 4]]), array([[2, 4, 6, 8]])]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "DBCwcLqFzeWq",
        "colab": {}
      },
      "source": [
        "#Horizontal splitting\n",
        "#Enter your code here\n",
        "\n",
        "#Example: np.hsplit(h,2)\n",
        "#Sample Output: [array([1, 2, 3, 4]), array([2, 4, 6, 8])]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DvyZVLLU1L2C",
        "colab_type": "text"
      },
      "source": [
        "Visit this link to visualise [vertical splitting](https://www.w3resource.com/numpy/manipulation/vsplit.php).<br>\n",
        "And visit this link to visualize [horizontal splitting](https://www.w3resource.com/numpy/manipulation/hsplit.php)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "mA2r_jq7zeWt"
      },
      "source": [
        "#### Floor and Ceil\n",
        "<ul>\n",
        "    <li><b>np.floor(array)</b> - returns floor of elements of array</li>\n",
        "    <li><b>np.ceil(array)</b> - returns ceil of elements of array</li>\n",
        "</ul>\n",
        "Example: a = 5.6<br>\n",
        "floor(a) = 5<br>\n",
        "ceil(a) = 6"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "GsdLK5j2zeWu",
        "colab": {}
      },
      "source": [
        "#Run this cell\n",
        "#Creating a random array\n",
        "c = np.random.random((2,3))\n",
        "print(c)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "cfwn_SZQzeWy",
        "colab": {}
      },
      "source": [
        "#floor\n",
        "#Enter your code below\n",
        "\n",
        "#Example: np.floor(c)\n",
        "#Sample Output: ([[0., 0., 0.],[0., 0., 0.]])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "hyKQH8h5zeW0",
        "colab": {}
      },
      "source": [
        "#ceil\n",
        "#Enter your code below\n",
        "\n",
        "#Example: np.ceil(c)\n",
        "#Sample Output:([[1., 1., 1.],[1., 1., 1.]])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "u-JC3GvTN9LV"
      },
      "source": [
        "#### Squeeze and Expand\n",
        "<ul>\n",
        "<li><b>np.squeeze(array,axis)</b> - used to remove single-dimensional entries from the shape of an array.</li>\n",
        "<li><b>np.expand_dims(array,axis)</b> - expands the shape of an array i.e, inserts a new axis that will appear at the axis position in the expanded array shape.</li>\n",
        "</ul>\n",
        "Let's see the example below:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "nvaU7_OhTgPe",
        "colab": {}
      },
      "source": [
        "#Run this cell\n",
        "#Suppose we have a three dimensional ndarray as given below\n",
        "three_dim = np.array([[[10],[20],[30]]])\n",
        "print('three_dim = ',three_dim)\n",
        "print('Shape = ',three_dim.shape)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "-4ONS294Vgwo"
      },
      "source": [
        "As you see above **three_dim** is a three dimensional array with shape **(1,3,1)**, now suppose I want to access this ndarray I will need to specify three indices, which is just an unnecessary task in this case.So it's better to squeeze the unwanted dimensions or the single dimensions here and access the elements easily.\n",
        "<br>Let's see how we will squeeze this ndarray below:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "b3GKYDEyiMjF",
        "colab": {}
      },
      "source": [
        "#Run this cell\n",
        "one_dim = np.squeeze(three_dim)\n",
        "print('Squeezed array = ',one_dim)\n",
        "print('Shape = ',one_dim.shape)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "lLdkWbjci3pn"
      },
      "source": [
        "And now you can easily manipulate this squeezed array for your desired operations.<br><br>\n",
        "Now, what if we have a case that is opposite to it in hand, i.e, suppose I have a two dimensional array and I want to perform an operation to it with a three dimensional array operand, so here we will need to expand the dimensions of our 2D array and let's see how we do it with **np.expand_dims()**:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "BIDC-JrPlE5r",
        "colab": {}
      },
      "source": [
        "#Run this cell\n",
        "two_dim = np.array([[10],[20],[30]])\n",
        "print('two_dim = ',two_dim)\n",
        "print('Shape = ',two_dim.shape)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "Jb-YUD1YvELy"
      },
      "source": [
        "Now, let's expand this to a 3D array to make the dimensions of the operands equal, so that we could perform the operation with a 3D operand easily. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "7memjiEEvFEH",
        "colab": {}
      },
      "source": [
        "#Run this cell\n",
        "dim_three = np.expand_dims(two_dim,axis=0)\n",
        "print('dim_three = ',dim_three)\n",
        "print('Shape = ',dim_three.shape)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YrcSNBR_1L2m",
        "colab_type": "text"
      },
      "source": [
        "So now we got a 3D array with dimensions **(1 * 3 * 1 )**.Here I expanded it along the horizontal axis, i.e, **axis=0** to get a three dimensional array of the dimensions (1 * 3 * 1). Had it been, along the vertical axis,i.e, **axis=1**, I would have got a 3D array of dimensions **(3 * 1 * 1)**.<br>\n",
        "Remember this is just a random example where I am not specific about the exact number of elements in each dimension to perform the operation.In practical situations, we have to manipulate ndarrays using these functions in accordance to our requirement!So I suggest to practice on your own to get a better idea of this topic.<br>\n",
        "And also refer these links to visualise [squeeze](https://www.w3resource.com/numpy/manipulation/squeeze.php) and [expand_dims](https://www.w3resource.com/numpy/manipulation/expand-dims.php) operations."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "-nnOOEdUzeW3"
      },
      "source": [
        "#### Transpose and dot product of matices\n",
        "<ul>\n",
        "    <li><b>array.T</b> - It gives the transpose of a matrix</li>\n",
        "    <li><b>np.dot(arra1,array2)</b> - Returns dot product of two arrays</li>\n",
        "</ul>\n",
        "Understand with examples and learn with practice!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "fczM7Y8CzeW4",
        "colab": {}
      },
      "source": [
        "#Enter your code here\n",
        "\n",
        "#Example: v.T\n",
        "#v = ([[1, 2, 3, 4],[2, 4, 6, 8]])\n",
        "#Sample Output: ([[1, 2],[2, 4],[3, 6],[4, 8]])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "9j24MLEMzeW6",
        "colab": {}
      },
      "source": [
        "#Run this cell\n",
        "p = np.arange(0,6).reshape(2,3)\n",
        "q = np.arange(0,6).reshape(3,2)\n",
        "print('p=',p)\n",
        "print('q=',q)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "Rgff3LqkzeW9",
        "colab": {}
      },
      "source": [
        "#Enter your code here\n",
        "\n",
        "#Example:t = np.dot(p,q)\n",
        "#Print t\n",
        "#Sample Output: ([[10, 13],[28, 40]])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "POWJCSh9zeXA"
      },
      "source": [
        "##### Sum()\n",
        "<ul>\n",
        "    <li><b>array.sum()</b> - Sum of all the elements</li>\n",
        "    <li><b>array.sum(axis=0)</b> - Column sum</li>\n",
        "    <li><b>array.sum(axis=1)</b> - Row sum</li>\n",
        "</ul>where array is an ndarray.<br><br>\n",
        "Take a look at the examples below where we use <b>t</b> from the above example and <b>t = ([[10, 13],[28, 40]])</b>.<br>\n",
        "Give it a try on your own with the ndarrays that you have used before or you can always create your own."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "AUlI1O32zeXB",
        "colab": {}
      },
      "source": [
        "#Enter your code here\n",
        "\n",
        "#Example: t.sum()\n",
        "#Sample Output: 91"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "iVzIby4czeXE",
        "colab": {}
      },
      "source": [
        "#Enter your code here\n",
        "\n",
        "#Example: t.sum(axis=0)\n",
        "#Sample Output: ([38, 53])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "4cNgzrd7zeXH",
        "colab": {}
      },
      "source": [
        "#Enter your code here\n",
        "\n",
        "#Example: t.sum(axis=1)\n",
        "#Sample Output: ([23, 68])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "_f0UVhF9zeXK"
      },
      "source": [
        "Similarly,try out these functions too and do not forget to practice okay?<br>\n",
        "<ul>\n",
        "    <li><b>ndarray.min()</b> - to calculate the minimum value</li>\n",
        "    <li><b>ndarray.max()</b> -  to calculate the maximum value</li>\n",
        "    <li><b>ndarray.mean()</b> - to calculate the mean average value</li>\n",
        "</ul>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "dW8XQf2JzeXM"
      },
      "source": [
        "#### Cumsum()\n",
        "<ul>\n",
        "    <li><b>array.cumsum()</b> - (Default case) Returns the cumilative sum over the flattened array.</li>\n",
        "    <li><b>array.cumsum(axis=0)</b> - Returns cumilative sum of the elements along the columns.</li>\n",
        "    <li><b>array.cumsum(axis=1)</b> - Returns cumilative sum of the elements along the rows.</li>\n",
        "</ul>where array is an ndarray.<br><br>\n",
        "Are you wondering what a flattened array is?Let's see some examples to clear your doubts and don't forget to try it on your own!<br>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "RkGkHL8qzeXM",
        "colab": {}
      },
      "source": [
        "#Enter your code here\n",
        "\n",
        "#Example: t.cumsum() (where t is an ndarray and t = [[10, 13],[28, 40]] as used in the examples before. )\n",
        "#Output: [10, 23, 51, 91]\n",
        "#You can see that the 2D array is flattened into one and the cumilative sums are calculated along the single row of the list"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "BGb9g6y0zeXP",
        "colab": {}
      },
      "source": [
        "#Enter your code here\n",
        "\n",
        "#Example: t.cumsum(axis=0)\n",
        "#Output: [[10, 13],[38, 53]]\n",
        "#Here note that the cumilative sum is computed along the columns in the 2D array"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "8-pttfHkzeXU",
        "colab": {}
      },
      "source": [
        "#Enter your code here\n",
        "\n",
        "#Example: t.cumsum(axis=1)\n",
        "#Output:[[10, 23],[28, 68]]\n",
        "#Here note that the cumilative sum is computed along the rows in the 2D array"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "ZIOsWuhlzeXW"
      },
      "source": [
        "#### Remember\n",
        "**axis=0** specifies column or vertical axis.<br>\n",
        "**axis=1** specifies row or horizontal axis<br>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "7dvG0aqkzeXX"
      },
      "source": [
        "##### Note!!\n",
        "You will be probably thinking that, when we have lists in python then why use NumPy's ndarray data structure, right?<br>\n",
        "We will take the last function we practiced now as an example,i.e, the sum( ) function. Now, if we wanted to calculate the column sum of each column or row sum of each row for a list of lists(2D lists), we would require a for loop to access each list to calulate it's sum and it won't be efficient at all when we have a large number of lists.<br>\n",
        "<br>\n",
        "And that's why we use the NumPy library.Using NumPy library, we can replace for loops with operations applied to multiple data points at once.This is called **vectorization** and ndarrays make vectorization possible!<br>\n",
        "These vectorized operations help take a lot of the mental load out of working with big collections of values when you basically want to do the same thing to all of them, treating the logic like you’re just working with one number. You don’t write any loops of your own!<br><br>\n",
        "**The NumPy library takes advantage of a processor feature called <i>Single Instruction Multiple Data (SIMD)</i> to process data faster. SIMD allows a processor to perform the same operation, on multiple data points, in a single processor cycle.**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "hfdIZvFAzeXY"
      },
      "source": [
        "### Vectorisation in ndarrays\n",
        "Let's see the example below to get a better understanding of the concept."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "AlCuXzQnzeXY",
        "colab": {}
      },
      "source": [
        "#Run this cell\n",
        "x = np.array([1,2,3,4])\n",
        "y = np.array([4,3,2,1])\n",
        "z = x + y\n",
        "print(z)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "ZJ3lvOjIzeXd"
      },
      "source": [
        "We have now **\"vectorized\"** the addition operation, making it work for vectors. The NumPy library has a whole bunch of vectorized functions, including square root, absolute value, trigonometry functions, logarithmic functions, exponential functions, and more.<br>\n",
        "Now try out **vectorizing multiplication, subtraction and exponential operations** on your own."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "7AhpaEFJzeXe",
        "colab": {}
      },
      "source": [
        "#Vectorize multiplication operation\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "duyPsua0zeXg",
        "colab": {}
      },
      "source": [
        "#Vectorize subtraction operation\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "5T2dgrDizeXk",
        "colab": {}
      },
      "source": [
        "#Vectorize exponential operation\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "4EXWgJOvzeXo"
      },
      "source": [
        "### Broadcasting  in ndarrays\n",
        "OK, so far we’ve figured out that the idea behind **vectorization** is to make operations between two collections of the **same size and shape** as intuitive as operations between two single numbers. <br>\n",
        "But what about when the collections are **different shapes**? <br>\n",
        "This is when we apply a concept known as **broadcasting**. Broadcasting is the act of extending an array to a shape that will allow it to successfully take part in a vectorized calculation. <br>\n",
        "Let's again go with an example to figure out this concept in a better manner"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "pW9WukT1zeXo",
        "colab": {}
      },
      "source": [
        "#Run this cell\n",
        "l = np.array([1,2,3,4])\n",
        "m = 10\n",
        "n = l*m\n",
        "print(n)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "tzofnnYTzeXr"
      },
      "source": [
        "So, didn't you notice how 10 was multiplied to all the numbers in the list, l. Here the single element 10 in m is **broadcasted** to [10,10,10,10] to perform the given operation.This feature of python is called broadcasting!<br>\n",
        "So now you can **practice** this on your own with **any operation** you like."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "NkB28FhgzeXr",
        "colab": {}
      },
      "source": [
        "#Practice here\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "I0CXNBg2ISkO"
      },
      "source": [
        "Rules of broadcasting are given below:<br>\n",
        "<ul>\n",
        "<li>If the two arrays are of the same length in a dimension, that dimension will be operated on in an element-wise manner. </li>\n",
        "<li>If one array has some number in a dimension and the other array is only size 1 in that dimension, that value will be broadcasted, and it will be used with each item in the other array. </li>\n",
        "<li>If the two arrays are different sizes and neither is size 1, broadcasting can't be performed, and an error is thrown.</li>\n",
        "</ul>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "akPqb4qmzeXu"
      },
      "source": [
        "#### Activity\n",
        "So here is a very small activity for you to do:<br>\n",
        "Try out following functions that you might have used with lists in python:\n",
        "    <ul>\n",
        "    <li>array.flatten()</li>\n",
        "    <li>np.append(array,element)</li>\n",
        "    <li>np.delete(array,element,axis)</li>\n",
        "    <li>np.copy(array)</li>\n",
        "    <li>insert(array,element1,element2,...axis)</li>\n",
        "    <li>array.sort(axis)</li><br>\n",
        "    </ul>\n",
        "You can also explore other functions on your own!<br>\n",
        "The link to complete reference guide for Numpy is given below to enhance your knowledge on the same:<br>\n",
        "[Reference guide](https://numpy.org/doc/1.18/numpy-ref.pdf)\n",
        "<br>\n",
        "And a more simplified explanation can be found here.[Simplified overview](https://www.w3resource.com/numpy/manipulation/index.php)\n",
        "#### Happy learning!"
      ]
    }
  ]
}