Mahendra_Python_NumPy.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Untitled3.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nZRdGJy65I9c",
        "colab_type": "text"
      },
      "source": [
        "# **NumPy Basics**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IuqSl-Yp5RDr",
        "colab_type": "text"
      },
      "source": [
        "## **Creating a Basic Array**\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fvooP0X15BYH",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        },
        "outputId": "3db419bb-c1c0-466c-8742-59ec515f00f3"
      },
      "source": [
        "   import numpy as np\n",
        "   arr1=np.array([1,2,3])\n",
        "   arr2=np.array(['a','b','c','d','e'])\n",
        "   arr3= np.array((1, 2, 3, 4, 5)) # You can also pass a tuple to creat an Array\n",
        "   print(arr1)\n",
        "   print(arr2)\n",
        "   print(arr3)\n",
        "   print(type(arr1))"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1 2 3]\n",
            "['a' 'b' 'c' 'd' 'e']\n",
            "[1 2 3 4 5]\n",
            "<class 'numpy.ndarray'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lro9176r5uX8",
        "colab_type": "text"
      },
      "source": [
        "Arrays using ***np.zeros(), np.ones(), np.arange()***"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cpTvrMpc6DF6",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 102
        },
        "outputId": "1ac6b116-53e0-45fe-a319-96bfc3ce269a"
      },
      "source": [
        "   import numpy as np\n",
        "   a=np.zeros(3)\n",
        "   b=np.ones(5)\n",
        "   c=np.arange(10)\n",
        "   d=np.arange(2,9)   # To specify start and stop\n",
        "   e=np.arange(1,10,2) # To specify start and stop with step size\n",
        "   print(a)\n",
        "   print(b)\n",
        "   print(c)\n",
        "   print(d)\n",
        "   print(e)"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0. 0. 0.]\n",
            "[1. 1. 1. 1. 1.]\n",
            "[0 1 2 3 4 5 6 7 8 9]\n",
            "[2 3 4 5 6 7 8]\n",
            "[1 3 5 7 9]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZgpAKkfJ6VaO",
        "colab_type": "text"
      },
      "source": [
        "## **NdArray (N-Dimensional Array)**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kqyrw5Gz6hFh",
        "colab_type": "text"
      },
      "source": [
        " **A 2-Dimensional Array**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9ZQaeKsm69yz",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 221
        },
        "outputId": "3d881694-ff37-42f1-e545-26a7289dc9b7"
      },
      "source": [
        "   import numpy as np\n",
        "   arr1=np.array([[1,2,3],[4,5,6]])\n",
        "   arr2=np.array([[1,2,3],[4,5,6],[7,8,9]])\n",
        "   arr3=np.array([['a','b','c'],['d','e','f']])\n",
        "   \n",
        "   #creates a 3X3 array with all zeros\n",
        "   zeros=np.zeros((3,3))\n",
        "   \n",
        "   #creates a 2X2 array with all ones\n",
        "   ones=np.ones((2,2),dtype='int64')  #specify the type with (dtype) parameter \n",
        "   \n",
        "   print(arr1)\n",
        "   print(arr2)\n",
        "   print(arr3)\n",
        "   print(zeros)\n",
        "   print(ones)"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[1 2 3]\n",
            " [4 5 6]]\n",
            "[[1 2 3]\n",
            " [4 5 6]\n",
            " [7 8 9]]\n",
            "[['a' 'b' 'c']\n",
            " ['d' 'e' 'f']]\n",
            "[[0. 0. 0.]\n",
            " [0. 0. 0.]\n",
            " [0. 0. 0.]]\n",
            "[[1 1]\n",
            " [1 1]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9CrmsTfZ7JzM",
        "colab_type": "text"
      },
      "source": [
        "NumPy provides some cool methods you can check the number of dimensions using ***ndim***"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nxCplbEd7LEf",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        },
        "outputId": "90148302-5fc2-415b-808e-ef54f3cd0a28"
      },
      "source": [
        "   import numpy as np\n",
        "\n",
        "   a = np.array(42)\n",
        "   b = np.array([1, 2, 3, 4, 5])\n",
        "   c = np.array([[1, 2, 3], [4, 5, 6]])\n",
        "   d = np.array([[[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]]])\n",
        "\n",
        "   print(a.ndim)\n",
        "   print(b.ndim)\n",
        "   print(c.ndim)\n",
        "   print(d.ndim)"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0\n",
            "1\n",
            "2\n",
            "3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yPsSP0zW7bGq",
        "colab_type": "text"
      },
      "source": [
        "**Basic Operations with Arrays**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "t9HppyiA7UKx",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 136
        },
        "outputId": "43ee7741-1152-4b31-c5f0-797ea96b48dc"
      },
      "source": [
        "   import numpy as np\n",
        "   arr1=np.array([5,5,5,5])\n",
        "   arr2=np.array([3,3,3,3])\n",
        "   c=arr1+arr2\n",
        "   d=arr1-arr2\n",
        "   e=arr1/arr2\n",
        "   print(arr1)\n",
        "   print(arr2)\n",
        "   print(c) # addition\n",
        "   print(d) # subtraction\n",
        "   print(e) # division\n",
        "   print(\"Adding one to all elements:\",c+1)\n",
        "   print(\"Subtracting one from all elements:\",d-1)"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[5 5 5 5]\n",
            "[3 3 3 3]\n",
            "[8 8 8 8]\n",
            "[2 2 2 2]\n",
            "[1.66666667 1.66666667 1.66666667 1.66666667]\n",
            "Adding one to all elements: [9 9 9 9]\n",
            "Subtracting one from all elements: [1 1 1 1]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Gl-ASg4q9j6N",
        "colab_type": "text"
      },
      "source": [
        "## **Array Indexing and Slicing**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iMTS3mZS9oaS",
        "colab_type": "text"
      },
      "source": [
        "### **Array Indexing**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-XzhAaZH9tfV",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 119
        },
        "outputId": "e8b5d068-74a0-41da-c388-318f0f2228c4"
      },
      "source": [
        "   import numpy as np\n",
        "   arr1= np.array([3,2,3,4])\n",
        "   arr2= np.array([2,1,1,3])\n",
        "   arr3= np.array(['D','e','V','I','n','c','e','p','t'])\n",
        "   arr4= np.array([[1,2,3,4,5], [6,7,8,9,10]])\n",
        "   print(arr1[0]) # prints first element\n",
        "   print(arr1[-1]) # prints last element\n",
        "   print(arr2[2]) # prints third element\n",
        "   print(arr3[0]) # prints first element\n",
        "   print(arr4[1][3]) #prints 9\n",
        "   print(arr4[1,3]) # Or you can use this type "
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3\n",
            "4\n",
            "1\n",
            "D\n",
            "9\n",
            "9\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xC66jkkb-DHc",
        "colab_type": "text"
      },
      "source": [
        "### **Array Slicing**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uieObpRf-GEt",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 187
        },
        "outputId": "fc6d156f-9268-4c37-d4e3-5542ff89db8e"
      },
      "source": [
        "   import numpy as np\n",
        "   arr1=np.array(['D','e','V','I','n','c','e','p','t'])\n",
        "   arr2=np.array([1,2,3,4,5,6,7,8,9])\n",
        "   \n",
        "   #2-D Slicing\n",
        "   arr3=np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])\n",
        "   \n",
        "   print(arr1[:3]) # default is taken as 0\n",
        "   print(arr1[0:3])\n",
        "   print(arr1[3:]) # taken till the end\n",
        "   print(arr1[::2])\n",
        "   \n",
        "   print(arr2[-4:-1])\n",
        "   print(arr2[::2]) # step size as 2\n",
        "   \n",
        "   # 2-D Slicing\n",
        "   print(arr3[1,1:4])\n",
        "   print(arr3[0:2, 2])\n",
        "   print(arr3[0:2, 1:4])"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['D' 'e' 'V']\n",
            "['D' 'e' 'V']\n",
            "['I' 'n' 'c' 'e' 'p' 't']\n",
            "['D' 'V' 'n' 'e' 't']\n",
            "[6 7 8]\n",
            "[1 3 5 7 9]\n",
            "[7 8 9]\n",
            "[3 8]\n",
            "[[2 3 4]\n",
            " [7 8 9]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_L6HWD5g-MiQ",
        "colab_type": "text"
      },
      "source": [
        "**All in One Example**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vcoa3e6o-MDc",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        },
        "outputId": "63bc86f2-7adf-4ede-e4ef-31720bdb48a2"
      },
      "source": [
        "   import numpy as np\n",
        "   data = np.array([1, 2, 3])\n",
        "   print(data[1])\n",
        "   print(data[0:2])\n",
        "   print(data[1:])\n",
        "   print(data[-2:])"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2\n",
            "[1 2]\n",
            "[2 3]\n",
            "[2 3]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qrTm0hIO-Vnp",
        "colab_type": "text"
      },
      "source": [
        "# **Numpy Functions**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "T_TIbFSy-bJm",
        "colab_type": "text"
      },
      "source": [
        "## **NumPy Array Shape**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1fYpP4eD-nJO",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "6f852d60-6104-492d-a6cf-cc564abf8644"
      },
      "source": [
        "   import numpy as np\n",
        "   arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])\n",
        "   arr1= np.array([1,2,3,4])\n",
        "\n",
        "   print(arr.shape)\n",
        "   print(arr1.shape)"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(2, 4)\n",
            "(4,)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DaqvlyT0-sil",
        "colab_type": "text"
      },
      "source": [
        "**All in One Example**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CMAx1fkN-v4x",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "c10ce9d0-a00a-4ab8-d14a-b05a179a8865"
      },
      "source": [
        "   array_example = np.array([[[0, 1, 2, 3],\n",
        "                            [4, 5, 6, 7]],\n",
        "\n",
        "                           [[0, 1, 2, 3],\n",
        "                            [4, 5, 6, 7]],\n",
        "\n",
        "                           [[0 ,1 ,2, 3],\n",
        "                            [4, 5, 6, 7]]])\n",
        " \n",
        "   print('No of dimensions of the array:',array_example.ndim)     # .ndim for dimensions\n",
        "   print('Total no of elements of the array:',array_example.size) # .size for size\n",
        "   print('Shape of the array:',array_example.shape)                # .shape for shape"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "No of dimensions of the array: 3\n",
            "Total no of elements of the array: 24\n",
            "Shape of the array: (3, 2, 4)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xS2Wz42v_pqo",
        "colab_type": "text"
      },
      "source": [
        "## **NumPy Array Reshaping**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8raKPv4__z7h",
        "colab_type": "text"
      },
      "source": [
        "**Reshape from 1-Dimensional to 2-Dimensional**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oam8dZQH_7-v",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 136
        },
        "outputId": "93264028-ed77-40d7-a213-e444d39f8bee"
      },
      "source": [
        "   import numpy as np\n",
        "   arr1 = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])\n",
        "   newarr1 = arr1.reshape(4, 3)\n",
        "   arr2 = np.array(['D','e','V','I','n','c','e','p','t'])\n",
        "   newarr2 = arr2.reshape(3,3)\n",
        "   print(newarr1)\n",
        "   print(newarr2)"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 1  2  3]\n",
            " [ 4  5  6]\n",
            " [ 7  8  9]\n",
            " [10 11 12]]\n",
            "[['D' 'e' 'V']\n",
            " ['I' 'n' 'c']\n",
            " ['e' 'p' 't']]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Mgk1bM2_AG-U",
        "colab_type": "text"
      },
      "source": [
        "**Reshape from 1-Dimensional to 3-Dimensional**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AMlf27XvAGLB",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 136
        },
        "outputId": "01d78258-528b-4721-fb7c-f5b0ae48d7b9"
      },
      "source": [
        "   import numpy as np\n",
        "   arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])\n",
        "   newarr = arr.reshape(2, 3, 2)\n",
        "   print(newarr)"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[[ 1  2]\n",
            "  [ 3  4]\n",
            "  [ 5  6]]\n",
            "\n",
            " [[ 7  8]\n",
            "  [ 9 10]\n",
            "  [11 12]]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oIfG5wuiARMw",
        "colab_type": "text"
      },
      "source": [
        "**Multi-Dimensional Array into 1-Dimensional Array**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mDfVsh4DAX9E",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "170f04ae-e332-47ff-d086-3907560fa22e"
      },
      "source": [
        "   import numpy as np\n",
        "   arr = np.array([[1, 2, 3], [4, 5, 6]])\n",
        "   newarr = arr.reshape(-1)\n",
        "   print(newarr)"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1 2 3 4 5 6]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HsOUztvfAeQG",
        "colab_type": "text"
      },
      "source": [
        "## **NumPy Sorting and Searching**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VYLW04h7AiPr",
        "colab_type": "text"
      },
      "source": [
        "### **NumPy Sorting**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yevX-WhxApT8",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        },
        "outputId": "7274deb1-68c9-4c14-cec1-8d6abd4dff9a"
      },
      "source": [
        "   import numpy as np\n",
        "   arr1 = np.array([3, 2, 0, 1])\n",
        "   arr2 = np.array(['red','blue','green'])\n",
        "   \n",
        "   # 2-D array\n",
        "   arr3 = np.array([[3, 2, 4], [5, 0, 1]])\n",
        "   \n",
        "   print(np.sort(arr1))\n",
        "   print(np.sort(arr2))\n",
        "   print(np.sort(arr3))"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0 1 2 3]\n",
            "['blue' 'green' 'red']\n",
            "[[2 3 4]\n",
            " [0 1 5]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oX7tR9X7AuVv",
        "colab_type": "text"
      },
      "source": [
        "### **NumPy Searching**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5m-s-Na4A2Cs",
        "colab_type": "text"
      },
      "source": [
        "**where() :**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wdbB1-ZwAxlY",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "dd3252fb-7c1c-48ef-96ee-2ac345e407fc"
      },
      "source": [
        "   import numpy as np\n",
        "   arr1 = np.array([1, 2, 3, 4, 5, 4, 4])\n",
        "   x = np.where(arr1 == 4)\n",
        "   y = np.where(arr1%2 == 0)\n",
        "   z = np.where(arr1%2 == 1)\n",
        "   print(x)\n",
        "   print(y)\n",
        "   print(z)"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(array([3, 5, 6]),)\n",
            "(array([1, 3, 5, 6]),)\n",
            "(array([0, 2, 4]),)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Fd5_Dqq4A5u3",
        "colab_type": "text"
      },
      "source": [
        "**searchsorted() :**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nAX3a2a4A4iW",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "0b7f2274-7249-4488-94b3-2ccd590fddf1"
      },
      "source": [
        "   import numpy as np\n",
        "   arr1 = np.array([6, 7, 8, 9])\n",
        "   x = np.searchsorted(arr1, 7)\n",
        "   print(x)\n",
        "   \n",
        "   # Multiple values\n",
        "   arr2 = np.array([1, 3, 5, 7])\n",
        "   y = np.searchsorted(arr2, [2, 4, 6])\n",
        "   print(y)"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "[1 2 3]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-e06TgWUBI9e",
        "colab_type": "text"
      },
      "source": [
        "## **Mean, Median, Mode**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qAb3kEOSBMtT",
        "colab_type": "text"
      },
      "source": [
        "### **Mean**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "afrWai0bBPyD",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "0117a3b1-541b-448c-f5c0-4c7a8bac6377"
      },
      "source": [
        "   import numpy as np\n",
        "   arr=np.array([19,13,18,21,44,17,12,31,37,8,12,27])\n",
        "   x=np.mean(arr)\n",
        "   print(x)"
      ],
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "21.583333333333332\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mEIDbq8nBULu",
        "colab_type": "text"
      },
      "source": [
        "### **Median**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8bFk1NsvBcEd",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "cbb4384b-d9df-4502-9b61-7ce503981ccc"
      },
      "source": [
        "   import numpy\n",
        "   # For one value in the middle\n",
        "   speed = [99,86,87,88,111,86,103,87,94,78,77,85,86]\n",
        "   x = numpy.median(speed)\n",
        "   print(x)\n",
        "   \n",
        "   # For two values in the middle\n",
        "   speed1 = [99,86,87,88,86,103,87,94,78,77,85,86]\n",
        "   y = numpy.median(speed1)\n",
        "   print(y)"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "87.0\n",
            "86.5\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SFjFWDmrBgZD",
        "colab_type": "text"
      },
      "source": [
        "### **Mode**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_US_V68hBmou",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "0b4b566e-b264-47a7-e4a8-bf07582d3903"
      },
      "source": [
        "   from scipy import stats\n",
        "   speed = [99,86,87,88,111,86,103,87,94,78,77,85,86]\n",
        "   x = stats.mode(speed)\n",
        "   print(x)"
      ],
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "ModeResult(mode=array([86]), count=array([3]))\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gExfQdSiBuxX",
        "colab_type": "text"
      },
      "source": [
        "## **Standard Deviation (σ)**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "t43odpbmB1zQ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "f236a788-bfd6-417b-f18b-0032f0af7e6a"
      },
      "source": [
        "   import numpy\n",
        "   speed = [86,87,88,86,87,85,86]\n",
        "   x = numpy.std(speed)\n",
        "   print(x)\n",
        "   \n",
        "   speed1 = [32,111,138,28,59,77,97]\n",
        "   y = numpy.std(speed1)\n",
        "   print(y)"
      ],
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0.9035079029052513\n",
            "37.84501153334721\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qq6_PKnWB65t",
        "colab_type": "text"
      },
      "source": [
        "# **Practice all you want and play with the code as much as you want..**\n"
      ]
    }
  ]
}