python-basics and ml.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# basic data types and variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "str = 'hello world'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world\n"
     ]
    }
   ],
   "source": [
    "print(str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "learning = True\n",
    "print(learning)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "sleeping = False\n",
    "print(sleeping)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "random_variable = None\n",
    "print(random_variable)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# So we have learnt basic data types and variables in Python, now lets learn about lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "list = [-1.1, 'vinod', x, str]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-1.1, 'vinod', 1, 'hello world']"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.1"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# first element of list\n",
    "list[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'vinod'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# second element of list\n",
    "list[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello world'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# last element in list\n",
    "list[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# second last element in list\n",
    "list[-2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# adding an element to end of the list\n",
    "list.append(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# now lets see the last element in the list\n",
    "list[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "list.append(False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-1.1, 'vinod', 1, 'hello world', True, False]\n"
     ]
    }
   ],
   "source": [
    "print(list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-2.2\n",
      "vinodvinod\n",
      "2\n",
      "hello worldhello world\n",
      "2\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "# iterating over all elements of a list\n",
    "for x in list:\n",
    "    print(x * 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Lets learn functions in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define a function call add which will add 2 arguments passed to it and return the added value\n",
    "def add(x, y):\n",
    "    return x + y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# call that function passing required arguments\n",
    "add(7, -7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_divisible(num, divisible_by):\n",
    "    if num % divisible_by == 0:\n",
    "        # if reminder after division is 0 then its divisible, so return True\n",
    "        return True\n",
    "    else:\n",
    "        return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_divisible(10, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_divisible(21, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_greater(value, other_value):\n",
    "    if value > other_value:\n",
    "        return True\n",
    "    else:\n",
    "        return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_greater(value, other_value): return value > other_value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_greater(5, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_greater(10, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4]"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# In Python functions can take functions as arguments and invoke those functions, lets see an example\n",
    "\n",
    "def is_even(x):\n",
    "    return x % 2 == 0\n",
    "\n",
    "def only_even_numbers(list, is_even):\n",
    "    result = []\n",
    "    for x in list:\n",
    "        if(is_even(x)):\n",
    "            result.append(x)\n",
    "    return result\n",
    "            \n",
    "only_even_numbers([1, 2, 3, 4, 5], is_even)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Other really helpful functions to work with lists filter, map, reduce"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "# filtering elements in a list using built-in filter method\n",
    "numbers = [1, 2, 3, 4, 5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<filter object at 0x05D48CB0>\n"
     ]
    }
   ],
   "source": [
    "def is_even_number(num):\n",
    "    return num % 2 == 0\n",
    "\n",
    "filtered_list = filter(is_even_number, numbers)\n",
    "print(filtered_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<map object at 0x05D212F0>\n"
     ]
    }
   ],
   "source": [
    "# creating a new list from existing list using built-in map method\n",
    "def square_it(num):\n",
    "    return num * num\n",
    "squared_list = map(square_it, numbers)\n",
    "print(squared_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "# So we have leart how to filter, map, reduce and iterate a list. \n",
    "# This is a very important construct and we will use it many times!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2)\n"
     ]
    }
   ],
   "source": [
    "# Now lets learn about Tuples in Python, similar to list but cannot be modified once defined\n",
    "tup = (1, 2)\n",
    "print(tup)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# similar way to access elements\n",
    "tup[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<filter at 0x5d21b70>"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# can do similar map, reduce, filter operations\n",
    "filter(is_even_number, tup)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Now lets learn about Python dictionaries a.k.a maps\n",
    "# Dictionary has many named elements in it. \n",
    "# Name of each element is called the 'key' and the element itself is called the 'value' \n",
    "dict = {}\n",
    "dict['name'] = 'Asif'\n",
    "dict['age'] = 35\n",
    "dict['gender'] = 'male'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Asif'"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict['name']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "35"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict['age']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Unknown height\n"
     ]
    }
   ],
   "source": [
    "x = dict.get('height', 'Unknown height')\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['name', 'age', 'gender'])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# how to get all keys of a dict as a list\n",
    "dict.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values(['Asif', 35, 'male'])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# how to get all values of a dict as a list\n",
    "dict.values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_items([('name', 'Asif'), ('age', 35), ('gender', 'male')])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# how to get all (key, value) pairs as a list\n",
    "dict.items()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "name Asif\n",
      "age 35\n",
      "gender male\n"
     ]
    }
   ],
   "source": [
    "# how to print all the keys and their corresponding values \n",
    "for key, value in dict.items():\n",
    "    print(key, value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# number of items in dict\n",
    "len(dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# So we have now learnt about Dictionary or Map in Python, now lets learn about Lambda functions\n",
    "# a lambda function, is a normal function but without any name\n",
    "# Lambdas create a shorthand to define functions and store them in variables\n",
    "add_function = lambda x, y: x + y\n",
    "add_function(3, -4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "# now that we can have function variables, we can pass functions to other functions as arguments\n",
    "def filter_list(list, filter_function):\n",
    "    result = []\n",
    "    for x in list:\n",
    "        if(filter_function(x)):\n",
    "            result.append(x)\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "120"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# we need to import math package before using it\n",
    "# more details of Math package at: https://docs.python.org/2/library/math.html\n",
    "\n",
    "import math\n",
    "math.factorial(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "120"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math as m\n",
    "m.factorial(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# now we can use other functions from math module\n",
    "m.floor(1.7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "120"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# what if we wanted to directly access factorial and floor functions?\n",
    "from math import factorial, floor\n",
    "\n",
    "factorial(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "floor(1.7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "120"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# what if we wanted to rename the functions while importing them\n",
    "from math import factorial as fact, floor as fl\n",
    "fact(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "40320"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# what if we wanted to import all function in math so that we can access then directly\n",
    "from math import *\n",
    "factorial(8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "train=pd.read_csv(\"height-weight.csv\", sep='\\t')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Index</th>\n",
       "      <th>Height(Inches)</th>\n",
       "      <th>Weight(Pounds)</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>65.78331</td>\n",
       "      <td>112.9925</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>71.51521</td>\n",
       "      <td>136.4873</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>69.39874</td>\n",
       "      <td>153.0269</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4</td>\n",
       "      <td>68.21660</td>\n",
       "      <td>142.3354</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5</td>\n",
       "      <td>67.78781</td>\n",
       "      <td>144.2971</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Index  Height(Inches)  Weight(Pounds)\n",
       "0      1        65.78331        112.9925\n",
       "1      2        71.51521        136.4873\n",
       "2      3        69.39874        153.0269\n",
       "3      4        68.21660        142.3354\n",
       "4      5        67.78781        144.2971"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 25000 entries, 0 to 24999\n",
      "Data columns (total 3 columns):\n",
      "Index             25000 non-null int64\n",
      "Height(Inches)    25000 non-null float64\n",
      "Weight(Pounds)    25000 non-null float64\n",
      "dtypes: float64(2), int64(1)\n",
      "memory usage: 586.0 KB\n"
     ]
    }
   ],
   "source": [
    "train.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Index</th>\n",
       "      <th>Height(Inches)</th>\n",
       "      <th>Weight(Pounds)</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>25000.000000</td>\n",
       "      <td>25000.000000</td>\n",
       "      <td>25000.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>12500.500000</td>\n",
       "      <td>67.993114</td>\n",
       "      <td>127.079421</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>7217.022701</td>\n",
       "      <td>1.901679</td>\n",
       "      <td>11.660898</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>1.000000</td>\n",
       "      <td>60.278360</td>\n",
       "      <td>78.014760</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>6250.750000</td>\n",
       "      <td>66.704397</td>\n",
       "      <td>119.308675</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>12500.500000</td>\n",
       "      <td>67.995700</td>\n",
       "      <td>127.157750</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>18750.250000</td>\n",
       "      <td>69.272958</td>\n",
       "      <td>134.892850</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>25000.000000</td>\n",
       "      <td>75.152800</td>\n",
       "      <td>170.924000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              Index  Height(Inches)  Weight(Pounds)\n",
       "count  25000.000000    25000.000000    25000.000000\n",
       "mean   12500.500000       67.993114      127.079421\n",
       "std     7217.022701        1.901679       11.660898\n",
       "min        1.000000       60.278360       78.014760\n",
       "25%     6250.750000       66.704397      119.308675\n",
       "50%    12500.500000       67.995700      127.157750\n",
       "75%    18750.250000       69.272958      134.892850\n",
       "max    25000.000000       75.152800      170.924000"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Index</th>\n",
       "      <th>Height(Inches)</th>\n",
       "      <th>Weight(Pounds)</th>\n",
       "      <th>height</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>65.78331</td>\n",
       "      <td>112.9925</td>\n",
       "      <td>5.48</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>71.51521</td>\n",
       "      <td>136.4873</td>\n",
       "      <td>5.96</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>69.39874</td>\n",
       "      <td>153.0269</td>\n",
       "      <td>5.78</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4</td>\n",
       "      <td>68.21660</td>\n",
       "      <td>142.3354</td>\n",
       "      <td>5.68</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5</td>\n",
       "      <td>67.78781</td>\n",
       "      <td>144.2971</td>\n",
       "      <td>5.65</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Index  Height(Inches)  Weight(Pounds)  height\n",
       "0      1        65.78331        112.9925    5.48\n",
       "1      2        71.51521        136.4873    5.96\n",
       "2      3        69.39874        153.0269    5.78\n",
       "3      4        68.21660        142.3354    5.68\n",
       "4      5        67.78781        144.2971    5.65"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train['height'] = train['Height(Inches)'].map(lambda inches: round(inches * 0.0833333, 2))\n",
    "train.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Index</th>\n",
       "      <th>Height(Inches)</th>\n",
       "      <th>Weight(Pounds)</th>\n",
       "      <th>height</th>\n",
       "      <th>weight</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>65.78331</td>\n",
       "      <td>112.9925</td>\n",
       "      <td>5.48</td>\n",
       "      <td>51.25</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>71.51521</td>\n",
       "      <td>136.4873</td>\n",
       "      <td>5.96</td>\n",
       "      <td>61.91</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>69.39874</td>\n",
       "      <td>153.0269</td>\n",
       "      <td>5.78</td>\n",
       "      <td>69.41</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4</td>\n",
       "      <td>68.21660</td>\n",
       "      <td>142.3354</td>\n",
       "      <td>5.68</td>\n",
       "      <td>64.56</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5</td>\n",
       "      <td>67.78781</td>\n",
       "      <td>144.2971</td>\n",
       "      <td>5.65</td>\n",
       "      <td>65.45</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Index  Height(Inches)  Weight(Pounds)  height  weight\n",
       "0      1        65.78331        112.9925    5.48   51.25\n",
       "1      2        71.51521        136.4873    5.96   61.91\n",
       "2      3        69.39874        153.0269    5.78   69.41\n",
       "3      4        68.21660        142.3354    5.68   64.56\n",
       "4      5        67.78781        144.2971    5.65   65.45"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train['weight'] = train['Weight(Pounds)'].map(lambda pounds: round(pounds * 0.453592, 2))\n",
    "train.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>height</th>\n",
       "      <th>weight</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>5.48</td>\n",
       "      <td>51.25</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>5.96</td>\n",
       "      <td>61.91</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>5.78</td>\n",
       "      <td>69.41</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>5.68</td>\n",
       "      <td>64.56</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5.65</td>\n",
       "      <td>65.45</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   height  weight\n",
       "0    5.48   51.25\n",
       "1    5.96   61.91\n",
       "2    5.78   69.41\n",
       "3    5.68   64.56\n",
       "4    5.65   65.45"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = train[['height', 'weight']]\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25000"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(df.index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0xe0eb950>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.scatter(df['height'], df['weight'])\n",
    "plt.title('Height Weight Scatter Plot')\n",
    "plt.xlabel('Height (in feet)')\n",
    "plt.ylabel('Weight (in kgs)')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy import stats\n",
    "\n",
    "slope, intercept, r_value, p_value, std_err = stats.linregress(df['height'], df['weight'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.25286289315595617"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r_value ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0xe1ab190>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def predict(x):\n",
    "    return slope * x + intercept\n",
    "\n",
    "fitLine = predict(df['height'])\n",
    "\n",
    "plt.scatter(df['height'], df['weight'])\n",
    "plt.plot(df['height'], fitLine, c='r')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "#now 2nd resume analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Degree</th>\n",
       "      <th>Grade</th>\n",
       "      <th>Work Experience</th>\n",
       "      <th>Referral</th>\n",
       "      <th>Shortlisted</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>BTech</td>\n",
       "      <td>50</td>\n",
       "      <td>4</td>\n",
       "      <td>N</td>\n",
       "      <td>N</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>MTech</td>\n",
       "      <td>40</td>\n",
       "      <td>4</td>\n",
       "      <td>N</td>\n",
       "      <td>N</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>MTech</td>\n",
       "      <td>95</td>\n",
       "      <td>5</td>\n",
       "      <td>N</td>\n",
       "      <td>Y</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>BTech</td>\n",
       "      <td>80</td>\n",
       "      <td>4</td>\n",
       "      <td>N</td>\n",
       "      <td>Y</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>MTech</td>\n",
       "      <td>60</td>\n",
       "      <td>5</td>\n",
       "      <td>N</td>\n",
       "      <td>Y</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  Degree  Grade  Work Experience Referral Shortlisted\n",
       "0  BTech     50                4        N           N\n",
       "1  MTech     40                4        N           N\n",
       "2  MTech     95                5        N           Y\n",
       "3  BTech     80                4        N           Y\n",
       "4  MTech     60                5        N           Y"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn import tree\n",
    "\n",
    "input_file = \"./resume_shortlist.csv\"\n",
    "df = pd.read_csv(input_file, header = 0)\n",
    "\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Degree</th>\n",
       "      <th>Grade</th>\n",
       "      <th>Work Experience</th>\n",
       "      <th>Referral</th>\n",
       "      <th>Shortlisted</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>50</td>\n",
       "      <td>4</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>40</td>\n",
       "      <td>4</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "      <td>95</td>\n",
       "      <td>5</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0</td>\n",
       "      <td>80</td>\n",
       "      <td>4</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1</td>\n",
       "      <td>60</td>\n",
       "      <td>5</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Degree  Grade  Work Experience  Referral  Shortlisted\n",
       "0       0     50                4         0            0\n",
       "1       1     40                4         0            0\n",
       "2       1     95                5         0            1\n",
       "3       0     80                4         0            1\n",
       "4       1     60                5         0            1"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = {'Y': 1, 'N': 0}\n",
    "df['Shortlisted'] = df['Shortlisted'].map(d)\n",
    "df['Referral'] = df['Referral'].map(d)\n",
    "\n",
    "d = {'BTech': 0, 'MTech': 1}\n",
    "df['Degree'] = df['Degree'].map(d)\n",
    "\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['Degree', 'Grade', 'Work Experience', 'Referral'], dtype='object')"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "features = df.columns[:4]\n",
    "features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = df[\"Shortlisted\"]\n",
    "X = df[features]\n",
    "clf = tree.DecisionTreeClassifier()\n",
    "clf = clf.fit(X,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1]\n"
     ]
    }
   ],
   "source": [
    "print(clf.predict([[1, 90, 3, 1]]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0]\n"
     ]
    }
   ],
   "source": [
    "print(clf.predict([[0, 30, 5, 0]]))"
   ]
  }
 ],
 "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}