8_Statistical Calculation.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "shortlist = [1, 2, 3]\n",
    "print(sum(shortlist))\n",
    "\n",
    "print(len(shortlist))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0\n",
      "Harendra\n"
     ]
    }
   ],
   "source": [
    "# calculat mean\n",
    "def calculatemean(numbers):\n",
    "    s= sum(numbers)\n",
    "    l = len(numbers)\n",
    "    return s/l\n",
    "\n",
    "if __name__==\"__main__\":\n",
    "    print(calculatemean(shortlist))\n",
    "    print(\"Harendra\")\n",
    "else:\n",
    "    print(\"hello\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 4, 9, 15]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# median\n",
    "samplelist = [4,9,15,4]\n",
    "samplelist.sort()\n",
    "samplelist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1 = [1,2,3,4,5]\n",
    "calculatemean(list1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Median donation over the last 12 days is 500.0\n"
     ]
    }
   ],
   "source": [
    "def calculate_median(numbers):\n",
    "    N = len(numbers)\n",
    "    numbers.sort()\n",
    "    # Find the median\n",
    "    if N % 2 == 0:\n",
    "        # if N is even\n",
    "        m1 = N/2\n",
    "        m2 = (N/2) + 1\n",
    "        # Convert to integer, match position\n",
    "        m1 = int(m1) - 1\n",
    "        m2 = int(m2) - 1\n",
    "        median = (numbers[m1] + numbers[m2])/2\n",
    "    else:\n",
    "        m = (N+1)/2\n",
    "        # Convert to integer, match position\n",
    "        m = int(m) - 1\n",
    "        median = numbers[m]\n",
    "    return median\n",
    "if __name__ == '__main__':\n",
    "    donations = [100, 60, 70, 900, 100, 200, 500, 500, 503, 600, 1000, 1200]\n",
    "    median = calculate_median(donations)\n",
    "    N = len(donations)\n",
    "    print('Median donation over the last {0} days is {1}'.format(N, median))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(4, 2), (2, 1), (1, 1), (3, 1)]\n",
      "(1, 1)\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "# Finding the Mode and Creating a Frequency Table\n",
    "# creating frequenc list\n",
    "simplelist = [4, 2, 1, 3, 4]\n",
    "from collections import Counter\n",
    "c = Counter(simplelist)\n",
    "num = c.most_common()\n",
    "print(num)\n",
    "print(num[2])\n",
    "print(num[0][1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'collections.Counter'>\n",
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "print(type(c))\n",
    "print(type(num))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(4, 2)]\n",
      "[(4, 2), (2, 1)]\n"
     ]
    }
   ],
   "source": [
    "print(c.most_common(1))\n",
    "print(c.most_common(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(4, 2)]\n",
      "[(4, 2), (3, 2)]\n"
     ]
    }
   ],
   "source": [
    "newlist = [4,3,5,5,3,4]\n",
    "b= Counter(newlist)\n",
    "print(b.most_common(1))  # for multimodal, firt come first one\n",
    "print(b.most_common(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "mode = c.most_common(1)\n",
    "print(mode[0][0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The mode(s) of the list of numbers are:\n",
      "5\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "# modes for multimodal data\n",
    "from collections import Counter\n",
    "def calculate_mode(numbers):\n",
    "    c = Counter(numbers)\n",
    "    numbers_freq = c.most_common()  # [(5,3),(4,3),(9,1),..]\n",
    "    max_count = numbers_freq[0][1]\n",
    "    modes = []\n",
    "    for num in numbers_freq:\n",
    "        if num[1] == max_count:\n",
    "            modes.append(num[0])\n",
    "    return modes\n",
    "if __name__ == '__main__':\n",
    "    scores = [5, 5, 5, 4, 4, 4, 9, 1, 3]\n",
    "    modes = calculate_mode(scores)\n",
    "    print('The mode(s) of the list of numbers are:')\n",
    "    for mode in modes:\n",
    "        print(mode)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number\tFrequency\n",
      "9\t5\n",
      "6\t3\n",
      "7\t2\n",
      "8\t2\n",
      "10\t2\n",
      "5\t2\n",
      "1\t2\n",
      "2\t1\n",
      "4\t1\n"
     ]
    }
   ],
   "source": [
    "# creating frequency list\n",
    "from collections import Counter\n",
    "def frequency_table(numbers):\n",
    "    table = Counter(numbers)\n",
    "    print('Number\\tFrequency')\n",
    "    for number in table.most_common():\n",
    "        print('{0}\\t{1}'.format(number[0], number[1]))\n",
    "if __name__=='__main__':\n",
    "    scores = [7, 8, 9, 2, 10, 9, 9, 9, 9, 4, 5, 6, 1, 5, 6, 7, 8, 6, 1, 10]\n",
    "    frequency_table(scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lowest: 60 Highest: 1200 Range: 1140\n"
     ]
    }
   ],
   "source": [
    "# Measuring the Dispersion\n",
    "def find_range(numbers):\n",
    "    lowest = min(numbers)\n",
    "    highest = max(numbers)\n",
    "    # Find the range\n",
    "    r = highest-lowest\n",
    "    return lowest, highest, r\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    donations = [100, 60, 70, 900, 100, 200, 500, 500, 503, 600, 1000, 1200]\n",
    "    lowest, highest, r = find_range(donations)\n",
    "    print('Lowest: {0} Highest: {1} Range: {2}'.format(lowest, highest, r))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The variance of the list of numbers is 141047.35416666666\n",
      "The standard deviation of the list of numbers is 375.5627166887931\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "Find the variance and standard deviation of a list of numbers\n",
    "'''\n",
    "def calculate_mean(numbers):\n",
    "    s = sum(numbers)\n",
    "    N = len(numbers)\n",
    "    # Calculate the mean\n",
    "    mean = s/N\n",
    "    return mean\n",
    "def find_differences(numbers):\n",
    "    # Find the mean\n",
    "    mean = calculate_mean(numbers)\n",
    "    # Find the differences from the mean\n",
    "    diff = []\n",
    "    for num in numbers:\n",
    "        diff.append(num-mean)\n",
    "    return diff\n",
    "def calculate_variance(numbers):\n",
    "    # Find the list of differences\n",
    "    diff = find_differences(numbers)\n",
    "    # Find the squared differences\n",
    "    squared_diff = []\n",
    "    for d in diff:\n",
    "        squared_diff.append(d**2)\n",
    "        # Find the variance\n",
    "    sum_squared_diff = sum(squared_diff)\n",
    "    variance = sum_squared_diff/len(numbers)\n",
    "    return variance\n",
    "if __name__ == '__main__':\n",
    "    donations = [100, 60, 70, 900, 100, 200, 500, 500, 503, 600, 1000, 1200]\n",
    "    variance = calculate_variance(donations)\n",
    "    print('The variance of the list of numbers is {0}'.format(variance))\n",
    "    std = variance**0.5\n",
    "    print('The standard deviation of the list of numbers is {0}'.format(std))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "477.75\n",
      "141047.35416666666\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "print(np.mean(donations))\n",
    "print(np.var(donations))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The variance of the list of numbers is 135.38888888888889\n",
      "The standard deviation of the list of numbers is 11.63567311713804\n"
     ]
    }
   ],
   "source": [
    "donation1= [382, 389, 377, 397, 396, 368, 369, 392, 398, 367, 393,396]\n",
    "variance1 = calculate_variance(donation1)\n",
    "print('The variance of the list of numbers is {0}'.format(variance))\n",
    "std1 = variance1**0.5\n",
    "print('The standard deviation of the list of numbers is {0}'.format(std))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "plt.plot([0.1, 0.2, 0.3, 0.4], [1,2,3,4], label='first plot')\n",
    "plt.plot([0.1, 0.2, 0.3, 0.4], [1,2,8,16],label='second plot')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot([1,2,3,4,12,15],'g*', [1,4,9,16], 'ro')    #g* green star,  ro  = red 0\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculating the Correlation Between Two Data Sets\n",
    "def find_corr_x_y(x,y):\n",
    "    n = len(x)\n",
    "    # Find the sum of the products\n",
    "    prod = []\n",
    "    for xi,yi in zip(x,y):\n",
    "        prod.append(xi*yi)\n",
    "    \n",
    "    sum_prod_x_y = sum(prod)\n",
    "    sum_x = sum(x)\n",
    "    sum_y = sum(y)\n",
    "    squared_sum_x = sum_x**2\n",
    "    squared_sum_y = sum_y**2\n",
    "    x_square = []\n",
    "    \n",
    "    for xi in x:\n",
    "        x_square.append(xi**2)\n",
    "    # Find the sum\n",
    "    x_square_sum = sum(x_square)\n",
    "    y_square=[]\n",
    "    \n",
    "    for yi in y:\n",
    "        y_square.append(yi**2)\n",
    "   \n",
    "    # Find the sum\n",
    "    y_square_sum = sum(y_square)\n",
    "    \n",
    "    # Use formula to calculate correlation\n",
    "    numerator = n*sum_prod_x_y - sum_x*sum_y\n",
    "    denominator_term1 = n*x_square_sum - squared_sum_x\n",
    "    denominator_term2 = n*y_square_sum - squared_sum_y\n",
    "    denominator = (denominator_term1*denominator_term2)**0.5\n",
    "    correlation = numerator/denominator\n",
    "\n",
    "    return correlation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9953243433267447\n"
     ]
    }
   ],
   "source": [
    "x = [1,3,4,6,79]\n",
    "y = [7,7,2,5,84]\n",
    "print(find_corr_x_y(x,y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x251a6c8ba8>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(x,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x251b7b8ba8>,\n",
       " <matplotlib.lines.Line2D at 0x251b7b8cf8>]"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(x,'g*',y,'bo') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x1 = [1,2,3,4,5]\n",
    "y1 = [3,6,4,8,9]\n",
    "x2 = [25,30,35,40,45]\n",
    "y2 = [4,7,2,7,8]\n",
    "plt.scatter(x1,y1)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum of the numbers: 5733.0\n"
     ]
    }
   ],
   "source": [
    "# Reading Data from Files\n",
    "def sum_data(filename):\n",
    "    s = 0\n",
    "    with open(filename) as f:\n",
    "        for line in f:\n",
    "            s = s + float(line)\n",
    "    print('Sum of the numbers: {0}'.format(s))\n",
    "if __name__ == '__main__':\n",
    "    sum_data('mytext.txt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEKCAYAAAAIO8L1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAF9BJREFUeJzt3X2QZXWd3/H3hxlE4tOANCzMTDIsjviw0YFtHiqYiGAWZC0HE6mwZRbKkBq1WALqIuBWsloVq1hZxViVkB1FZ4iu7kQRJi6KhAddtwLYwMiDODIr6DyFaYOgLiPLwDd/3NN6GU533xnm9O1m3q+qW/ec3/md0987cPvT53eeUlVIkrSzfYZdgCRpdjIgJEmtDAhJUisDQpLUyoCQJLUyICRJrQwISVIrA0KS1KrTgEjyUJJ7kqxLMta0HZjkhiQPNO8HNO1J8qkkG5LcneToLmuTJE0tXV5JneQhYLSqftrX9jHgkaq6NMnFwAFVdVGS04DzgNOA44D/UlXHTbX9gw46qJYsWdJZ/ZL0fHTHHXf8tKpGpus3fyaK2cly4MRmejVwC3BR035V9RLr1iQLkhxaVVsn29CSJUsYGxvruFxJen5J8uNB+nV9DKKAbya5I8mKpu2QiV/6zfvBTftCYGPfupuatmdIsiLJWJKx8fHxDkuXpL1b13sQJ1TVliQHAzck+cEUfdPS9qzxr6paCawEGB0d9U6DktSRTvcgqmpL874N+CpwLPBwkkMBmvdtTfdNwOK+1RcBW7qsT5I0uc4CIsmLkrxkYhr4PeBeYC1wdtPtbODaZnotcFZzNtPxwGNTHX+QJHWryyGmQ4CvJpn4OX9ZVd9I8l1gTZJzgJ8AZzT9r6N3BtMG4HHgXR3WJkmaRmcBUVU/Al7f0v7/gJNb2gs4t6t6JOn54Jq7NnPZ9evZ8uh2DluwPxeeciSnH/Ws83n2iGGc5ipJ2g3X3LWZS66+h+1PPgXA5ke3c8nV9wB0EhLeakOS5ojLrl//63CYsP3Jp7js+vWd/DwDQpLmiC2Pbt+l9ufKgJCkOeKwBfvvUvtzZUBI0hxx4SlHsv++857Rtv++87jwlCM7+XkepJakOWLiQLRnMUmSnuX0oxZ2Fgg7c4hJktTKgJAktTIgJEmtDAhJUisDQpLUyoCQJLUyICRJrQwISVKrzgMiybwkdyX5WjO/KsmDSdY1r2VNe5J8KsmGJHcnObrr2iRJk5uJK6nPB+4HXtrXdmFVfXmnfm8Bljav44ArmndJ0hB0ugeRZBHw+8BnBui+HLiqem4FFiQ5tMv6JEmT63qI6ZPAB4Gnd2r/aDOMdHmS/Zq2hcDGvj6bmjZJ0hB0FhBJ3gpsq6o7dlp0CfAq4BjgQOCiiVVaNlMt212RZCzJ2Pj4+J4sWZLUp8s9iBOAtyV5CPgScFKSz1fV1mYY6Qngc8CxTf9NwOK+9RcBW3beaFWtrKrRqhodGRnpsHxJ2rt1FhBVdUlVLaqqJcCZwE1V9W8njiskCXA6cG+zylrgrOZspuOBx6pqa1f1SZKmNoznQXwhyQi9IaV1wHua9uuA04ANwOPAu4ZQmySpMSMBUVW3ALc00ydN0qeAc2eiHknS9LySWpLUyoCQJLUyICRJrQwISVIrA0KS1MqAkCS1MiAkSa0MCElSKwNCktTKgJAktTIgJEmtDAhJUisDQpLUyoCQJLUyICRJrQwISVKrzgMiybwkdyX5WjN/eJLbkjyQ5K+SvKBp36+Z39AsX9J1bZKkyc3EHsT5wP19838GXF5VS4GfAec07ecAP6uqVwCXN/0kSUPSaUAkWQT8PvCZZj7AScCXmy6rgdOb6eXNPM3yk5v+kqQh6HoP4pPAB4Gnm/mXA49W1Y5mfhOwsJleCGwEaJY/1vR/hiQrkowlGRsfH++ydknaq3UWEEneCmyrqjv6m1u61gDLftNQtbKqRqtqdGRkZA9UKklqM7/DbZ8AvC3JacALgZfS26NYkGR+s5ewCNjS9N8ELAY2JZkPvAx4pMP6JElT6GwPoqouqapFVbUEOBO4qareCdwMvKPpdjZwbTO9tpmnWX5TVT1rD0KSNDOGcR3ERcD7k2ygd4zhyqb9SuDlTfv7gYuHUJskqdHlENOvVdUtwC3N9I+AY1v6/Ao4YybqkSRNzyupJUmtDAhJUisDQpLUyoCQJLUyICRJrQwISVIrA0KS1MqAkCS1MiAkSa0MCElSKwNCktTKgJAktTIgJEmtDAhJUisDQpLUqstnUr8wye1JvpfkviQfadpXJXkwybrmtaxpT5JPJdmQ5O4kR3dVmyRpel0+MOgJ4KSq+mWSfYHvJPl6s+zCqvryTv3fAixtXscBVzTvkqQh6PKZ1FVVv2xm921eUz1jejlwVbPercCCJId2VZ8kaWqdHoNIMi/JOmAbcENV3dYs+mgzjHR5kv2atoXAxr7VNzVtkqQh6DQgquqpqloGLAKOTfI7wCXAq4BjgAOBi5ruadvEzg1JViQZSzI2Pj7eUeWSpBk5i6mqHgVuAU6tqq3NMNITwOeAY5tum4DFfastAra0bGtlVY1W1ejIyEjHlUvS3qvLs5hGkixopvcH3gz8YOK4QpIApwP3NqusBc5qzmY6HnisqrZ2VZ8kaWpdnsV0KLA6yTx6QbSmqr6W5KYkI/SGlNYB72n6XwecBmwAHgfe1WFtkqRpdBYQVXU3cFRL+0mT9C/g3K7qkSTtGq+kliS1MiAkSa0MCElSKwNCktTKgJAktTIgJEmtDAhJUisDQpLUyoCQJLUyICRJrQwISVIrA0KS1MqAkCS1GiggkhyS5MokX2/mX5PknG5LkyQN06B7EKuA64HDmvkfAhd0UZAkaXYYNCAOqqo1wNMAVbUDeKqzqiRJQzdoQPx9kpcDBTDxSNCpVkjywiS3J/lekvuSfKRpPzzJbUkeSPJXSV7QtO/XzG9oli/Z7U8lSXrOBg2I99N7ZvQRSf4WuAo4b5p1ngBOqqrXA8uAU5tg+TPg8qpaCvwMmDiWcQ7ws6p6BXB500+SNCTTBkSSfYAXAm8E/hnwbuC1zSNFJ1U9v2xm921eBZwEfLlpXw2c3kwvb+Zplp+cJIN/FEnSnjRtQFTV08DHq2pHVd1XVfdW1ZODbDzJvCTrgG3ADcDfAY82xzAANgELm+mFwMbmZ+6gN4T18pZtrkgylmRsfHx8kDIkSbth0CGmbyb517v6F31VPVVVy4BFwLHAq9u6Ne9t265nNVStrKrRqhodGRnZlXIkSbtg/oD93g+8CNiR5Ff0fplXVb10kJWr6tEktwDHAwuSzG/2EhYBW5pum4DFwKYk84GXAY8M/EkkSXvUQHsQVfWSqtqnql5QVS9t5qcMhyQjSRY00/sDbwbuB24G3tF0Oxu4tple28zTLL+pqp61ByFJmhmD7kGQ5ABgKb0D1gBU1benWOVQYHWSefSCaE1VfS3J94EvJfnPwF3AlU3/K4H/kWQDvT2HM3fpk0iS9qiBAiLJvwfOpzcktI7eUNH/oXdGUqvmLKejWtp/RO94xM7tvwLOGKhqSVLnBj1IfT5wDPDjqnoTvV/8nkIkSc9jgwbEr5q/8EmyX1X9ADiyu7IkScM26DGITc0B52uAG5L8jN+cfSRJeh4aKCCq6u3N5IeT3EzvFNRvdFaVJGnoBj1I/Y/7Zh9s3n8L+Mker0iSNCsMOsT01/Suag6901wPB9YDr+2oLknSkA06xPRP++eTHE3vpn2SpOep3XomdVXdSe+0V0nS89SgxyDe3ze7D3A0XgchSc9rgx6DeEnf9A56xyS+sufLkSTNFoMeg/hI14VIkmaXQYeY1k61vKretmfKkSTNFoMOMT1I77qHzzfzfwA8BFzfQU2SpFlg0IA4qqr+Rd/8/0ry7ar6UBdFSZKGb9DTXEeS/PbETJLDAZ/3KUnPY4MGxPuAW5Lc0tyL6WbggqlWSLI4yc1J7k9yX5Lzm/YPJ9mcZF3zOq1vnUuSbEiyPskpu/uhJEnP3ZRDTEmOATZW1TeSLAXeA5wMfBP47jTb3gF8oKruTPIS4I4kNzTLLq+qP9/pZ72G3lPkXgscBvzvJK+sqqd2+VNJkp6z6fYg/gL4h2b6OOAiYDXwMLByqhWramtzxTVV9Qt6z6NeOMUqy4EvVdUTVfUgsIGWJ89JkmbGdAExr6oeaab/DbCyqr5SVf8ReMWgPyTJEnpPobutafqjJHcn+WzzrGvohcfGvtU2MXWgSJI6NG1AJJkYhjoZuKlv2aDXULyY3lXXF1TVz4ErgCOAZcBW4OMTXVtWr5btrUgylmRsfNy7fUhSV6YLiC8C30pyLbAd+BuAJK8AHptu40n2pRcOX6iqqwGq6uGqeqqqngY+zW+GkTYBi/tWX0TLU+uqamVVjVbV6MiIJ1JJUlemDIiq+ijwAWAV8IaqmviLfh/gvKnWTRLgSuD+qvpEX/uhfd3eDtzbTK8FzkyyX3Ma7VLg9sE/iiRpT5p2mKiqbm1p++EA2z4B+EPgniTrmrYPAX+QZBm94aOHaJ4rUVX3JVkDfJ/eGVDnegaTJA3PoFdS77Kq+g7txxWum2KdjwIf7aomSdLgduuBQZKk5z8DQpLUyoCQJLUyICRJrQwISVIrA0KS1MqAkCS1MiAkSa0MCElSKwNCktTKgJAktTIgJEmtDAhJUisDQpLUyoCQJLUyICRJrToLiCSLk9yc5P4k9yU5v2k/MMkNSR5o3g9o2pPkU0k2JLk7ydFd1SZJml6XexA7gA9U1auB44Fzk7wGuBi4saqWAjc28wBvofcc6qXACuCKDmuTJE2js4Coqq1VdWcz/QvgfmAhsBxY3XRbDZzeTC8HrqqeW4EFSQ7tqj5J0tRm5BhEkiXAUcBtwCFVtRV6IQIc3HRbCGzsW21T0yZJGoLOAyLJi4GvABdU1c+n6trSVi3bW5FkLMnY+Pj4nipTkrSTTgMiyb70wuELVXV10/zwxNBR876tad8ELO5bfRGwZedtVtXKqhqtqtGRkZHuipekvVyXZzEFuBK4v6o+0bdoLXB2M302cG1f+1nN2UzHA49NDEVJkmbe/A63fQLwh8A9SdY1bR8CLgXWJDkH+AlwRrPsOuA0YAPwOPCuDmuTJE2js4Coqu/QflwB4OSW/gWc21U9kqRd45XUkqRWBoQkqZUBIUlqZUBIkloZEJKkVgaEJKmVASFJamVASJJaGRCSpFYGhCSplQEhSWplQEiSWhkQkqRWBoQkqZUBIUlq1eUT5T6bZFuSe/vaPpxkc5J1zeu0vmWXJNmQZH2SU7qqS5I0mC73IFYBp7a0X15Vy5rXdQBJXgOcCby2Wee/JZnXYW2SpGl0FhBV9W3gkQG7Lwe+VFVPVNWD9B47emxXtUmSpjeMYxB/lOTuZgjqgKZtIbCxr8+mpk2SNCQzHRBXAEcAy4CtwMeb9rZnV1fbBpKsSDKWZGx8fLybKiVJMxsQVfVwVT1VVU8Dn+Y3w0ibgMV9XRcBWybZxsqqGq2q0ZGRkW4LlqS92IwGRJJD+2bfDkyc4bQWODPJfkkOB5YCt89kbZKkZ5rf1YaTfBE4ETgoySbgT4ETkyyjN3z0EPBugKq6L8ka4PvADuDcqnqqq9okSdNLVetQ/5wwOjpaY2Njwy5DkuaUJHdU1eh0/bySWpLUyoCQJLUyICRJrQwISVIrA0KS1MqAkCS1MiAkSa0MCElSKwNCktTKgJAktTIgJEmtDAhJUisDQpLUyoCQJLUyICRJrQwISVKrzgIiyWeTbEtyb1/bgUluSPJA835A054kn0qyIcndSY7uqi5J0mC63INYBZy6U9vFwI1VtRS4sZkHeAu951AvBVYAV3RYV6euuWszJ1x6E4df/NeccOlNXHPX5mGXJEm7pbOAqKpvA4/s1LwcWN1MrwZO72u/qnpuBRYkObSr2rpyzV2bueTqe9j86HYK2Pzodi65+h5DQtKcNNPHIA6pqq0AzfvBTftCYGNfv01N25xy2fXr2f7kU89o2/7kU1x2/fohVSRJu2+2HKROS1u1dkxWJBlLMjY+Pt5xWbtmy6Pbd6ldkmazmQ6IhyeGjpr3bU37JmBxX79FwJa2DVTVyqoararRkZGRTovdVYct2H+X2iVpNpvpgFgLnN1Mnw1c29d+VnM20/HAYxNDUXPJhaccyf77zntG2/77zuPCU44cUkWStPvmd7XhJF8ETgQOSrIJ+FPgUmBNknOAnwBnNN2vA04DNgCPA+/qqq4unX5U77DJZdevZ8uj2zlswf5ceMqRv26XpLkkVa1D/XPC6OhojY2NDbsMSZpTktxRVaPT9ZstB6klSbNMZ0NMs9k1d212GEiSprHXBcTExWwT1ytMXMwGGBKS1GevG2LyYjZJGsxeFxBezCZJg9nrAsKL2SRpMHtdQHgxmyQNZq87SO3FbJI0mL0uIKAXEgaCJE1trxtikiQNxoCQJLUyICRJrQwISVIrA0KS1GpO3+47yTjw42HXMYmDgJ8Ou4jdZO0zb67WDdY+LM+l9n9SVdM+knNOB8RslmRskPutz0bWPvPmat1g7cMyE7U7xCRJamVASJJaGRDdWTnsAp4Da595c7VusPZh6bx2j0FIklq5ByFJamVA7AFJPptkW5J7+9oOTHJDkgea9wOGWeNkJqn9siQ/SHJ3kq8mWTDMGtu01d237I+TVJKDhlHbdCarPcl5SdYnuS/Jx4ZV31Qm+f9lWZJbk6xLMpbk2GHW2CbJ4iQ3J7m/+fc9v2mf9d/TKWrv/HtqQOwZq4BTd2q7GLixqpYCNzbzs9Eqnl37DcDvVNXrgB8Cl8x0UQNYxbPrJsli4F8CP5npgnbBKnaqPcmbgOXA66rqtcCfD6GuQazi2f/uHwM+UlXLgP/UzM82O4APVNWrgeOBc5O8hrnxPZ2s9s6/pwbEHlBV3wYe2al5ObC6mV4NnD6jRQ2orfaq+mZV7WhmbwUWzXhh05jk3xzgcuCDwKw9uDZJ7e8FLq2qJ5o+22a8sAFMUnsBL22mXwZsmdGiBlBVW6vqzmb6F8D9wELmwPd0stpn4ntqQHTnkKraCr3/wMDBQ65nd/074OvDLmIQSd4GbK6q7w27lt3wSuCfJ7ktybeSHDPsgnbBBcBlSTbS2/OZjXucv5ZkCXAUcBtz7Hu6U+39OvmeGhCaVJI/obd7+4Vh1zKdJP8I+BN6Qxxz0XzgAHpDCBcCa5JkuCUN7L3A+6pqMfA+4Moh1zOpJC8GvgJcUFU/H3Y9u2Ky2rv8nhoQ3Xk4yaEAzfusHDKYTJKzgbcC76y5cS70EcDhwPeSPERvd/vOJL811KoGtwm4unpuB56md6+dueBs4Opm+n8Cs+4gNUCSfen9gv1CVU3UOye+p5PU3vn31IDozlp6Xxya92uHWMsuSXIqcBHwtqp6fNj1DKKq7qmqg6tqSVUtofcL9+iq+r9DLm1Q1wAnASR5JfAC5s5N5LYAb2ymTwIeGGItrZq9sSuB+6vqE32LZv33dLLaZ+R7WlW+nuML+CKwFXiS3i+mc4CX0zsr4oHm/cBh17kLtW8ANgLrmtd/H3adg9S90/KHgIOGXecu/Ju/APg8cC9wJ3DSsOvchdrfANwBfI/e2PjvDrvOlrrfQO9g+t19/1+fNhe+p1PU3vn31CupJUmtHGKSJLUyICRJrQwISVIrA0KS1MqAkCS1MiCkPs1dYD/eN//HST68h7a9Ksk79sS2pJlgQEjP9ATwr2bbrcKTzBt2Ddr7GBDSM+2g9yjH9+28YOc9gCS/bN5PbG6wtybJD5NcmuSdSW5Pck+SI/o28+Ykf9P0e2uz/rzm3v7fbe7t/+6+7d6c5C+Be7r80FKb+cMuQJqF/itw9y4+tOf1wKvp3Qr7R8BnqurY5uEu59G74ynAEnq3pTgCuDnJK4CzgMeq6pgk+wF/m+SbTf9j6d3z/8Hn+qGkXWVASDupqp8nuQr4D8D2AVf7bjW3jU7yd8DEL/h7gDf19VtTVU8DDyT5EfAq4PeA1/XtnbwMWAr8A3C74aBhMSCkdp+kd0+kz/W17aAZlm1uoPaCvmVP9E0/3Tf/NM/8nu18b5sCApxXVdf3L0hyIvD3u1e+9Nx5DEJqUVWPAGvo3YxuwkPA7zbTy4F9d2PTZyTZpzku8dvAeuB64L3NLZ1J8sokL9rd2qU9xYCQJvdxnvlMhk8Db0xyO3Acu/fX/XrgW/Se/vWeqvoV8Bng+/SeX3Ev8Be4d69ZwLu5SpJauQchSWplQEiSWhkQkqRWBoQkqZUBIUlqZUBIkloZEJKkVgaEJKnV/wfLySnvM4oVJQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Reading Data from a CSV File\n",
    "import csv\n",
    "import matplotlib.pyplot as plt\n",
    "def scatter_plot(x, y):\n",
    "    plt.scatter(x, y)\n",
    "    plt.xlabel('Number')\n",
    "    plt.ylabel('Square')\n",
    "    plt.show()\n",
    "def read_csv(filename):\n",
    "    numbers = []\n",
    "    squared = []\n",
    "    with open(filename) as f:\n",
    "        reader = csv.reader(f)\n",
    "        next(reader)\n",
    "        for row in reader:\n",
    "            numbers.append(int(row[0]))\n",
    "            squared.append(int(row[1]))\n",
    "        return numbers, squared\n",
    "if __name__ == '__main__':\n",
    "    numbers, squared = read_csv('numbers.csv')\n",
    "    scatter_plot(numbers, squared)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating a Grouped Frequency Table\n",
    "def create_classes(numbers, n): # 1,2,4,9\n",
    "    low = min(numbers)   # 1\n",
    "    high = max(numbers)  # 10\n",
    "    # Width of each class\n",
    "    width = (high - low)/n  #(9-1)/4 ,2  no of classes = 2, w =4\n",
    "    classes = []\n",
    "    a = low  # 1\n",
    "    b = low + width   # 1+4 = 5\n",
    "    classes = []\n",
    "    while a < (high-width):\n",
    "        classes.append((a, b))\n",
    "        a = b\n",
    "        b = a + width\n",
    "# The last class may be of a size that is less than width\n",
    "    classes.append((a, high+1))\n",
    "    return classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(1, 5.5), (5.5, 11)]\n",
      "Number\tFrequency\n",
      "(1, 5.5)\t1\n",
      "(5.5, 11)\t1\n"
     ]
    }
   ],
   "source": [
    "from collections import Counter\n",
    "def frequency_table(numb,num):\n",
    "    table = Counter(numb)\n",
    "    print('Number\\tFrequency')\n",
    "    for number in table.most_common():\n",
    "        print('{0}\\t{1}'.format(number[0], number[1]))\n",
    "if __name__=='__main__':\n",
    "    num = [7, 8, 9, 2, 10, 9, 9, 9, 9, 4, 5, 6, 1, 5, 6, 7, 8, 6, 1, 10]\n",
    "    scores = create_classes(num,2) \n",
    "    print(scores)\n",
    "    frequency_table(scores,num)   # incomplete hai"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}