module2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic Descriptive Statistics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mean, Median, and Mode"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean value of 12 awards is $477.75\n"
     ]
    }
   ],
   "source": [
    "# Calculating the mean of a list\n",
    "\n",
    "import matplotlib\n",
    "\n",
    "def calculate_mean(nums):\n",
    "    s = sum(nums)\n",
    "    N = len(nums)\n",
    "    mean = s/N\n",
    "    return mean\n",
    "\n",
    "awards = [100, 60, 70, 900, 100, 200, 500, 500, 503, 600, 1000, 1200]\n",
    "mean = calculate_mean(awards)\n",
    "N = len(awards)\n",
    "print('Mean value of {} awards is ${}'.format(N, mean))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[109, 120, 126, 135, 136, 149, 157, 158, 170, 175, 184, 190]\n",
      "Median of 12 values is 153.0\n"
     ]
    }
   ],
   "source": [
    "# Calculating the median of a list\n",
    "\n",
    "import random as r\n",
    "\n",
    "def calculate_median(nums):\n",
    "    N = len(nums)\n",
    "    nums.sort()\n",
    "\n",
    "    if N % 2 == 1:\n",
    "        median = nums[N // 2]\n",
    "    else:\n",
    "        median = (nums[N // 2 - 1] + nums[N // 2]) / 2\n",
    "    return median\n",
    "\n",
    "# generate random integer from 10-25 inclusive for list size\n",
    "N = r.randint(10,25)\n",
    "# generate list of N random ints from 100-200 \n",
    "vals = [r.randint(100,200) for x in range(N)]\n",
    "\n",
    "median = calculate_median(vals)\n",
    "print(vals)\n",
    "print('Median of {0} values is {1}'.format(N, median))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The median is 151\n"
     ]
    }
   ],
   "source": [
    "# Calculating median using statistics module\n",
    "\n",
    "import statistics as stat\n",
    "\n",
    "med = stat.median(vals)\n",
    "print('The median is',med)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(4, 2)]\n",
      "(4, 2)\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "# Calculating the mode of a list\n",
    "\n",
    "mylist = [4, 2, 1, 3, 4]\n",
    "from collections import Counter\n",
    "c = Counter(mylist)\n",
    "mode = c.most_common(1)\n",
    "print(mode)\n",
    "print(mode[0])\n",
    "print(mode[0][0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The mode of the list of numbers is: 9\n"
     ]
    }
   ],
   "source": [
    "# Calculating the mode\n",
    "\n",
    "from collections import Counter\n",
    "def calculate_mode(numbers):\n",
    "    c = Counter(numbers)\n",
    "    mode = c.most_common(1)\n",
    "    return mode[0][0]\n",
    "\n",
    "scores = [7,8,9,2,10,9,9,9,9,4,5,6,1,5,6,7,8,6,1,10]\n",
    "mode = calculate_mode(scores)\n",
    "print('The mode of the list of numbers is: {0}'.format(mode))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The mode(s) of the list of numbers are:\n",
      "5\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "# Calculating the mode when the list of numbers may have multiple modes\n",
    "\n",
    "from collections import Counter\n",
    "def calculate_mode(numbers):\n",
    "    c = Counter(numbers)\n",
    "    numbers_freq = c.most_common()\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",
    "\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)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Develop and Plot Frequency Table"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "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"
     ]
    },
    {
     "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": [
    "# Frequency table for a list of numbers\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "from collections import Counter\n",
    "def frequency_table(numbers):\n",
    "    table = Counter(numbers)\n",
    "    freq = table.most_common()\n",
    "    print('Number\\tFrequency')\n",
    "    for number in freq:\n",
    "        print('{0}\\t{1}'.format(number[0], number[1]))\n",
    "    return freq\n",
    "\n",
    "scores = [7, 8, 9, 2, 10, 9, 9, 9, 9, 4, 5, 6, 1, 5, 6, 7, 8, 6, 1, 10]\n",
    "tab = frequency_table(scores)\n",
    "\n",
    "plt.bar(*zip(*tab))\n",
    "plt.title('Frequency Table')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number\tFrequency\n",
      "1\t2\n",
      "2\t1\n",
      "4\t1\n",
      "5\t2\n",
      "6\t3\n",
      "7\t2\n",
      "8\t2\n",
      "9\t5\n",
      "10\t2\n"
     ]
    }
   ],
   "source": [
    "# Frequency table for a list of numbers\n",
    "# Enhanced to display the table sorted by the numbers\n",
    "\n",
    "from collections import Counter\n",
    "def frequency_table(numbers):\n",
    "    table = Counter(numbers)\n",
    "    numbers_freq = table.most_common()\n",
    "    numbers_freq.sort()\n",
    "\n",
    "    print('Number\\tFrequency')\n",
    "    for number in numbers_freq:\n",
    "        print('{0}\\t{1}'.format(number[0], number[1]))\n",
    "\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": "markdown",
   "metadata": {},
   "source": [
    "### Range, Variance, and Standard Deviation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lowest: 60 Highest: 1200 Range: 1140\n"
     ]
    }
   ],
   "source": [
    "# Find the range\n",
    "\n",
    "def find_range(numbers):\n",
    "    lowest = min(numbers)\n",
    "    highest = max(numbers)\n",
    "\n",
    "    r = highest-lowest\n",
    "    return lowest, highest, r\n",
    "\n",
    "nums = [100, 60, 70, 900, 100, 200, 500, 500, 503, 600, 1000, 1200]\n",
    "lowest, highest, r = find_range(nums)\n",
    "print('Lowest: {0} Highest: {1} Range: {2}'.format(lowest, highest, r))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lowest: 60 Highest: 1200 Range: 1140\n"
     ]
    }
   ],
   "source": [
    "# Find the range by returning a dictionary\n",
    "\n",
    "def find_range(numbers):\n",
    "    lowest = min(numbers)\n",
    "    highest = max(numbers)\n",
    "    r = highest-lowest\n",
    "    return {'lowest':lowest, 'highest':highest, 'range':r}\n",
    "\n",
    "nums = [100, 60, 70, 900, 100, 200, 500, 500, 503, 600, 1000, 1200]\n",
    "ans = find_range(nums)\n",
    "print('Lowest: {0} Highest: {1} Range: {2}'.format(ans['lowest'], ans['highest'], ans['range']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The mean is 69.26666666666667\n",
      "[91, 80, 53, 98, 77, 65, 90, 57, 93, 58, 81, 83, 95, 57, 75, 86, 63, 49, 85, 41, 49, 87, 70, 54, 42, 41, 98, 70, 48, 42]\n",
      "The variance of the list of numbers is 349.92888888888893\n",
      "The standard deviation of the list is 18.706386312938395\n"
     ]
    }
   ],
   "source": [
    "# Find the variance and standard deviation of a list of numbers\n",
    "\n",
    "import random as r\n",
    "\n",
    "def calculate_mean(numbers):\n",
    "    s = sum(numbers)\n",
    "    N = len(numbers)\n",
    "    mean = s/N\n",
    "    return mean\n",
    "\n",
    "def find_diffs(numbers):\n",
    "    mean = calculate_mean(numbers)\n",
    "    diffs = []\n",
    "    for num in numbers:\n",
    "        diffs.append(num - mean)\n",
    "    return diffs\n",
    "\n",
    "def calculate_variance(numbers):\n",
    "    diffs = find_diffs(numbers)\n",
    "    squared_diffs = [d ** 2 for d in diffs]\n",
    "    sum_squared_diffs = sum(squared_diffs)\n",
    "    variance = sum_squared_diffs / len(numbers)\n",
    "    return variance\n",
    "\n",
    "# generate list of 30 random ints between 40-100, inclusive\n",
    "nums = [r.randint(40,100) for n in range(30)]\n",
    "print('The mean is',calculate_mean(nums))\n",
    "print(nums)\n",
    "\n",
    "variance = calculate_variance(nums)\n",
    "print('The variance of the list of numbers is {0}'.format(variance))\n",
    "std_dev = variance ** 0.5\n",
    "print('The standard deviation of the list is {0}'.format(std_dev))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Random data, 100 values\n",
      " [87, 99, 99, 74, 87, 89, 61, 99, 67, 79, 79, 95, 96, 94, 64, 85, 69, 77, 69, 91, 67, 73, 80, 81, 60, 100, 89, 94, 93, 91, 65, 93, 95, 75, 89, 95, 75, 100, 68, 80, 68, 65, 97, 77, 85, 67, 89, 66, 94, 83, 73, 70, 72, 99, 89, 75, 100, 65, 85, 79, 84, 93, 63, 64, 69, 70, 70, 93, 61, 72, 86, 90, 72, 98, 84, 92, 99, 70, 66, 100, 79, 77, 86, 96, 64, 97, 78, 99, 98, 76, 77, 89, 88, 86, 99, 79, 71, 84, 60, 62]\n",
      "\n",
      "Variance is 151.389\n",
      "Standard deviation is 12.304\n",
      "\n",
      "Verifying using statistics module...\n",
      "Variance is 151.389\n",
      "Standard deviation is 12.304\n"
     ]
    }
   ],
   "source": [
    "# Another variance and standard deviation example\n",
    "# Uses several list comprehensions\n",
    "\n",
    "import random as r, statistics as st\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# generate random data (100 random integers from 60-100, inclusive)\n",
    "n = 100\n",
    "data = [r.randint(60,100) for x in range(n)]\n",
    "print('Random data, {} values\\n'.format(n),data)\n",
    "\n",
    "mu = sum(data) / n\n",
    "    \n",
    "diffs = [(x - mu)**2 for x in data]\n",
    "var = sum(diffs) / (n - 1)\n",
    "print('\\nVariance is {:.3f}'.format(var))\n",
    "\n",
    "stdev = var ** 0.5\n",
    "print('Standard deviation is {:.3f}'.format(stdev))\n",
    "\n",
    "print('\\nVerifying using statistics module...')\n",
    "print('Variance is {:.3f}'.format(st.variance(data)))\n",
    "print('Standard deviation is {:.3f}'.format(st.stdev(data)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 4\n",
      "2 5\n",
      "3 6\n"
     ]
    }
   ],
   "source": [
    "# How the zip() function works\n",
    "\n",
    "list_1 = [1, 2, 3]\n",
    "list_2 = [4, 5, 6]\n",
    "for x,y in zip(list_1,list_2):\n",
    "    print(x, y)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scatter Plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "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": [
    "# Creating a scatter plot\n",
    "x = [1, 2, 3, 4, 5]\n",
    "y = [2, 5, 3, 4, 6]\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "plt.scatter(x, y)\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum of the numbers: 21.0\n"
     ]
    }
   ],
   "source": [
    "# Find the sum of numbers stored in a file\n",
    "\n",
    "def sum_data(filename):\n",
    "    s = 0\n",
    "    with open(filename) as f:\n",
    "        for line in f:\n",
    "            s += float(line)\n",
    "    print('Sum of the numbers: {0}'.format(s))\n",
    "\n",
    "sum_data('mydata.txt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean: 3.5\n"
     ]
    }
   ],
   "source": [
    "# Calculate the mean of numbers stored in a file\n",
    "\n",
    "def read_data(filename):\n",
    "    numbers = []\n",
    "    with open(filename) as f:\n",
    "        for line in f:\n",
    "            numbers.append(float(line))\n",
    "    return numbers\n",
    "\n",
    "def calculate_mean(numbers):\n",
    "    s = sum(numbers)\n",
    "    N = len(numbers)\n",
    "    mean = s/N\n",
    "    return mean\n",
    "\n",
    "data = read_data('mydata.txt')\n",
    "mean = calculate_mean(data)\n",
    "print('Mean: {0}'.format(mean))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEGCAYAAACKB4k+AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAT10lEQVR4nO3df5Bd5X3f8ffHQrbXOPGCWTtoIRU2RE1q0oisbVJ3bGLcKnY9QaG4cSaNaYYObsdxwLQqlmc6dTrt4FRxnGYmQ0NMEkgdEwYUQaeJF8bGP5KpMQsiljFZQ2wMWlGQC4uNs44l8e0f9+xhkVarK2nvXu2979cMc895znPufg9ntJ+9z3PuOakqJEkCeFG/C5AknTgMBUlSy1CQJLUMBUlSy1CQJLVO6ncBx+O0006r9evX97sMSVpV7r333m9V1dhi21Z1KKxfv56pqal+lyFJq0qSbx5um8NHkqSWoSBJahkKkqSWoSBJahkKkqTWqr76SJKGzY6dM2ybnGbP7BzrRkfYsmkDmzeOL9v7GwqStErs2DnD1u27mNt3AICZ2Tm2bt8FsGzB4PCRJK0S2yan20CYN7fvANsmp5ftZxgKkrRK7JmdO6r2Y2EoSNIqsW505Kjaj4WhIEmrxJZNGxhZu+YFbSNr17Bl04Zl+xlONEvSKjE/mezVR5IkoBMMyxkCB3P4SJLUMhQkSS1DQZLUMhQkSS1DQZLUMhQkSS1DQZLUMhQkSS1DQZLUMhQkSS1DQZLUMhQkSS1DQZLUMhQkSS1DQZLU6mkoJPlAkgeSfCXJJ5O8NMlZSe5O8lCSP0ny4qbvS5r1h5vt63tZmyTpUD0LhSTjwK8CE1X1OmAN8G7g14GPVdU5wNPAZc0ulwFPV9XZwMeafpKkFdTr4aOTgJEkJwEvAx4H3grc0my/AdjcLF/UrNNsvzBJelyfJGmBnoVCVc0AvwE8SicMngHuBWaran/TbTcw/1y5ceCxZt/9Tf9XHvy+SS5PMpVkau/evb0qX5KGUi+Hj06h89f/WcA64GTg7Yt0rfldltj2fEPVdVU1UVUTY2Njy1WuJIneDh+9DfhGVe2tqn3AduAfAaPNcBLAGcCeZnk3cCZAs/0VwFM9rE+SdJBehsKjwPlJXtbMDVwIfBW4C7ik6XMpcFuzfHuzTrP9M1V1yCcFSVLv9HJO4W46E8b3Abuan3UdcDVwVZKH6cwZXN/scj3wyqb9KuCDvapNkrS4rOY/xicmJmpqaqrfZUjSqpLk3qqaWGyb32iWJLUMBUlSy1CQJLUMBUlSy1CQJLUMBUlSy1CQJLUMBUlSy1CQJLUMBUlSy1CQJLUMBUlSy1CQJLUMBUlSy1CQJLUMBUlSy1CQJLUMBUlSy1CQJLUMBUlSy1CQJLUMBUlSy1CQJLUMBUlSy1CQJLUMBUlSy1CQJLUMBUlSy1CQJLUMBUlS66R+FyBJx2rHzhm2TU6zZ3aOdaMjbNm0gc0bx/td1qpmKEhalXbsnGHr9l3M7TsAwMzsHFu37wIwGI6Dw0eSVqVtk9NtIMyb23eAbZPTfapoMBgKklalPbNzR9Wu7hgKklaldaMjR9Wu7hgKklalLZs2MLJ2zQvaRtauYcumDX2qaDD0NBSSjCa5JclfJ3kwyU8lOTXJnUkeal5PafomyW8neTjJl5Oc18vaJK1umzeOc83F5zI+OkKA8dERrrn4XCeZj1Ovrz7678CnquqSJC8GXgZ8CPh0VX0kyQeBDwJXA28Hzmn+eyNwbfMqSYvavHHcEFhmPfukkOQHgTcD1wNU1feraha4CLih6XYDsLlZvgi4sTq+CIwmOb1X9UmSDtXL4aPXAHuBP0iyM8nHk5wMvLqqHgdoXl/V9B8HHluw/+6m7QWSXJ5kKsnU3r17e1i+JA2fXobCScB5wLVVtRH4Lp2hosPJIm11SEPVdVU1UVUTY2Njy1OpJAnobSjsBnZX1d3N+i10QuKJ+WGh5vXJBf3PXLD/GcCeHtYnSTpIz0Khqv4v8FiS+evDLgS+CtwOXNq0XQrc1izfDrynuQrpfOCZ+WEmSdLK6PXVR+8HPtFcefR14JfpBNHNSS4DHgXe1fT9M+AdwMPA3zZ9JUkrqKehUFX3AxOLbLpwkb4FvK+X9UiSluY3miVJLUNBktQyFCRJLUNBktQyFCRJLUNBktQyFCRJLUNBktQyFCRJLUNBktQyFCRJra5CIcmrk1yf5M+b9R9rbmgnSRog3X5S+ENgEljXrH8NuLIXBUmS+qfbUDitqm4GngOoqv3AgZ5VJUnqi25D4btJXknzeMz5h+D0rCpJUl90+zyFq+g8Ge21Sf4SGAMu6VlVkqS+OGIoJHkR8FLgLcAGIMB0Ve3rcW2SpBV2xFCoqueSfLSqfgp4YAVqkiT1SbdzCnck+edJ0tNqJEl9dTRzCicD+5N8j84QUlXVD/asMknSiusqFKrqB3pdiCSp/7r9pECSU4Bz6Ew6A1BVn+9FUZKk/ugqFJL8a+AK4AzgfuB84P8Ab+1daZKkldbtRPMVwOuBb1bVTwMbgb09q0qS1BfdhsL3qup7AEleUlV/Tec7C5KkAdLtnMLuJKPADuDOJE8De3pXliSpH7q9+ujnmsUPJ7kLeAXwqZ5VJUnqi24nmn94weo3mtcfAh5d9ookSX3T7fDR/6Zzh9TQuST1LGAa+Ac9qkuS1AfdDh+du3A9yXnAe3tSkSSpb47pGc1VdR+dS1QlSQOk2zmFqxasvgg4D7+nIEkDp9s5hYX3PtpPZ47h1uUvR5LUT93OKfxarwuRJPVft8NHty+1vap+dnnKkST1U7fDR9+g872E/9ms/wLwCDDZg5okSX3SbShsrKo3L1j/X0k+X1UfOtKOSdYAU8BMVb0zyVnATcCpwH3AL1XV95O8BLgR+Eng/wE/X1WPHMWxSENtx84Ztk1Os2d2jnWjI2zZtIHNG8f7XZZWmW4vSR1L8pr5leYX+1iX+14BPLhg/deBj1XVOcDTwGVN+2XA01V1NvCxpp+kLuzYOcPW7buYmZ2jgJnZObZu38WOnTP9Lk2rTLeh8AHgs0k+29z76C7gyiPtlOQM4J8BH2/WQ+cZDLc0XW4ANjfLFzXrNNsv9JnQUne2TU4zt+/AC9rm9h1g2+R0nyrSarVkKCR5fZIfqqpP0Xnq2p8C3wHuAO7p4v1/C/gPwHPN+iuB2ara36zvBuY/344DjwE0259p+h9c0+VJppJM7d3rVyUkgD2zc0fVLh3OkT4p/C7w/Wb5jcDVdP6afwK4bqkdk7wTeLKq7l3YvEjX6mLb8w1V11XVRFVNjI11O4IlDbZ1oyNH1S4dzpFCYU1VPdUs/zxwXVXdWlX/ETj7CPu+CfjZJI/QmVh+K51PDqNJ5ie4z+D55zLsBs4EaLa/AngKSUe0ZdMGRtaueUHbyNo1bNnks7B0dI4YCgt+gV8IfGbBtiWvXKqqrVV1RlWtB94NfKaqfpHOfMQlTbdLgdua5dubdZrtn6mqQz4pSDrU5o3jXHPxuYyPjhBgfHSEay4+16uPdNSOdEnqJ4HPJfkWMAd8ASDJ2XTG/I/F1cBNSf4LsBO4vmm/HvijJA/T+YTw7mN8f2kobd44bgjouOVIf4wnOR84Hbijqr7btP0I8PLmbql9MzExUVNTU/0sQZJWnST3VtXEYtuO+OW1qvriIm1fW47CJEknlmN6noIkaTAZCpKklqEgSWoZCpKklqEgSWoZCpKklqEgSWoZCpKklqEgSWoZCpKklqEgSWoZCpKklqEgSWoZCpKklqEgSWoZCpKklqEgSWoZCpKklqEgSWoZCpKklqEgSWoZCpKklqEgSWoZCpKklqEgSWoZCpKklqEgSWoZCpKklqEgSWoZCpKk1kn9LkDqhR07Z9g2Oc2e2TnWjY6wZdMGNm8c73dZ0gnPUNDA2bFzhq3bdzG37wAAM7NzbN2+C8BgkI7A4SMNnG2T020gzJvbd4Btk9N9qkhaPQwFDZw9s3NH1S7peYaCBs660ZGjapf0vJ6FQpIzk9yV5MEkDyS5omk/NcmdSR5qXk9p2pPkt5M8nOTLSc7rVW0abFs2bWBk7ZoXtI2sXcOWTRv6VJG0evTyk8J+4N9V1Y8C5wPvS/JjwAeBT1fVOcCnm3WAtwPnNP9dDlzbw9o0wDZvHOeai89lfHSEAOOjI1xz8blOMktd6NnVR1X1OPB4s/ydJA8C48BFwAVNtxuAzwJXN+03VlUBX0wymuT05n2ko7J547ghIB2DFZlTSLIe2AjcDbx6/hd98/qqpts48NiC3XY3bQe/1+VJppJM7d27t5dlS9LQ6XkoJHk5cCtwZVV9e6mui7TVIQ1V11XVRFVNjI2NLVeZkiR6HApJ1tIJhE9U1fam+YkkpzfbTweebNp3A2cu2P0MYE8v65MkvVAvrz4KcD3wYFX95oJNtwOXNsuXArctaH9PcxXS+cAzzidI0srq5W0u3gT8ErAryf1N24eAjwA3J7kMeBR4V7Ptz4B3AA8Dfwv8cg9rkyQtopdXH/0Fi88TAFy4SP8C3tereiRJR+Y3miVJLUNBktQyFCRJLUNBktQyFCRJLUNBktQyFCRJLUNBktQyFCRJLUNBktQyFCRJLUNBktQyFCRJLUNBktTq5fMUdILYsXOGbZPT7JmdY93oCFs2bfCh9pIWZSgMuB07Z9i6fRdz+w4AMDM7x9btuwAMBkmHcPhowG2bnG4DYd7cvgNsm5zuU0WSTmSGwoDbMzt3VO2ShpuhMODWjY4cVbuk4WYoDLgtmzYwsnbNC9pG1q5hy6YNfapI0onMieYBNz+Z7NVHkrphKAyBzRvHDQFJXXH4SJLUMhQkSS1DQZLUMhQkSS1DQZLUMhQkSS1DQZLUMhQkSS1DQZLUGrpvNPvAGUk6vKEKBR84I0lLG6rhIx84I0lLG6pQ8IEzkrS0oQoFHzgjSUs7oUIhyc8kmU7ycJIPLvf7+8AZSVraCTPRnGQN8DvAPwF2A/ckub2qvrpcP8MHzkjS0k6YUADeADxcVV8HSHITcBGwbKEAPnBGkpZyIg0fjQOPLVjf3bRJklbIiRQKWaStDumUXJ5kKsnU3r17V6AsSRoeJ1Io7AbOXLB+BrDn4E5VdV1VTVTVxNjY2IoVJ0nD4EQKhXuAc5KcleTFwLuB2/tckyQNlRNmormq9if5FWASWAP8flU90OeyJGmopOqQYftVI8le4JvHuPtpwLeWsZzVwGMeDh7zcDieY/57VbXo+PuqDoXjkWSqqib6XcdK8piHg8c8HHp1zCfSnIIkqc8MBUlSa5hD4bp+F9AHHvNw8JiHQ0+OeWjnFCRJhxrmTwqSpIMYCpKk1lCGQpJHkuxKcn+SqX7X0wtJfj/Jk0m+sqDt1CR3JnmoeT2lnzUut8Mc84eTzDTn+v4k7+hnjcspyZlJ7kryYJIHklzRtA/seV7imAf5PL80yZeS/FVzzL/WtJ+V5O7mPP9JcyeI4/95wzinkOQRYKKqBvbLLkneDDwL3FhVr2va/hvwVFV9pHmI0SlVdXU/61xOhznmDwPPVtVv9LO2XkhyOnB6Vd2X5AeAe4HNwL9iQM/zEsf8Lxjc8xzg5Kp6Nsla4C+AK4CrgO1VdVOS/wH8VVVde7w/byg/KQyDqvo88NRBzRcBNzTLN9D5xzQwDnPMA6uqHq+q+5rl7wAP0rnd/MCe5yWOeWBVx7PN6trmvwLeCtzStC/beR7WUCjgjiT3Jrm838WsoFdX1ePQ+ccFvKrP9ayUX0ny5WZ4aWCGUhZKsh7YCNzNkJzng44ZBvg8J1mT5H7gSeBO4G+A2ara33RZtufPDGsovKmqzgPeDryvGXbQYLoWeC3wE8DjwEf7W87yS/Jy4Fbgyqr6dr/rWQmLHPNAn+eqOlBVP0HnkQJvAH50sW7L8bOGMhSqak/z+iTwp3T+Jw+DJ5ox2fmx2Sf7XE/PVdUTzT+o54DfY8DOdTPGfCvwiara3jQP9Hle7JgH/TzPq6pZ4LPA+cBokvk7XS/6/JljMXShkOTkZoKKJCcD/xT4ytJ7DYzbgUub5UuB2/pYy4qY/+XY+DkG6Fw3E5DXAw9W1W8u2DSw5/lwxzzg53ksyWizPAK8jc5cyl3AJU23ZTvPQ3f1UZLX0Pl0AJ3nSfxxVf3XPpbUE0k+CVxA5/a6TwD/CdgB3Az8MPAo8K6qGpiJ2cMc8wV0hhQKeAR47/x4+2qX5B8DXwB2Ac81zR+iM8Y+kOd5iWP+BQb3PP84nYnkNXT+kL+5qv5z87vsJuBUYCfwL6vq74775w1bKEiSDm/oho8kSYdnKEiSWoaCJKllKEiSWoaCJKllKEiNJJXkowvW/31zQ73leO8/THLJkXtK/WUoSM/7O+DiJKf1u5CFkqzpdw0aHoaC9Lz9dJ57+4GDNxz8l36SZ5vXC5J8LsnNSb6W5CNJfrG5//2uJK9d8DZvS/KFpt87m/3XJNmW5J7mZm7vXfC+dyX5Yzpf1JJWxElH7iINld8Bvtw8e6Jb/5DODcqeAr4OfLyq3tA8AOb9wJVNv/XAW+jcuO2uJGcD7wGeqarXJ3kJ8JdJ7mj6vwF4XVV943gPSuqWoSAtUFXfTnIj8KvAXJe73TN/S4UkfwPM/1LfBfz0gn43NzdseyjJ14G/T+feWz++4FPIK4BzgO8DXzIQtNIMBelQvwXcB/zBgrb9NMOtzU3ZFj76cOH9Zp5bsP4cL/w3dvA9ZQoI8P6qmly4IckFwHePrXzp2DmnIB2kuXnczcBlC5ofAX6yWb6IztOvjta7kryomWd4DTANTAL/trkdNEl+pLl7r9QXhoK0uI/SudvqvN8D3pLkS8AbOba/4qeBzwF/Dvybqvoe8HHgq8B9Sb4C/C5+glcfeZdUSVLLTwqSpJahIElqGQqSpJahIElqGQqSpJahIElqGQqSpNb/B/qSwP0VxdL0AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Read a CSV file and create a plot\n",
    "\n",
    "import csv\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def scatter_plot(x, y):\n",
    "    plt.scatter(x, y)\n",
    "    plt.xlabel('Number')\n",
    "    plt.ylabel('Square')\n",
    "    plt.show()\n",
    "    \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",
    "\n",
    "numbers, squared = read_csv('numbers.csv')\n",
    "scatter_plot(numbers, squared)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Correlation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function to calculate linear correlation\n",
    "\n",
    "def find_corr_x_y(x,y):    \n",
    "    n = len(x)\n",
    "    prod = []\n",
    "    for xi,yi in zip(x,y):\n",
    "        prod.append(xi * yi)\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",
    "    for xi in x:\n",
    "        x_square.append(xi ** 2)\n",
    "    x_square_sum = sum(x_square)\n",
    "    y_square=[]\n",
    "    for yi in y:\n",
    "        y_square.append(yi ** 2)\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": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Highest correlation: 0.9605138954331739\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYAAAAEGCAYAAABsLkJ6AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3df5Rc5Xkf8O8zoys0CzEjyp46DCxSCJVsWaANMshRT22pFBET5LWAo1BI/2lL2pO4IFO1S8MJkg+19lTHhf7hP0KdhORAiRRLnogojXCOZJPoRBiJXbSskVwXbKERp8gHDT+0gzQ7+/SPmTu6M3PvnTsz98fMvd/POTpod+fHO0fs+9z7vM/7vKKqICKi5ElFPQAiIooGAwARUUIxABARJRQDABFRQjEAEBEl1IKoB9CJq6++WpcsWRL1MIiIBsqxY8d+oarDzd8fqACwZMkSHD16NOphEBENFBH5ud33mQIiIkooBgAiooRiACAiSigGACKihGIAICJKKAYAIqKEGqgyUCLqH/nJAnYeOIkzxRKuyWawdcMyjI3moh4WdYABgIgcOU3y+ckCHts7jVK5AgAoFEt4bO80ADAIDBAGACKy5TbJ7zxwsv59U6lcwc4DJxkABggDABG1yE8W8Oju11FpOjDKnOTPFEu2z3P6vt96TT8xfVXFAEBEDcwr/+bJ32ROmgWbyf6abCbo4fWcfmL66pLIqoBEZJGI/EhEXheRGRHZHtVYiJIoP1nA2omDWDq+H2snDiI/WQBgn96xMq+YM0a64fsZI42tG5YFOmbAPf0UxvPjJMoy0AsA1qvqzQBWAbhTRNZEOB6ixDCvggvFEhSXroLzk4W2aZzZi3MAgB2bViKXzUAA5LIZ7Ni0MpQr6F7TT1Gnr/pJZCkgrZ5G/3HtS6P2hyfUE4XA6Sr4kV1TSIs4pn8A4NxsGY/tncaOTStxeHx90ENt0Wv6Kcr0Vb+JdCOYiKRFZArAewC+r6qv2DzmIRE5KiJHz549G/4giWLI7WrXbfI3RZky6TX9FGX6qt9EGgBUtaKqqwBcC+BWEfmczWOeUdXVqrp6eLjlPAMi6oIfV7tRpUzGRnM9pZ96fX6c9EUVkKoWReQHAO4E8EbEwyGKva0bljVUwnQjypTJ2Giupwm71+fHRZRVQMMikq39PQPgdgAnohoPUZJYr4KdiMvzk5oyiZsoU0C/DOCQiBwH8CqqawB/FeF4iBJlbDSHw+Pr8fTmVbY58QfWjNTTJNmMgcVDRuJTJnETZRXQcQCjUb0/EVWZEzl3xiZPX6wBEFG0mBNPJp4HQESUUAwAREQJxQBARJRQDABERAnFRWCiGDP73heKpXqPnxyrfKiGAYAoppr73ps9fpLc/54aMQAQxZRbX39rMzfW/ycXAwDRgHM63rBdszbzToAnYyUXF4GJBpjbwS7tmrWlRXgyVsIxABANMLfjDe363psyRtr1zF9KBgYAogHmdrxhc8fPtFT7e5rN3Jw6gSbxZKx2nM5PHnRcAyAaYO2ON2zX46f5TAC2eW7VXE0Vp7US3gEQDbBejjfkyVjeuKXZBh3vAIgGWK+tnNkFtD23NNugYwAgGnCcxIPVLs02yJgCIiJy0Uuard/xDoCIyEWcT0xjACDqY067fClccU2zMQAQ9YnmyX7d8mHsOVaIZfkh9QeuARD1gfxkAVu/+3pDS4fnjpyKbfkh9QcGAKI+sP3FGZQr9q0ZmsWh/JD6AwMAUR84N1v2/Ng4lB9Sf2AAIBogRlpw/sJc7HrSUDQYAIj6QDZj2H4/Y6TqrRoWDxmAAsVSuaX1M1E3WAVE1CTs0kunCdxICXZsuqn+3msnDrakisxFYfMxLBulTjAAEFmE3fmx+f1Mi4cMPHH3iob3bNeTJs5dKykYTAERWYTd+dHp3N6hhQtaJm2nxV/z+3HuWknBYAAgsgij86P1cBG7JmNO79euJ02cu1ZSMBgAiCzaXWX3qvkM307G0a5/f9Bjp/jhGgCRxdYNywI9Jcsp5WMlANYtH7b9mVtPmqDHTvHDAEBkEXTnRy/pGAWw51gBq6+/qqP37XTsrBgiUfW2/bwfrF69Wo8ePRr1MIi6NvqNlzzv+s1lMzg8vj6QcdhVH2WMNI+EjCkROaaqq5u/zzsAohB1cr1lLe/0+0rdrWKIASA5GACIQvRBqbOeP0HV9rNiiAAGAKJQOZ0v28xcvPXrSr35LuLKjIGiTTBixVC4ol6HiawMVESuE5FDIvKmiMyIyMNRjYXIT9Y6/+aGbXa1/M2yGaOei3cKFl6CiHU81tLTQrGE8xfnYKSk4XGsGAqX3b9L2L2dotwHMAfgUVX9DIA1AH5XRD4b4XiIetbul3psNId7bnG/wtu2cQV2HjiJpeP7HR+TFnH8WTO7u4hyRXHFogWOewooeP2wczuyFJCqvgvg3drfPxKRNwHkAPw4qjER9apdyiY/WcCeY+5XeI/smmr7PpUOVpOd8vrF2TIm/+AOz69D/uqHdZi+WAMQkSUARgG8YvOzhwA8BAAjIyOhjouoU+1+qb1sBPMiV1sg9pI/dlp3YL4/Wv3w7xJ5KwgRuQLAHgCPqOqHzT9X1WdUdbWqrh4ett8dSdQvnH55FdV2zp3k7p1kjDTWLR/2nD9u10OIotEP/y6RBgARMVCd/J9X1b1RjoXID26LvIViCd4z943SIg25+kMnznrOH7frIUTR6Id/l8h2AouIAPhTAO+r6iNensOdwDQIzNSM16v9jJHGZQtStmWZ5s+bJ4al4/ttm8kJgLcn7upi1BRnTjuBo7wDWAvgtwGsF5Gp2p8vRzgeIl+MjeZweHy9p6v9xUPVks9tG1fY3jmYP+/0bAAiL6KsAvp7oOs7YqK+52XT19DC6q+guTicFkFFFbk2m4LY+ZP8EPkiMFFceZmMzcVbM1BUVOsTuVsuuB/yxzT4+qIMlCgumkszL1+YxvmLzmWfaZG2+wacSj3dzgYg8oIBgMgndo3bjJTASAvKldYlWyMlKM/bF2GcKZZ4yDsFjikgIp/YtlyYV1y+sNpyAbjUwiGbMTDv8lrXZDN90SqA4o13AEQ+cdoF/EGpjKknGlsurJ046Fj2KaiuH2xxaAnBls3kF94BEPmkk9JMt0lcUU3xOL3elRnDsdsoUScYAIh80snWfrd6fTNdZPd6Rkpw/uJcpC2EKT4YAIh80klp5tYNy2CkW7fBGCmpBwy717ti0YKWBWWuC1C3uAZA5CNzsjdLN82JuTkImF9vf3Gmfkh8NmNg28YVDY9tLvV0OiOA6wLUDQYASiy7GnsADd9bt3wYh06cbanDd6rP76R0s5s6/n5oIUzxEVkzuG6wGRz5pXmiBlBNySgca/OBak7/nlty2HOs0NKGYcemlY5N4NIimFft+dxXu3HbNYsjsnJqBsc7AEokp2MS2ymVK3jhlXdaTuQy8/BOqRjz8b1u5mpOMUVxkDjFBwMAJVIvOXOn4xjNCbldAzhrq4dusAUE+YVVQJRIveTMnQ5kN6/GnQ6EseKiLfUDBgBKJNsae5uyzGYZI437b7vOsd7fLN3MZgzX1+GiLXmRnywEuumPAYASya7Gfue9N7s+x6zrf3JspWO9f36ygG37ZhzbPADs20/emAv+QW76YxUQkYXTwe25bAaHx9e7PteuQsfudbhoS1708v9iM1YBEXngdtKWW29+wL6yyEqAjn9xKbmc1on8XD9iAKBEaTeJO5VZAmi7wavdLybz/tSJMDb9MQBQYjyen8bzR07BTHo61eTblVmunTjoenIX4H4GcHPev10gIgrj3GcuAlMi5CcLDZO/yWsjNS+3404loIuHjIadumEs7tHgC+PcZy4CUyI4LaiZnt68yvUXy+n5zS0egPa7dP1c3CPygovA1FfCToG0y89v2TWFR3ZNOVbp2N2OA60tHnZsWtl2Eg9jcY/IC6aAKHRRpEDaLZw1rws0j6X5dtxuN7DXdFInJ4cRBYkBgEIXxWHnXls0uI1lbDSHw+Pr8fbEXZh36QfUzVi4OYyiwBQQhS6KFIi1vLNdszageiewavtLKJbKSIugotqQHuqlRI8dPalfcBGYQhf1IqiXHbtOBNV00eUL0zh/sfX5D64ZwZNjK3sfJJGPuAhMfSOM+mZT82KzecJXqVypX9mbk7oX5uPsJn8AOHTirB/DJgqFpwAgIv8YwDcBXKOqvyEinwXwBVX9o0BHR7EUVgrE7njG546cqv/crODx8x6YlTw0SLzeATwL4E8A/H7t658A2AWAAYC6EsahJu168wSBlTw0SLxWAV2tqrsBzAOAqs4BCPc3i6hDXhZ7/cRKHho0Xu8AzovIP0LtbllE1gD4ILBREfUoP1noKLfvhd3rmd9jm2caRF7vAL4OYB+AG0TkMIA/A/C1wEZF1KOdB076Nvk/uGYEP5u4C09tXoXFQ40nfSmqQaBQLGHngZPs50MDpW0AEJEUgEUAvgjg1wH8DoAVqno84LERdc2PxVhBY1nn2GgOQwtbb5rb7SIm6ldtU0CqOi8i31LVLwCYCWFMRF0zyz69Xv1nMwY+KJVxZcaACFCcLbtWJbULLM0toon6mdc1gJdE5B4Ae3WQdo7RQPCrMVw3G7w++mQOD3Swecut57+JpaA0KDpZA/gLABdE5EMR+UhEPuz1zUXkj0XkPRF5o9fXosHkZ2O4bftmOi77rKjiuSOn8Hh+2tPjvfQUYikoDQpPAUBVf0lVU6q6UFU/Vfv6Uz68/7MA7vThdWhA9dIYLj9ZwNqJg1g6vh+j36j27enWC6+84+lx1q6gQHWdwIqloDRIPLeCEJHFAG5EdUEYAKCqL/fy5qr6sogs6eU1aLB12xiuOd1zbrb7yR+o3gnkJwueUk/WTWw82pEGmddWEP8GwMMArgUwBWANgH8AEHjnLhF5CMBDADAyMhL021HIuu2qGcQuX7vzgdsJY0czUVC8rgE8DODzAH6uqusAjAIIpeuVqj6jqqtVdfXw8HAYb0kh6qY3fn6y4HmX75Dh/ciLUrmC7S+y0I2Sw+tvxyeq+gkAiMhlqnoCABOd1LPmk7ayGQOLjBS27JrC2omDLYvBZurHi4yRxjc33YRMB0Hg3GyZdfyUGF5/M06LSBZAHsD3ReQvAZwJbliUJOZJW09tXoULc/M4N1t2rAhyS/0YaUE2Y0BQbc2wY9NKjI3msMjjSWDW9yBKAk9rAKr61dpft4nIIQBXAvibXt9cRF4A8CUAV4vIaQBPsMV0cjlVBG1/caaeZ3dbHN557822+fhihwvEhWIJaycOckGXYs/rIrB19fXt2n8/DeCUzcM9U9X7e3k+9aduKmPc8vpmWsbtKMZsxsDOAyexZddUy3t62bzVzLz7ADpbFCYaJJ6OhBSRaVzqe7UIwFIAJ1V1RbDDa8QjIfuf3W7cjJGup2O8PqdZNmPg8ssWoFAseeryaX1Pu9cXAL9+w1V47dQHru8b1jGVREFyOhLS60awlap6U+2/NwK4FcDf+z1IGnzdbOzyUtJZLJXrV/FeepGUyhU8uvv1+p3DPbfkGjZtKYDXTn2Ae27J1Td12WFbB4oz7+URFqr6GqploUQNutnYFdQkW1HFll1TeDw/jUMnzrYEjlK5gkMnzuLw+HrHIMC2DhRnXtcAvm75MgXg1xDSPgAaLG4bu8y1gUKxVD+QPZfNIDtk9LyT14kCeP7IKce7BjP4hHlQPVG/8HoH8EuWP5cB2A/gK0ENigaX08audcuH603fgEsHsheKJXz8yRyMdGNXHfOrXDbTcghLpxRAWpq79lSZV/jN+xGsZaREceW1DHR70AOheDAnzG37ZurN2RYZKew//q5jnr88r/VFXrvKoW7aPDerqCJjpF2v8NnWgZLGawpon9vPVXWjP8OhuLgwN1//u5f0TrFUxtQTd9j+zJyUzfRRN8wze9m4jegSr91A30a17v+52tf3A/gZgAMBjIki4ldny24atQmAx/PT2H/83XrAyGYMbNu4on5lPjaaw9qJg7ZBICWAKpAxUpgtzzf8zLzS5xU+USOv+wBeVtV/1u57QeM+gOB0U7/vZOn4ft8OZAeAyxemYaRT9aMbz1+cQ7ly6R2ax8kWzUSNnPYBeL0DGBaRX1HVt2ovthQAW3PGiFv9fqeTZzc7b92cv1gBUB1bsVSGkRIsHjIcz+/llT6RN16rgLYA+IGI/KDWC+gQgEeCGxaFrduDWexs3bCs5aQsUy6bcd145UV5XvFhaa6n1yCiNgFARD4vIp9W1b9B9TSw7wH4CMBLAF4NYXwUEqcNT91shBobzeGBNSO2QeD8hTmsWz7c9lzddiqqDR1DH89P14+HtGsjTUSt2t0B/CGAi7W/3wbgPwP4UwD/D8AzAY6LQtbNwSxunhxbiac2r8LlCxtfs1gqY8+xAn5t5ErHu4ROlcoVPH/klC8HyxMlSbs1gLSqvl/7+2YAz6jqHgB7RGQq2KFRmKyllr0unlp3/NoplSs48tY5XxeK7do8dLN+QZQkbQOAiCxQ1TkA/xy1s3k9PpcGTKeLp3bVNgA8bdqqeKg+s2O2kPCCjdyI3LWbxF8A8EMR+QWAEoC/AwAR+VUAHwQ8NupjzWWjZtrlsgUpT3sAOpnIFw8ZeOLuFa6tne1eiY3ciNy5rgGo6n8F8CiAZwH8U720aSAF4GvBDo36mVPZqNn+wY0AuP+26zwvBA8tXFC/M7Hr2fPAmhFf1y+IkqJtGkdVj9h87yfBDIcGRS/pFQXw3JFTyGYMfDJXQbsbgeb3sktVrb7+Km7+IuoQ8/jU1c5ZPzZ7FUtlGGlBZV4x7xIEsh66gXLzF1HnujoQhuLDzKl3WkJpVzbajXJFcWXGcG35/PEncyzpJAoAA0DM5ScLrhukujnCEUD9mEWnPvudODdbxtDCBXh68ypkM62BoDyv9fG0+zxE5J2nZnD9gs3gOuPUR99aVePUuE0AvD1xV0t6aN3yYRw6cdbz4eydaO7X3zyepzav8q1hHVGSODWDYwCIGeuEnXIptTRSgisWLXDs1W/2z+/1IJZOOZWHmv2D7NYdctkMDo+vD3xsRIPKKQAwBRQjj+ensWXXVD2f71ZnX55Xx8nfLKHspq9/r8yTu+zG42fDOiJiAIiN/GTB9fBzr6xn4UYxsZrvb3c2r58N64iIZaCxsf3FmZ4nfwFweHx9faE17ORgu5O77FJS3PBF1D0GgBjITxZcz931ulh7TTbjywHs3UiL4J5b3Gv5/WxYR0QMALHgVrJpVs+YjztTLDkeqxhV3h+o5v73HCtg9fVXtQ0CnPCJ/MEAEANuufpFRgpbdk21XC077f7dsiu6Lt9s4UwULi4Cx4DbImipPG+7w3dsNIfD4+vrdwdbdk1h9BsvhZ73b8aKHqLwMADEgF1bBrv9uaVyBY/ufr0eBJrbQLitI3QiJUA61d0OYVb0EIWHKaAQdNNsrRN2i6NOjdoqqnhs73T98UHk++cVEA8bDJsXp1nRQxQu7gQOmF1VTRjtC9ZOHHTt1pnzoZtnL8ydxqzoIQqe005g3gEEzK3ZWpCTXbs2DlFO/kA118+KHqJocQ0gYFG2L1hk9O8/b6aPx0aUFLwDCJhTPt662On3GkHYm7kuX5hGdmhh2wZ0VqW5+RBGRkRuIg0AInIngP8BIA3gO6o6EeV4guDUvmDd8uF6nt66GGqWawLoOghs2zcT6mau2YsVzHyj2o3Ta/AZoKUnotiKLACISBrAtwH8CwCnAbwqIvtU9cdRjSkIdhU665YPY8+xQn2SbJ4LO1kjsOvX7+Vgdj9Z72aaP6/TPO/HQTJE1Jso7wBuBfBTVX0LAETkzwF8BUCsAgDQ2r5g7cTBtlfIXtYIHs9PN3QALRRLeO7IqV6G2jEjLS2lm9bP+3h+2nZM9992XSjjIyJnUa7E5QC8Y/n6dO17sedlcm+3ISo/WcBzPrR/7kVKgJ333ux6p/Lk2Eo8uGakfsWfFsGDa0bw5NjKsIZJRA6ivAOwywG0zGci8hCAhwBgZGQk6DGFwm2jFtB+Q1R+soCv746uZ49JtXq1324R+8mxlZzwifpQlHcApwFY8wDXAjjT/CBVfUZVV6vq6uHh4dAG16lODit3m9zTIq6bxMxF1vk+WES1to8220k09xwiov4V5R3AqwBuFJGlAAoAfgvAv4xwPF1rrnzxUsmTErRM4kZKsPO+m12vqqNq19zMrX00u3oSDYbI7gBUdQ7A7wE4AOBNALtVdSaq8fTCbRJ0erzdFfwVixbUJ3+nq+ogNpAJ0NJMzkiL42atxUNG22Mj2dWTqP9Fug9AVf8awF9HOYZuWa/QnbIxnU6OxVo3TreA0m79oBsPrBnB6uuvsr3jsLsTMce4ZdeU48YvdvUk6n/cCdwFr5ud3A4xt5vEFe5N3M4US3hq8ypfd/lmjBSeP3IKh06ctd2B3FzSuWX3VMMmLrvJn109iQYDA0AXvObhZy/OIT9ZaJhU85MFzF6cc3xO885gq2uymfprbds309OGLyMtqMwrSuX5+vtu/e7rOPrz93HoxNmWOwGnen5TWgTzquzqSTRAGAC64DW/fW62jMf2TtcnVbfJ3UrRvlf+hR576QhaF6HLFW2Y5K2L2S+88g7cVFTxs4m7ehoTEYWL5wF0oV2vfb/YVQpFwcvZAebh87zyJ+o/TucBsCdvG3b1/WHlt/th8geqdzztevco4Fj1RET9iQHAhVM5JlAthUyKa7IZT717WPpJNFgYAFy4lWM+cfeKltr5fpIxUshmeg9S5trD6uuvwlCbQ1xY+kk0WBgAXDhd0RaKpXpw6Ne2xouMNKaeuKOr55qfKJfNYMemag+fx/ZOY7bsvPDM0k+iwcMqIBdO9fqCS2fqVlRhpAXlSp8k7GvOzZaxduIgMkaqXurplaI6+R8erx7y4tS+mqWfRIONAcCF3WledmWcQU3+XkpG3RSKJRhpQQpAp0Wj1rsfpzuheVW8zdJPooHFFJCLsdEcdmxa2ZBLD/M638t7ZTOG61pEuaJYZKSQq+XnvSasrPl8tx3NRDS4GAA86HXTVVCMlGDbxhW455ac61rEbHkeWzcsQy6b8RRUmvP5WzcsawkyzPkTDT6mgNrol/bLzTJGCjs23QQA2HOsYNuTx8ps6OZk8ZCB4mzZNp9vd64xc/5Eg48BwIHZBTOMHb/dqV7xew1Q5sRt93msC75Oms81JqLBl/gA4NTuuF3HzV4XaHtl7kfwGqBSIli3fBh7jhUaPhdTOUTJleheQHZtnTNGGouMFM7NOnfaFFR76JsN3qLUSSDKGGncc0vOttsnEcWXUy+gRN8BOO30bZdSUaB+yHl+soBHdkVzQHva4TAWJ6VyBYdOnG2b7iGiZEh0FVC3vWtylvLHsBqgGanGKp+Mke5o8jexXw8RmRIdALqtY3/vwxKWjO/HkvH9oaWAjLQgl81AcKlFQ66L8bN2n4hMiU4B2e309aLDzgq+mC3P48c2qZtOxs8FXyKySnQAsNa3R72Y68Wq7S9BBPV6/XXLh3HZgpSnAJDjgi8RNUl0FZDV0vH9vpR1Rl0e2kwA9ushSjieCObAPPGr10k7LYLFQ0ZfTf4Ac/5E5CzRKSC7fQDdqqi67h2IAnP+ROQm0QGgX/v89II9+onIq8QGgPxkoeuF31w2gzO1c4L7ScZIY8emlZz0iciTRK4BPJ6f7nr3rplWccqtZzNGQ73+g2tGehipM/O1m/cGcPInIq8SdweQnyzguSOnunru4iEDT9y9oj7J2vUR2rZxRcskvP/4u76tDxhpwc57b+ZET0Q9S1wA+C97j3f8HCMF7LxvVdc98p+4e4Uv/YJYy09EfkpUAMhPFjDb4TZet0nXa4/8sdEctu2bQbHU/V2Al579RESdSNQawPYXZzp+TqFYwmN7p5GfLPT03ts2rmg5VlEArL3hqoYzh52wiRsR+S1RAaDbPLx5+EovzAPmrYu2T21ehef/7Rdsg0MzbugiIr8lJgXU6xV8c8mo3Uli7dJBTimjdvsRuKGLiIKQiDuA/GQBj/7F6768DlAtI92yawqF2l6AXtNEbukdlncSUVAScQew/cUZVOZ737ZlpoGeP3KqZROYmSbqZqLu5bB2IqJuxf4OID9Z8K0G/0yxhJ0HTjruAO52oXbrhmUtawBM+xBR0GJ/B+DnkY1XZgzXSb7bhdpO9hQQEfklkgAgIvcB2AbgMwBuVdVgmvzD3/JJEed0jQA9XbF73VNAROSXqFJAbwDYBODloN/Iz/LJ4mzZNl0jAB5YM8IJnIgGSiQBQFXfVFX/cjMutm5YhpT481rXZDOO9fxPjq30502IiELS92sAIvIQgIcAYGSk886aY6M5bPGhD491UZbpGiKKg8ACgIj8LYBP2/zo91X1L72+jqo+A+AZoHomcDdj6bUAVASsxSei2AksAKjq7UG9dthUL1UTmUGgm53ARET9pO9TQL3qtQWEydzta7KeBWD9GYMAEQ2KSBaBReSrInIawBcA7BeRA0G9l5/7AMzdvna9e/xoGEdEFKZI7gBU9XsAvhfGe/ndRtnt9diymYgGSexbQfjdRvmabMbxNdmymYgGSewDgJ/9dMxSUPbuIaI4iH0AGBvNYcjo/WNa2zLbbQZjmSgRDZrYVwEBwDc33YSt330d5Ur3OwKa2zJzMxgRDbpEBABzot7+4kxXraG9nNlLRDRoYp8CMo2N5jD5B3fg6c2r6qmbxUNG28ndSAm2bVwRziCJiEKUiDsAK7vUTX6y0LCxy5TNGNi2cQVTPUQUS4kLAHZ4IAsRJREDQA0XdYkoaRKzBkBERI0YAIiIEooBgIgooRgAiIgSigGAiCihGACIiBJKVHs9MTc8InIWwM8DeOmrAfwigNftN/yc8ZOUz8rP2ZvrVXW4+ZsDFQCCIiJHVXV11OMIGj9n/CTls/JzBoMpICKihGIAICJKKAaAqmeiHkBI+DnjJymflZ8zAFwDICJKKN4BEBElFAMAEVFCMQDUiMh9IjIjIvMiErtyMxG5U0ROishPRWQ86vEEQUT+WETeE5E3oh5LkETkOhE5JCJv1v6ffTjqMQVBRBaJyI9E5PXa59we9RilmOUAAAQDSURBVJiCJCJpEZkUkb8K6z0ZAC55A8AmAC9HPRC/iUgawLcB/AaAzwK4X0Q+G+2oAvEsgDujHkQI5gA8qqqfAbAGwO/G9N/zAoD1qnozgFUA7hSRNRGPKUgPA3gzzDdkAKhR1TdV9WTU4wjIrQB+qqpvqepFAH8O4CsRj8l3qvoygPejHkfQVPVdVX2t9vePUJ00YneakVZ9XPvSqP2JZdWKiFwL4C4A3wnzfRkAkiEH4B3L16cRwwkjiURkCYBRAK9EO5Jg1NIiUwDeA/B9VY3l5wTwNID/BGA+zDdNVAAQkb8VkTds/sTuariJ2HwvlldSSSIiVwDYA+ARVf0w6vEEQVUrqroKwLUAbhWRz0U9Jr+JyG8CeE9Vj4X93ok6E1hVb496DBE5DeA6y9fXAjgT0VjIByJioDr5P6+qe6MeT9BUtSgiP0B1jSdui/xrAWwUkS8DWATgUyLynKo+GPQbJ+oOIMFeBXCjiCwVkYUAfgvAvojHRF0SEQHwRwDeVNX/HvV4giIiwyKSrf09A+B2ACeiHZX/VPUxVb1WVZeg+rt5MIzJH2AAqBORr4rIaQBfALBfRA5EPSa/qOocgN8DcADVBcPdqjoT7aj8JyIvAPgHAMtE5LSI/OuoxxSQtQB+G8B6EZmq/fly1IMKwC8DOCQix1G9iPm+qoZWIpkEbAVBRJRQvAMgIkooBgAiooRiACAiSigGACKihGIAICJKKAYASiwRURH5luXr/ygi23x67WdF5F4/XosoKAwAlGQXAGwSkaujHohVrXsrUeAYACjJ5lA9g3VL8w+ar+BF5OPaf78kIj8Ukd0i8hMRmRCRB2p966dF5AbLy9wuIn9Xe9xv1p6fFpGdIvKqiBwXkd+xvO4hEflfAKaD/NBEpkT1AiKy8W0Ax0Xkv3XwnJsBfAbV1tNvAfiOqt5aO5jlawAeqT1uCYAvArgB1R2tvwrgXwH4QFU/LyKXATgsIi/VHn8rgM+p6tu9figiLxgAKNFU9UMR+TMA/wFAyePTXlXVdwFARP4vAHMCnwawzvK43ao6D+D/iMhbAJYDuAPATZa7iysB3AjgIoAfcfKnMDEAEFV7sb8G4E8s35tDLUVaa7620PKzC5a/z1u+nkfj71RznxVFtTX311S1odeUiHwJwPnuhk/UHa4BUOKp6vsAdgOwNo/7GYBban//CqqnUXXqPhFJ1dYFfgXASVQb8v37WjtniMg/EZHLux07US8YAIiqvgXAWg30PwF8UUR+BOA2dHd1fhLADwH8bwD/TlU/QfXIvx8DeK12eP0fgnfiFBF2AyUiSijeARARJRQDABFRQjEAEBElFAMAEVFCMQAQESUUAwARUUIxABARJdT/B/tIKsxU+lwlAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Calculate correlation and create a scatter plot similar to that on Google correlate\n",
    "import matplotlib.pyplot as plt\n",
    "import csv\n",
    "\n",
    "def read_csv(filename):\n",
    "    with open(filename) as f:\n",
    "        reader = csv.reader(f)\n",
    "        next(reader)\n",
    "        summer = []\n",
    "        highest_correlated = []\n",
    "        for row in reader:\n",
    "            summer.append(float(row[1]))\n",
    "            highest_correlated.append(float(row[2]))\n",
    "    return summer, highest_correlated\n",
    "\n",
    "summer, highest_correlated = read_csv('correlate-summer.csv')\n",
    "corr = find_corr_x_y(summer, highest_correlated)\n",
    "print('Highest correlation: {0}'.format(corr))\n",
    "\n",
    "scatter_plot(summer, highest_correlated)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Correlation coefficient: 0.3183785775683751\n"
     ]
    }
   ],
   "source": [
    "# Correlation Example 1\n",
    "# Find the correlation for high school grades and college admission scores\n",
    "\n",
    "high_school_math = [90, 92, 95, 96, 87, 87, 90, 95, 98, 96]\n",
    "college_admission = [85, 87, 86, 97, 96, 88, 89, 98, 98, 87]\n",
    "corr = find_corr_x_y(high_school_math, college_admission)\n",
    "print('Correlation coefficient: {0}'.format(corr))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Correlation coefficient: 0.9989633063220916\n"
     ]
    }
   ],
   "source": [
    "# Correlation Example 2\n",
    "# Find the correlation for high school math grades and college admission scores\n",
    "\n",
    "high_school_math = [83, 85, 84, 96, 94, 86, 87, 97, 97, 85]\n",
    "college_admission = [85, 87, 86, 97, 96, 88, 89, 98, 98, 87]\n",
    "corr = find_corr_x_y(high_school_math, college_admission)\n",
    "print('Correlation coefficient: {0}'.format(corr))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 3.25), (3.25, 5.5), (5.5, 7.75), (7.75, 11)]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create classes for grouped frequency table\n",
    "# n is arbitrarily chosen number of classes\n",
    "\n",
    "def create_classes(numbers, n):\n",
    "    low = min(numbers)\n",
    "    high = max(numbers)\n",
    "    width = (high - low)/n   # Width of each class\n",
    "    classes = []\n",
    "    a = low\n",
    "    b = low + width\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\n",
    "\n",
    "create_classes([7, 8, 9, 2, 10, 9, 9, 9, 9, 4, 5, 6, 1, 5, 6, 7, 8, 6, 1, 10], 4)  # choosing 4 classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10.50 - 12.88 \t 4\n",
      "12.88 - 15.25 \t 4\n",
      "15.25 - 17.62 \t 7\n",
      "17.62 - 21.00 \t 10\n"
     ]
    }
   ],
   "source": [
    "# Create a grouped frequency table from a list of numbers\n",
    "\n",
    "def create_classes(numbers, n):\n",
    "    low = min(numbers)\n",
    "    high = max(numbers)\n",
    "    width = (high - low)/n   # Width of each class\n",
    "    classes = []\n",
    "    a = low\n",
    "    b = low + width\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\n",
    "\n",
    "def classify(numbers, classes):\n",
    "    # Create a list with size = number of classes\n",
    "    count = [0] * len(classes)  # each element is initially zero\n",
    "    for n in numbers:\n",
    "        for index, c in enumerate(classes):\n",
    "            if n >= c[0] and n < c[1]:\n",
    "                count[index] += 1\n",
    "                break\n",
    "    return count    # return list with counts for classes\n",
    "\n",
    "def read_data(filename):\n",
    "    numbers = []\n",
    "    with open(filename) as f:\n",
    "        for line in f:\n",
    "            numbers.append(float(line))\n",
    "    return numbers\n",
    "    \n",
    "import matplotlib.pyplot as plt\n",
    "    \n",
    "# num_classes = int(input('Enter the number of classes: '))\n",
    "num_classes = 4\n",
    "numbers = read_data('marks.txt')\n",
    "    \n",
    "classes = create_classes(numbers, num_classes)\n",
    "count = classify(numbers, classes)\n",
    "\n",
    "for c, cnt in zip(classes, count):\n",
    "    print('{0:.2f} - {1:.2f} \\t {2}'.format(c[0], c[1], cnt))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Percentile"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Bob': 94, 'Ann': 70, 'Sue': 64, 'Han': 76, 'Kim': 93, 'Lee': 71, 'Ava': 40, 'Syd': 73, 'Sam': 66, 'Tom': 56}\n",
      "8\n",
      "The percentile score for Kim was 80.00\n"
     ]
    }
   ],
   "source": [
    "# Find percentile performance of student on an exam\n",
    "\n",
    "import random as r, math\n",
    "\n",
    "scores = [r.randint(40,100) for n in range(10)]\n",
    "pupils = ['Bob','Ann','Sue','Han','Kim','Lee','Ava','Syd','Sam','Tom']\n",
    "results = dict(zip(pupils,scores))\n",
    "print(results)\n",
    "pupil = 'Kim'\n",
    "score = results[pupil]\n",
    "sorted_scores = sorted(scores)\n",
    "dex = sorted_scores.index(score)\n",
    "\n",
    "pct = dex / len(scores) * 100\n",
    "print('The percentile score for {} was {:.2f}'.format(pupil,pct))"
   ]
  }
 ],
 "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}