SMUMSE_ProgWorkshop_Lesson2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SMU Master of Science (Economics) Programming Workshop in Python\n",
    "\n",
    "\n",
    "## Introduction\n",
    "In today's class, we will be learning more about Loops, Conditional Statements, Functions and Classes. In the previous class, we have seen some simple applications of loops and functions. Today, we will learn about them in more detail.\n",
    "\n",
    "We being our discussion with loops."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### For and While Loops\n",
    "\n",
    "There are typically 2 types of loops: \"For\" and \"While\" loops.\n",
    "\n",
    "\"For\" loops are traditionally used when you have a block of code which you want to repeat a fixed number of times. The Python \"for\" statement iterates over the elements of a list or dictionary, and executes the code block for each element.\n",
    "\n",
    "\"While\" loops are typically used when a condition needs to be checked at every iteration i.e. checking for convergence or stability."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "154\n",
      "149\n",
      "130\n",
      "128\n",
      "160\n"
     ]
    }
   ],
   "source": [
    "# y is typically a data structure, such a list or a dictionary that you want to loop/iterated over\n",
    "# x x is the \"pointed\" observation\n",
    "\n",
    "heights = [154, 149, 130, 128, 160]\n",
    "\n",
    "for _ in heights:\n",
    "    # The 4 spaces following the for loop signifies that code written here will only be executed in the for loop\n",
    "    print(_)\n",
    "    # once print(x) is executed, we move on to the next observation\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "James\n",
      "Daniel\n",
      "Ahmad\n",
      "Clarissa\n",
      "Douglas\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "# Suppose we have a list of names, and we want to find out how many names have more than 4 letters\n",
    "names = ['James', 'Daniel', 'Jane', 'Ahmad', 'Tan', 'Clarissa', 'Douglas', 'Gina']\n",
    "\n",
    "names_more_than_4_letters = 0\n",
    "for name in names: # We iterate over each name in the list, and if the element has longer than 4 letters, we add 1 to the count\n",
    "    if len(name) > 4: \n",
    "        print(name)\n",
    "        names_more_than_4_letters += 1 # add 1 to the variable,  names_more_than_4_letters\n",
    "\n",
    "print(names_more_than_4_letters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'James'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "names[1] # index number 1 corresponds to Daniel\n",
    "names[0] # index number 1 corresponds to James"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "172"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "height[\"Douglas\"] # index number 1 corresponds to James"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "James 180\n",
      "Jane 157\n",
      "Clarissa 162\n",
      "Douglas 172\n",
      "Gina 175\n",
      "180\n",
      "157\n",
      "162\n",
      "172\n",
      "175\n"
     ]
    }
   ],
   "source": [
    "height = {\n",
    "    'James': 180, \n",
    "    'Jane': 157, \n",
    "    'Clarissa': 162, \n",
    "    'Douglas': 172, \n",
    "    'Gina': 175\n",
    "}\n",
    "\n",
    "keylist = list(height.keys()) # returns a list of the keys in the heights dictionary\n",
    "for key in keylist:\n",
    "    # Getting the keys and values for each observation\n",
    "    print(key, height[key])\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['James', 'Jane', 'Clarissa', 'Douglas', 'Gina'])\n",
      "James has a height of more than 160cm.\n",
      "Clarissa has a height of more than 160cm.\n",
      "Douglas has a height of more than 160cm.\n",
      "Gina has a height of more than 160cm.\n"
     ]
    }
   ],
   "source": [
    "# We can loop over a dictionary too\n",
    "# Suppose we are interested in finding out the names of those who are taller than 160cm\n",
    "height = {\n",
    "    'James': 180, \n",
    "    'Jane': 157, \n",
    "    'Clarissa': 162, \n",
    "    'Douglas': 172, \n",
    "    'Gina': 175\n",
    "}\n",
    "\n",
    "print(height.keys())\n",
    "    \n",
    "for name in height.keys(): # we iterate over the keys (names) in the dictionary, recall that dict[key] returns value\n",
    "    if height['Jane'] > 160:\n",
    "        # From this indent on, code will execute when condition is satisfied\n",
    "        print(name, 'has a height of more than 160cm.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Construct a dictionary with 6 students and 6 different weights.\n",
    "\n",
    "If the weight is larger than 50 (have 3 students with weight > 50 and 3 students with weight < 50), sum them up. \n",
    "Otherwise, dont' do anything.\n",
    "\n",
    "Regardless of their weight, print their names out."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "James\n",
      "Jane\n",
      "Clarissa\n",
      "Douglas\n",
      "Gina\n",
      "Kane\n",
      "226\n"
     ]
    }
   ],
   "source": [
    "weight = {\n",
    "    'James': 60, \n",
    "    'Jane': 40, \n",
    "    'Clarissa': 38, \n",
    "    'Douglas': 51, \n",
    "    'Gina': 62,\n",
    "    'Kane': 53\n",
    "}\n",
    "\n",
    "total_weight = 0\n",
    "for name in weight.keys(): # we iterate over the keys (names) in the dictionary, recall that dict[key] returns value\n",
    "    if weight[name] > 50:\n",
    "        total_weight += weight[name]\n",
    "        # From this indent on, code will execute when condition is satisfied\n",
    "    print(name)\n",
    "\n",
    "print(total_weight)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Problem: I want to sum all numbers from 1 to 50. How do I do that?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1275"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n = 50\n",
    "\n",
    "sum_n = 0\n",
    "\n",
    "# range(1, n+1) creates a list from 1 to n\n",
    "for num in range(1,n+1):\n",
    "    sum_n += num\n",
    "    \n",
    "sum_n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration:  1 Total:  1\n",
      "Iteration:  2 Total:  3\n",
      "Iteration:  3 Total:  6\n",
      "Iteration:  4 Total:  10\n",
      "Iteration:  5 Total:  15\n",
      "Iteration:  6 Total:  21\n",
      "Iteration:  7 Total:  28\n",
      "Iteration:  8 Total:  36\n",
      "Iteration:  9 Total:  45\n",
      "Iteration:  10 Total:  55\n",
      "Iteration:  11 Total:  66\n",
      "Iteration:  12 Total:  78\n",
      "Iteration:  13 Total:  91\n",
      "Iteration:  14 Total:  105\n",
      "Iteration:  15 Total:  120\n",
      "Iteration:  16 Total:  136\n",
      "Iteration:  17 Total:  153\n",
      "Iteration:  18 Total:  171\n",
      "Iteration:  19 Total:  190\n",
      "Iteration:  20 Total:  210\n",
      "Iteration:  21 Total:  231\n",
      "Iteration:  22 Total:  253\n",
      "Iteration:  23 Total:  276\n",
      "Iteration:  24 Total:  300\n",
      "Iteration:  25 Total:  325\n",
      "Iteration:  26 Total:  351\n",
      "Iteration:  27 Total:  378\n",
      "Iteration:  28 Total:  406\n",
      "Iteration:  29 Total:  435\n",
      "Iteration:  30 Total:  465\n",
      "Iteration:  31 Total:  496\n",
      "Iteration:  32 Total:  528\n",
      "Iteration:  33 Total:  561\n",
      "Iteration:  34 Total:  595\n",
      "Iteration:  35 Total:  630\n",
      "Iteration:  36 Total:  666\n",
      "Iteration:  37 Total:  703\n",
      "Iteration:  38 Total:  741\n",
      "Iteration:  39 Total:  780\n",
      "Iteration:  40 Total:  820\n",
      "Iteration:  41 Total:  861\n",
      "Iteration:  42 Total:  903\n",
      "Iteration:  43 Total:  946\n",
      "Iteration:  44 Total:  990\n",
      "Iteration:  45 Total:  1035\n",
      "Iteration:  46 Total:  1081\n",
      "Iteration:  47 Total:  1128\n",
      "Iteration:  48 Total:  1176\n",
      "Iteration:  49 Total:  1225\n",
      "Iteration:  50 Total:  1275\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1275"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Suppose we want to sum integers from 1 to n\n",
    "n = 50 # terminal condition\n",
    "count = 0 # counter (how many times have we looped over)\n",
    "\n",
    "sum_n = 0 # counter (total sum)\n",
    "iteration = 0 # placeholder\n",
    "\n",
    "while count < n: # While the 'count' variable is less than n, continue running. Otherwise, stop.\n",
    "    # Iteration 49\n",
    "    iteration += 1 # iteration has a value of 49+1 = 50\n",
    "    count += 1 # count has a value of 49+1=50\n",
    "    sum_n += count # in the second iteration, count = 50, sum_n = 1+2+3...+48+49+50\n",
    "    print('Iteration: ', iteration, \"Total: \", sum_n)\n",
    "    \n",
    "sum_n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1275"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Of course, this can be done with a for-loop as well\n",
    "n = 50\n",
    "\n",
    "total = 0\n",
    "for num in range(n+1):\n",
    "    total += num\n",
    "\n",
    "total"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Besides lists and dictionaries, one can also loop through the characters in a string. \n",
    "\n",
    "In addition, we can use the range function on an integer (say, n) to loop through the numbers 0 to n-1. Again, this is due to the 0-indexing of Python. \n",
    "\n",
    "Below, we show how both methods are done:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "H\n",
      "e\n",
      "l\n",
      "l\n",
      "o\n",
      " \n",
      "W\n",
      "o\n",
      "r\n",
      "l\n",
      "d\n",
      ".\n"
     ]
    }
   ],
   "source": [
    "new_string = 'Hello World.'\n",
    "for char in new_string:\n",
    "    print(char)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'l'"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_string[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At times, one may find it useful to keep the index of the list when looping over. While one may use counts to keep count, we can also use the function, `enumerate`. \n",
    "\n",
    "The function `enumerate` (which works only in a loop) takes a list as its argument, and returns the element and its index at each iteration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 Arthur\n",
      "1 Bob\n",
      "2 Charlie\n",
      "3 Dennis\n"
     ]
    }
   ],
   "source": [
    "name_list = ['Arthur', 'Bob', 'Charlie', 'Dennis']\n",
    "\n",
    "idx = 0 # counter for my index\n",
    "for name in name_list:\n",
    "    print(idx, name)\n",
    "    idx += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 Arthur\n",
      "1 Bob\n",
      "2 Charlie\n",
      "3 Dennis\n"
     ]
    }
   ],
   "source": [
    "name_list = ['Arthur', 'Bob', 'Charlie', 'Dennis']\n",
    "\n",
    "for idx, name in enumerate(name_list):\n",
    "    print(idx,name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A 70 B\n",
      "B 80 A-\n",
      "C 90 A\n",
      "D 95 A+\n",
      "E 95 A+\n"
     ]
    }
   ],
   "source": [
    "names = ['A', 'B', 'C', 'D', 'E'] # 5 observations\n",
    "scores = [70, 80, 90, 95, 95, 100] # 6 observations\n",
    "grades = ['B', 'A-', 'A', 'A+', 'A+', 'A*', 'A*'] # 7 observations\n",
    "\n",
    "# a is a pointer for names, b is a pointer for scores, c is a pointer for grades\n",
    "for a, b, c in zip(names, scores, grades): \n",
    "    print(a, b, c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Arthur is index number 0 in the class list.\n",
      "Bob is index number 1 in the class list.\n",
      "Charlie is index number 2 in the class list.\n",
      "Dennis is index number 3 in the class list.\n"
     ]
    }
   ],
   "source": [
    "idx = 0\n",
    "for name in name_list:\n",
    "    print(name, 'is index number', idx, 'in the class list.')\n",
    "    idx += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conditional Statements\n",
    "\n",
    "Conditional statements are executed whenever a condition is satisfied. We typically do this in the form of an if-else statement, where a specific chunk of code is executed only if the condition for it to be executed is met. Otherwise, the chunk of code is skipped. \n",
    "\n",
    "Here's an image representation of an if-only statement:\n",
    "\n",
    "![](images/flowchart_if_only.png \"If-Only Statements\")\n",
    "\n",
    "\n",
    "Here's an image representation of an if-else statement:\n",
    "\n",
    "![](images/flowchart_if_else.png \"If-Else Statements\")\n",
    "\n",
    "Application:\n",
    "Given some data, one might, for example, be interested to subset the data based on a person's test result to identify who might require additional tuition. In that case, one way to do so will be to use conditional statements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "# In this example, we are provided with data in the form of a dictionary where the \n",
    "# keys are the names of the students and the values are the test results of the students. \n",
    "# As the teacher, you are interested in those that score below x marks which can be defined by user.\n",
    "\n",
    "test_results = {\n",
    "    'Amy': 68,\n",
    "    'Jason': 41,\n",
    "    'Priscilla': 48,\n",
    "    'Daniel': 89,\n",
    "    'Katie': 95,\n",
    "    'Ryan': 28,\n",
    "    'Dennis': 64\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jason has scored below 50 marks.\n",
      "Priscilla has scored below 50 marks.\n",
      "Ryan has scored below 50 marks.\n"
     ]
    }
   ],
   "source": [
    "# One way to find out who scored below x is to use conditional statements. Below, we show 1 way to do thisL\n",
    "pass_score = 50\n",
    "\n",
    "for name in test_results.keys(): # iterate over all students in the class\n",
    "    if test_results[name] < pass_score: # check if the student's score is above or below some threshold\n",
    "        print(name, 'has scored below', pass_score, 'marks.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "68"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_results['Amy']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It appears that Jason, Priscilla and Ryan require additional attention, and possibly tuition. Note what happens to the students who scored above 50 marks - there was no output. Since we did not include an \"else\" statement, the previous code block did not have any action to execute for students who scored above 50 marks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Amy has scored >= 50 marks.\n",
      "Jason has scored below 50 marks.\n",
      "Priscilla has scored below 50 marks.\n",
      "Daniel has scored >= 50 marks.\n",
      "Katie has scored >= 50 marks.\n",
      "Ryan has scored below 50 marks.\n",
      "Dennis has scored >= 50 marks.\n"
     ]
    }
   ],
   "source": [
    "# One way to find out who scored below x is to use conditional statements. Below, we show 1 way to do thisL\n",
    "pass_score = 50\n",
    "\n",
    "for name in test_results.keys(): # iterate over all students in the class\n",
    "    if test_results[name] < pass_score: # check if the student's score is above or below some threshold\n",
    "        print(name, 'has scored below', pass_score, 'marks.') # Either in this category\n",
    "    else:\n",
    "        print(name, 'has scored >=', pass_score, 'marks.') # In this category"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Suppose we want to give more tuition to students who are failing, and reward students who are performing well (scoring above 80). How we can write this in 1 block of code? We can use the 'elif' conditional statement, which stands for else-if."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Amy has scored 68 marks.\n",
      "Jason has scored below 50 marks. Please come back during summer for tuition.\n",
      "Priscilla has scored below 50 marks. Please come back during summer for tuition.\n",
      "Daniel has scored above 80 marks. Well done!\n",
      "Katie scored > 90\n",
      "Ryan has scored below 50 marks. Please come back during summer for tuition.\n",
      "Dennis has scored 64 marks.\n"
     ]
    }
   ],
   "source": [
    "good_score = 80\n",
    "best_score = 90\n",
    "\n",
    "for name in test_results.keys():\n",
    "    # First category, you failed, score < 50\n",
    "    if test_results[name] < pass_score:\n",
    "        print(name, 'has scored below', pass_score, 'marks. Please come back during summer for tuition.')\n",
    "    \n",
    "    # After first group, people who passed are remaining\n",
    "    \n",
    "    # Code from here on only applies to students who passed\n",
    "    # Second Category, score > 90\n",
    "    elif test_results[name] >= best_score:\n",
    "        print(name, 'scored >', best_score)\n",
    "        \n",
    "    # Only people who scored between 50 and 90 are remaining\n",
    "        \n",
    "    # Third Category, only for people who scored between 80 and 90\n",
    "    elif test_results[name] >= good_score:\n",
    "        print(name, 'has scored above %d marks. Well done!' % good_score)\n",
    "        \n",
    "    # Only people who scored between 50 and 80 remains\n",
    "    \n",
    "    # Final Category 50 < score < 80\n",
    "    else:\n",
    "        print(name, 'has scored %d marks.' % test_results[name])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "good_score = 80\n",
    "best_score = 90\n",
    "\n",
    "for name in test_results.keys():\n",
    "    # First category, you failed, score < 50\n",
    "    if test_results[name] < pass_score:\n",
    "        print(name, 'has scored below', pass_score, 'marks. Please come back during summer for tuition.')\n",
    "    \n",
    "    # After first group, people who passed are remaining\n",
    "    \n",
    "    # Third Category, only for people who scored more than 80\n",
    "    elif test_results[name] >= good_score:\n",
    "        print(name, 'has scored above %d marks. Well done!' % good_score)\n",
    "    \n",
    "    # After second group, only people who scored between 50 and 80 are left\n",
    "\n",
    "    # Code from here on only applies to students who scored more than 90\n",
    "    elif test_results[name] >= best_score:\n",
    "        print(name, 'scored >', best_score)\n",
    "    \n",
    "    # Final Category 50 < score < 80\n",
    "    else:\n",
    "        print(name, 'has scored %d marks.' % test_results[name])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There's no limit as to how many 'elif' statements we choose to include in the loop itself. One can add as many as one needs, but it comes at the expense of readability.\n",
    "\n",
    "Another useful concept is that of 'continue' and 'break'. \n",
    "\n",
    "The `continue` call moves on to the next iteration, while the `break` call exits the loop once some condition is met. This is best illustrated by means of an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 ['1996', '2019', '2018', '16', '94', '1997', '08', '92', '90', '2011', '09', '1993', '95']\n",
      "3 ['1996', '2019', '2018', '2016', '94', '1997', '08', '92', '90', '2011', '09', '1993', '95']\n",
      "4 ['1996', '2019', '2018', '2016', '1994', '1997', '08', '92', '90', '2011', '09', '1993', '95']\n",
      "6 ['1996', '2019', '2018', '2016', '1994', '1997', '2008', '92', '90', '2011', '09', '1993', '95']\n",
      "7 ['1996', '2019', '2018', '2016', '1994', '1997', '2008', '1992', '90', '2011', '09', '1993', '95']\n",
      "8 ['1996', '2019', '2018', '2016', '1994', '1997', '2008', '1992', '1990', '2011', '09', '1993', '95']\n",
      "10 ['1996', '2019', '2018', '2016', '1994', '1997', '2008', '1992', '1990', '2011', '2009', '1993', '95']\n",
      "12 ['1996', '2019', '2018', '2016', '1994', '1997', '2008', '1992', '1990', '2011', '2009', '1993', '1995']\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['1996',\n",
       " '2019',\n",
       " '2018',\n",
       " '2016',\n",
       " '1994',\n",
       " '1997',\n",
       " '2008',\n",
       " '1992',\n",
       " '1990',\n",
       " '2011',\n",
       " '2009',\n",
       " '1993',\n",
       " '1995']"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Suppose we are interested in converting the dates to YYYY format from YY format\n",
    "# We also know that the list contains data from 1990 - 2019\n",
    "dates = ['1996', '2019', '18', '16', '94', '1997', '08', '92', '90', '2011', '09', '1993', '95']\n",
    "\n",
    "for idx, date in enumerate(dates):\n",
    "    if len(date) == 4: continue # Go to the next iteration; there's nothing to do here (what happens if we omit this?)\n",
    "    else:\n",
    "        if int(date) + 10 >= 100: newdate = '19' + date\n",
    "        else: newdate = '20' + date\n",
    "    dates[idx] = newdate # change the i-th element of the list to the new date (after cleaning)\n",
    "    print(idx, dates)\n",
    "    \n",
    "dates"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loops + Conditional Statements\n",
    "\n",
    "Loops can be combined with conditional statements to replicate more complicated structures that cannot be achieved simply by using either one alone. \n",
    "\n",
    "For example, consider the case where we have 2 lists: \n",
    "1. a list containing the gender of the students, and \n",
    "2. another list containing the scores obtained by the students on a test\n",
    "\n",
    "We are interested in finding out which gender performed better on the test. It is easily to see that using either loops or conditional statements do not give us the result we want easily. This case can easily be generalized to policy changes (Treatment vs Control) etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "F 36\n",
      "F 44\n",
      "M 32\n",
      "F 31\n",
      "M 45\n",
      "F 41\n",
      "M 27\n",
      "The average score for males is 34.666666666666664\n",
      "The average score for females is 38.0\n"
     ]
    }
   ],
   "source": [
    "# Suppose we are given 2 lists, one with the gender of the student and 1 with the score of the student\n",
    "# We are trying to find the mean score for both genders\n",
    "genders = ['F', 'F', 'M', 'F', 'M', 'F', 'M']\n",
    "scores = [36, 44, 32, 31, 45, 41, 27]\n",
    "\n",
    "count_M = 0 \n",
    "count_F = 0\n",
    "total_M = 0 \n",
    "total_F = 0\n",
    "\n",
    "for gender, score in zip(genders, scores):\n",
    "    print(gender, score)\n",
    "    if gender == 'M': # to check whether it is a value, we use 2 \"equal\" signs\n",
    "        count_M += 1\n",
    "        total_M += score\n",
    "    else:\n",
    "        count_F += 1\n",
    "        total_F += score\n",
    "        \n",
    "print('The average score for males is', str(total_M/count_M))\n",
    "print('The average score for females is', str(total_F/count_F))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also use `zip` to iterate over multiple lists with the same length. Here, we apply the function `zip` to the 2 lists:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In-class assignment:\n",
    "\n",
    "You are given the following dataset:\n",
    "\n",
    "|Name  | Height | Gender| Weight| School | Scores |\n",
    "|------|--------|-------|-------|--------|--------|\n",
    "|Jane  | 155.0  |   F   |  42.8 |  SMU   |  87.5  |\n",
    "|John  | 181.2  |   M   |  85.1 |  NTU   |  81.2  |\n",
    "|Tina  | 172.6  |   F   |  52.7 |  NUS   |  76.1  |\n",
    "|Lena  | 162.3  |   F   |  49.0 |  SMU   |  88.3  |\n",
    "|Kane  | 174.8  |   M   |  77.1 |  NUS   |  91.2  |\n",
    "|Ryan  | 172.3  |   M   |  82.6 |  NTU   |  77.6  |\n",
    "|Kate  | 151.8  |   F   |  45.2 |  SMU   |  82.5  |\n",
    "\n",
    "1. Find the difference between the average weights and heights of males and females.\n",
    "\n",
    "**In-class assignment**\n",
    "1. Find the difference between the maximum scores of males in NUS and females in SMU.\n",
    "2. Find the difference in the mean scores of males in NTU and females in NUS."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "88.3 91.2\n"
     ]
    }
   ],
   "source": [
    "max_smu_female_score = 0\n",
    "# Two ways of doing 2 conditions at the same time\n",
    "for gender, school, score in zip(genders, schools, scores):\n",
    "    if (gender == 'F') and (school == 'SMU'):\n",
    "        # Keep track of the largest score, check if it's larger than the current one\n",
    "        if score > max_smu_female_score:\n",
    "            max_smu_female_score = score # Update the score if it's the largest we have seen\n",
    "\n",
    "max_nus_male_score = 0\n",
    "for gender, school, score in zip(genders, schools, scores):\n",
    "    if (gender == 'M') and (school == 'NUS'):\n",
    "        # Keep track of the largest score, check if it's larger than the current one\n",
    "        if score > max_nus_male_score:\n",
    "            max_nus_male_score = score # Update the score if it's the largest we have seen\n",
    "            \n",
    "print(max_smu_female_score, max_nus_male_score)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.9000000000000057"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Please submit your work here\n",
    "genders = ['F', 'M', 'F', 'F', 'M', 'M', 'F']\n",
    "schools = ['SMU', 'NTU', 'NUS', 'SMU', 'NUS', 'NTU', 'SMU']\n",
    "scores  = [87.5, 81.2, 76.1, 88.3, 91.2, 77.6, 82.5]\n",
    "\n",
    "# Question 1\n",
    "count_nus_males = 0\n",
    "lst_nus_males = []\n",
    "count_smu_females = 0\n",
    "lst_smu_females = []\n",
    "\n",
    "for gender, school, score in zip(genders, schools, scores):\n",
    "    if (gender == 'F') and (school == 'SMU'):\n",
    "        count_smu_females += 1\n",
    "        lst_smu_females.append(score)\n",
    "    elif (gender == 'M') and (school == 'NUS'):\n",
    "        count_nus_males += 1\n",
    "        lst_nus_males.append(score)\n",
    "        \n",
    "max(lst_nus_males) - max(lst_smu_females)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "83.33333333333333 83.6\n",
      "86.10000000000001 79.4\n"
     ]
    }
   ],
   "source": [
    "# Please submit your work here\n",
    "genders = ['F', 'M', 'F', 'F', 'M', 'M', 'F']\n",
    "schools = ['SMU', 'NTU', 'NUS', 'SMU', 'NUS', 'NTU', 'SMU']\n",
    "scores  = [87.5, 81.2, 76.1, 88.3, 91.2, 77.6, 82.5]\n",
    "\n",
    "### Q1 ###\n",
    "count_M = 0\n",
    "count_F = 0\n",
    "\n",
    "total_M = 0\n",
    "total_F = 0\n",
    "\n",
    "for gender, score in zip(genders, scores):\n",
    "    if gender == 'M':\n",
    "        count_M += 1\n",
    "        total_M += score\n",
    "    else:\n",
    "        count_F += 1\n",
    "        total_F += score\n",
    "\n",
    "print(total_M/count_M, total_F/count_F)\n",
    "\n",
    "### Q2 ###\n",
    "count_SMU = 0\n",
    "count_NTU = 0\n",
    "\n",
    "total_SMU = 0\n",
    "total_NTU = 0\n",
    "for school, score in zip(schools, scores):\n",
    "    if school == 'SMU':\n",
    "        count_SMU += 1\n",
    "        total_SMU += score\n",
    "    elif school == 'NTU':\n",
    "        count_NTU += 1\n",
    "        total_NTU += score\n",
    "\n",
    "print(total_SMU/count_SMU, total_NTU/count_NTU)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Functions\n",
    "Now that we have a working understanding of how loops and conditional statements work, we are ready to move on to functions and classes. \n",
    "\n",
    "\n",
    "We begin this module with a simple question: what exactly are functions?\n",
    "\n",
    "From [w3schools](https://www.w3schools.com/python/python_functions.asp), a function is a block of code which only runs when it is called. While this doesn't actually say much, it kind of implies that a function consists of proper code that can do whatever you want it to do, so long as it is computationally probable and possible. \n",
    "\n",
    "So far, we've seen quite a few functions:\n",
    "\n",
    "1. print( )\n",
    "2. range( )\n",
    "3. list( )\n",
    "4. dict( )\n",
    "5. len( )\n",
    "6. zip( )\n",
    "7. int( )\n",
    "8. float( )\n",
    "\n",
    "What do they have in common? Apart from the fact that they turn green when you type them in the Jupyter Notebook, they have round brackets ( ), which we can then input arguments for the functions. This begs the question: what exactly is an argument, then? \n",
    "\n",
    "Before we answer that question, we appeal to the '?' function in Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "?int()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "35"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(float(\"35.2\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The '?' function in Python returns the documentation string for the function. For our previous example, we called the '?' function on the argument, int( ). It then returns the documentation string for the int function. From the documentation string, we know that int converts a number or a string to an integer, and returns 0 when no arguments are given. For floating point numbers (decimals), it truncates towards 0 (rounds down). Let's give it a try."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "print(int(6.9999))\n",
    "print(int())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It worked! Now, this is one way to find out what a function is doing under the hood. The next time you have problems with certain functions, be sure to use this function to find out what exactly the function takes as arguments, and what it outputs.\n",
    "\n",
    "In the following examples, I define a function that adds variables together, or calculates the mean of the variables in a list. There are many different ways to write a particular function. Some are preferred because of their readability, while others are preferred because of their computational timings.\n",
    "\n",
    "Do try to follow what's going on, as functions are pretty central to programming. Do note how loops and conditional statements are used (although not all functions require them) in this context."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add(x, y):\n",
    "    '''\n",
    "    Given x and y, returns x + y\n",
    "    '''\n",
    "    # return x, y can return more than 1 output\n",
    "    return x + y # here, x and y can both be integers or strings, but not 1 of each type\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add(3, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_mean(lst):\n",
    "    '''\n",
    "    Given a list, returns x, the mean of the values.\n",
    "    \n",
    "    Parameters: lst (list) containing only integers and/or float values\n",
    "    Output: x (float value).\n",
    "    '''\n",
    "    only_int_or_float = True\n",
    "    if type(lst) != list: return 'Please provide a list.'\n",
    "    \n",
    "    for num in lst:\n",
    "        # Check if it's a float or num\n",
    "        if type(num) != float and type(num) != int: \n",
    "            only_int_or_float = False\n",
    "    \n",
    "    if only_int_or_float is True: \n",
    "        return sum(lst)/len(lst)\n",
    "    else: \n",
    "        return 'Please provide a list with integers and/or float values.'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_mean(lst):\n",
    "    '''\n",
    "    Given a list, returns x, the mean of the values.\n",
    "    \n",
    "    Parameters: lst (list) containing only integers and/or float values\n",
    "    Output: x (float value).\n",
    "    '''\n",
    "    only_int_or_float = True\n",
    "    if type(lst) != list: return 'Please provide a list.'\n",
    "        \n",
    "    for num in lst:\n",
    "        if type(num) == float: continue\n",
    "        elif type(num) == int: continue\n",
    "        else: \n",
    "            only_int_or_float = False\n",
    "    \n",
    "    if only_int_or_float is True: \n",
    "        return sum(lst)/len(lst)\n",
    "    else: \n",
    "        return 'Please provide a list with integers and/or float values.'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What do we notice?\n",
    "1. def - def is short-form for the word, define. This tells Python that we are going to define a function.\n",
    "2. get_mean( ) - get_mean is the name of our function, which takes only 1 argument, a list.\n",
    "3. lst - lst is the sole argument used for the function, get_mean( ). In our case, we require lst to be a list.\n",
    "4. return - returns the output of interest (in this case, the mean of the list)\n",
    "\n",
    "We can include more than 1 argument for the function but for our example, this is not required."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Please provide a list with integers and/or float values.'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "names = ['Jane', 'John', 'Jack']\n",
    "get_mean(names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "210.66666666666666"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "height = [136, 246, 250]\n",
    "get_mean(height)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Please provide a list.'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k = 36\n",
    "get_mean(k)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's another example. This function acts almost exactly the same as the condition *num* >= 5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def larger_than_five(num):\n",
    "    '''\n",
    "    Returns True if the number provided is larger than 5 in value.\n",
    "    '''\n",
    "    if type(num) != int and type(num) != float: return 'Please input a number.'\n",
    "    \n",
    "    if num >= 5:\n",
    "        return True\n",
    "    else:\n",
    "        return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please input a number.\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(larger_than_five('six'))\n",
    "print(larger_than_five(6))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In-class assignment\n",
    "\n",
    "In what follows, you are required to design a function that receives a list and outputs the most popular character in the list. For example, the list could be ['Jack, 'Jason', 'Gina']. In this case, the most popular character is 'a', which appears 3 times. I have provided starter code for this assignment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "H\n",
      "e\n",
      "l\n",
      "l\n",
      "o\n",
      " \n",
      "W\n",
      "o\n",
      "r\n",
      "l\n",
      "d\n"
     ]
    }
   ],
   "source": [
    "for character in \"Hello World\":\n",
    "    print(character)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Jack', 'Jason', 'Gina']\n",
      "{'J': 1}\n",
      "{'J': 1, 'a': 1}\n",
      "{'J': 1, 'a': 1, 'c': 1}\n",
      "{'J': 1, 'a': 1, 'c': 1, 'k': 1}\n",
      "{'J': 2, 'a': 1, 'c': 1, 'k': 1}\n",
      "{'J': 2, 'a': 2, 'c': 1, 'k': 1}\n",
      "{'J': 2, 'a': 2, 'c': 1, 'k': 1, 's': 1}\n",
      "{'J': 2, 'a': 2, 'c': 1, 'k': 1, 's': 1, 'o': 1}\n",
      "{'J': 2, 'a': 2, 'c': 1, 'k': 1, 's': 1, 'o': 1, 'n': 1}\n",
      "{'J': 2, 'a': 2, 'c': 1, 'k': 1, 's': 1, 'o': 1, 'n': 1, 'G': 1}\n",
      "{'J': 2, 'a': 2, 'c': 1, 'k': 1, 's': 1, 'o': 1, 'n': 1, 'G': 1, 'i': 1}\n",
      "{'J': 2, 'a': 2, 'c': 1, 'k': 1, 's': 1, 'o': 1, 'n': 2, 'G': 1, 'i': 1}\n",
      "{'J': 2, 'a': 3, 'c': 1, 'k': 1, 's': 1, 'o': 1, 'n': 2, 'G': 1, 'i': 1}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "('a', 3)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import operator\n",
    "\n",
    "name_list = ['Jack', 'Jason', 'Gina']\n",
    "\n",
    "def most_popular_character(lst):\n",
    "    '''\n",
    "    Returns the most popular alphabet from the names provided in the list\n",
    "    '''\n",
    "    if type(lst) != list: return 'Please provide a list.'\n",
    "    \n",
    "    character_count = {} # a dictionary where each character is the key, and the frequency is the value\n",
    "    # Loops over the name of the list\n",
    "    for name in lst:\n",
    "        # Loops over the characters in the name\n",
    "        for char in name: # You can loop through strings too!\n",
    "            # Your code here\n",
    "            \n",
    "            # Case 1: I've seen this character before and it is in my dictionary\n",
    "            if char in character_count.keys():\n",
    "                character_count[char] += 1\n",
    "                print(character_count)\n",
    "            # Case 2: New character, never seen before\n",
    "            else:\n",
    "                character_count[char] = 1\n",
    "                print(character_count)\n",
    "    sorted_character_count = sorted(character_count.items(), key=operator.itemgetter(1), reverse=True)\n",
    "    return sorted_character_count[0]\n",
    "\n",
    "print(name_list)\n",
    "most_popular_character(name_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Advanced Application: Recursive Programming with Functions\n",
    "In this section, we will be using recursive programming to solve problems. Recursive programming uses the idea of repetition (using a function to call itself repeatedly, and thus yielding a recursive structure) to break problems into smaller problems and solving them.\n",
    "\n",
    "---\n",
    "\n",
    "#### Recursive Programming\n",
    "One way to see what Recursive Programming is doing is through the factorial problem. Suppose you wish to define a function, that takes as an integer as its rgument and returns the factorial of the integer. How do you do this? One way is the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "120"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def factorial(n):\n",
    "    if n == 0: return 1\n",
    "    elif n == 1: return 1\n",
    "    else:\n",
    "        return n * factorial(n-1)\n",
    "    \n",
    "factorial(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "120"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def factorial(n):\n",
    "    total = 1\n",
    "    for i in range(1, n+1):\n",
    "        total = total * i\n",
    "    return total\n",
    "\n",
    "factorial(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The previous problem gives a glimpse as to what Recursive Programming aims to do. By repeatedly calling itself, it is able to reduce a potentially difficult to solve problem into a \"linear\" problem (the difficulty of the problem is O(n), where n is the integer) by taking advantage of its recursive structure.\n",
    "\n",
    "However, while Recursive programming is one way to solve complicated problems such as the Fibonacci problem, it is by no means the only way. Sometimes, it can even be the \"bad\" way. In some sense, a \"bad\" way is one that either:\n",
    "\n",
    "1. is difficult to understand; and/or\n",
    "2. hard to interpret; and/or\n",
    "3. takes way longer to compute\n",
    "\n",
    "Consider the following problem:\n",
    "\n",
    "A Fibonacci sequence is the integer sequence of 0, 1, 1, 2, 3, 5, 8...., where each succeeding integer is the sum of the previous 2 integers. Suppose we are trying to solve for the number at the n-th index (in Python, that will be the (n-1)-th index) of the Fibonacci Sequence. How can we do this? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "179 ms ± 2.11 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
     ]
    }
   ],
   "source": [
    "# First, the Recursive Programming method.\n",
    "def fibonacci(n):\n",
    "    if n == 1: return 0\n",
    "    elif n == 2: return 1\n",
    "    elif n == 3: return 1\n",
    "    else: \n",
    "        return fibonacci(n-1) + fibonacci(n-2)\n",
    "\n",
    "n = 5\n",
    "\n",
    "%timeit fibonacci(30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16.9 µs ± 148 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "# As it turns out, recursive programming isn't very useful. How can we solve for this problem *more* efficiently?\n",
    "# One way to do this is through Dynamic Programming and memoization\n",
    "\n",
    "def fast_fibonacci(n):\n",
    "    if n == 1: return 0\n",
    "    elif n == 2: return 1\n",
    "    elif n == 3: return 1\n",
    "    else:\n",
    "        start = [0, 1, 1]\n",
    "        \n",
    "        # The follow for loop appends to the list the sum of the previous 2 items in the list\n",
    "        for num in range(2, n+1): # creates a list from [2, 3, ..., n]\n",
    "            start.append(start[num] + start[num-1])\n",
    "    return start[n]\n",
    "\n",
    "%timeit fast_fibonacci(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "102334155"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fibonacci(40)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "102334155"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fast_fibonacci(40)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Memoization refers to the idea of storing the results the computer has previously calculated (caching) so that it does not have to calculate them from scratch over and over again. \n",
    "\n",
    "In the first scenario, the results from `fibonacci(3)` dose not enter into the computation of `fibonacci(4)`. That is, when the computer is called upon to run `fibonacci(4)`, it calculates `fibonacci(3)` from scratch and adds that to `fibonacci(2)`.\n",
    "\n",
    "On the other hand, the second scenario \"memorizes\" the results obtained from `fast_fibonacci(3)`, making the computation of `fast_fibonacci(4)` that much easier.\n",
    "\n",
    "---\n",
    "In-class assignment:\n",
    "\n",
    "1. Define a **recursive** function that takes an argument, n, and returns the sum of the first n integers.\n",
    "2. Define a **dynamic** function that takes an argument, n, and returns the sum of the first n integers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "55"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def recursive_sum(n):\n",
    "    '''\n",
    "    This function takes an integer, n, as its input and returns the sum of the first n integers, \n",
    "    using recursive programming.\n",
    "    \n",
    "    Input: n, int\n",
    "    '''\n",
    "    # Your code here\n",
    "    if n == 0: return 0\n",
    "    \n",
    "recursive_sum(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "55"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def dynamic_sum(n):\n",
    "    '''\n",
    "    This function takes an integer, n, as its input and returns the sum of the first n integers,\n",
    "    using dynamic programming.\n",
    "    \n",
    "    Input: n, int\n",
    "    '''    \n",
    "    # Your code here\n",
    "    total = 0\n",
    "\n",
    "dynamic_sum(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dynamic Programming\n",
    "It turns out that recursive programming is not the most efficient way. If you don't believe me, try setting n = 40. In this case, Dynamic Programming is the superior method. This begs the question: what is dynamic programming? \n",
    "\n",
    "Dynamic Programming is a method for solving a complex problem by breaking it down into a collection of simpler subproblems, solving each of those subproblems just once, and storing (**memoizing**) their solutions using a memory-based data structure (taken from the [Use Journal Blog](https://blog.usejournal.com/top-50-dynamic-programming-practice-problems-4208fed71aa3)).\n",
    "\n",
    "Due to their difficulty (and the fact that this is only an introductory workshop), we will refrain from talking about Dynamic Programming."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Classes\n",
    "In layman terms, classes are objects that a programmer can create, and bestow upon these objects attributes (such as names, height, weight etc.) and **methods** (which are essentially functions for classes). It might help if we were to look at an example. To define a class, we can call *class* in Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Robot:\n",
    "    '''\n",
    "    Creates an instance of the robot when called. \n",
    "    \n",
    "    Robot has the following attributes:\n",
    "    1. Name\n",
    "    2. Favourite Drink\n",
    "    3. Favourite Activity\n",
    "    4. Location\n",
    "    \n",
    "    Robot has the following methods (methods it can use):\n",
    "    1. what: Returns the class of the robot\n",
    "    2. drink: Returns the favorite drink of the robot\n",
    "    3. location: Returns the location of the class\n",
    "    4. name: Returns the name of the robot\n",
    "    5. activity: Returns the favorite activity of the robot\n",
    "    '''\n",
    "    def __init__(self, name, drink, act, location): # in the initialization of a class, \"self\" needs to be the 1st arg.\n",
    "        # Since there are 4 attributes, we need 5 arguments (including \"self\")\n",
    "        self.name = name\n",
    "        self.drink = drink\n",
    "        self.activity = act\n",
    "        self.location = location\n",
    "        \n",
    "    # Methods of robots (what functions it can call)\n",
    "    def what(self): # calling this method returns the following command\n",
    "        return \"I am a robot.\"\n",
    "    \n",
    "    def fav_drink(self): \n",
    "        return self.drink\n",
    "    \n",
    "    def cur_location(self):\n",
    "        return self.location\n",
    "    \n",
    "    def cur_name(self):\n",
    "        return self.name\n",
    "    \n",
    "    def fav_activity(self):\n",
    "        return self.activity"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In what follows, we instantiate (create an instance of) a robot, with the name of the robot Julian, given as an argument. Our robot loves drinking diesel, and likes to party with friends. The __init__ method of our class tells what we need to provide to instantiate the class: we need to provide 4 arguments, a name, drink, activity and a location to create an instance of a robot. \"Self\" is already implicitly provided as an argument.\n",
    "\n",
    "After the creation of the robot, we have 5 methods that we can call. Methods are essentially functions, but for classes. That is, the first argument of a method is the class. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'I am a robot.'"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# In \n",
    "robot_1 = Robot(\"Julian\", \"Diesel\", \"Party\", \"Japan\")\n",
    "robot_2 = Robot(\"Julia\", \"Pepsi\", \"Sleeping\", \"Macpherson\")\n",
    "robot_1.what()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Diesel'"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "robot_1.fav_drink()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Julian'"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "robot_1.cur_name()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Macpherson'"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "robot_2.cur_location()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consider a new example, which is exactly the same as the previous example except for a new method `made_new_friends`. This function tells us whether our robot made a new friend, and if so, how many new friends it made. Initially, we initialised the robot with 0 friends, but with the inclusion of this function, the robot is allowed to make new friends."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Robot:\n",
    "    '''\n",
    "    Creates an instance of the robot when called. \n",
    "    \n",
    "    Robot has the following attributes:\n",
    "    1. Name\n",
    "    2. Favourite Drink\n",
    "    3. Favourite Activity\n",
    "    4. Location\n",
    "    \n",
    "    Robot has the following methods (functions it can call):\n",
    "    1. what: Returns the class of the robot\n",
    "    2. drink: Returns the favorite drink of the robot\n",
    "    3. location: Returns the location of the class\n",
    "    4. name: Returns the name of the robot\n",
    "    5. activity: Returns the favorite activity of the robot\n",
    "    '''\n",
    "    def __init__(self, name, drink, act, location, friends=0): # The default value of friends is set to 0 when instantiated\n",
    "        # Attributes of the robots\n",
    "        self.name = name # Name of robot\n",
    "        self.drink = drink # Name of fav. drink\n",
    "        self.activity = act # Name of fav. activity\n",
    "        self.location = location # Name of current location\n",
    "        self.friends = friends\n",
    "        \n",
    "    # Methods of robots (what functions it can call)\n",
    "    def what(self):\n",
    "        return \"I am a robot.\"\n",
    "    \n",
    "    def fav_drink(self):\n",
    "        return self.drink\n",
    "    \n",
    "    def cur_location(self):\n",
    "        return self.location\n",
    "    \n",
    "    def cur_name(self):\n",
    "        return self.name\n",
    "    \n",
    "    def fav_activity(self):\n",
    "        return self.activity\n",
    "    \n",
    "    def made_new_friends(self, n):\n",
    "        self.friends += n\n",
    "        return \"I have %d friends now.\" % self.friends\n",
    "    \n",
    "    def update_location(self, new_location): # This method allows us to update the loc of the robot with a new loc\n",
    "        print('I was at %s.' % self.location)\n",
    "        self.location = new_location\n",
    "        print(\"I am currently at %s.\" % self.location)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'I am a robot.'"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# In \n",
    "robot_1 = Robot(\"Julia\", \"Beer\", \"Party\", \"Robobar\")\n",
    "robot_1.what()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'I have 5 friends now.'"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(robot_1.friends)\n",
    "\n",
    "robot_1.made_new_friends(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "robot_1.friends"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I was at Robobar.\n",
      "I am currently at Chomp Chomp Hawker Center.\n"
     ]
    }
   ],
   "source": [
    "robot_1.update_location(\"Chomp Chomp Hawker Center\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It turns out that after attending some parties, Julia the Robot was able to make 5 friends! After drinking, she moved to a hawker center for some supper. \n",
    "\n",
    "Hopefully, this gives you a better idea of what classes are.\n",
    "\n",
    "---\n",
    "\n",
    "In-class assignment:\n",
    "\n",
    "Write up a class, \"Class\" that has the following attributes:\n",
    "1. Course Name, course_name\n",
    "2. Course Code, course_code\n",
    "3. Instructor Name, instructor_name\n",
    "4. Number of students, num_students\n",
    "5. Class Timings, class_timing\n",
    "\n",
    "The class should have the following methods:\n",
    "1. add_new_students (with argument: n (number of new students), int)\n",
    "2. remove_students (with argument: n (number of students removed), int)\n",
    "3. change_class_timings (with argument: new_timing, str)\n",
    "\n",
    "Instantiate the following classes, using the \"Class\" class:\n",
    "\n",
    "|   Course Name    | Code    |  Instructor Name   | No. of Students | Class Timings |\n",
    "|------------------|---------|--------------------|-----------------|---------------|\n",
    "|Microeconomics I  | ECON601 |  Takashi Kunimoto  |      20         | Mon 12:00pm   |\n",
    "|Econometrics I    | ECON611 |  Su Liangjun       |      18         | Tue 08:30am   |    \n",
    "|Mechanism Design  | ECON714 |  Shurojit Chatterji|       9         | Thu 15:30pm   |\n",
    "|Macroeconomics I  | ECON602 |  Nicolas Jacquet   |      11         | Wed 09:00am   |\n",
    "\n",
    "The following starter code has been provided. Do note that you should have 5 attributes, and 8 methods for your class (they are provided down in the starter code below)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "expected an indented block (<ipython-input-53-40178bd3622b>, line 33)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-53-40178bd3622b>\"\u001b[0;36m, line \u001b[0;32m33\u001b[0m\n\u001b[0;31m    def code(self):\u001b[0m\n\u001b[0m      ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m expected an indented block\n"
     ]
    }
   ],
   "source": [
    "class Class:\n",
    "    '''\n",
    "    Creates an instance of Class when called. \n",
    "    \n",
    "    Each class has the following attributes:\n",
    "    1. Course Name\n",
    "    2. Course Code\n",
    "    3. Instructor Name\n",
    "    4. Number of Students\n",
    "    5. Class Timings\n",
    "    \n",
    "    Robot has the following methods (functions it can call):\n",
    "    1. name: Returns the course name\n",
    "    2. code: Returns the course code\n",
    "    3. instructor_name: Returns the instructor name\n",
    "    4. no_of_students: Returns the number of students in the class\n",
    "    5. timing: Returns the class timing\n",
    "    6. add_new_students: Takes an input, n, and returns the total number of students in the class.\n",
    "    7. remove_students: Takes an input, n, and returns the total number of students left in the class.\n",
    "    8. change_class_timings: Takes an input, time, and returns the new timing of the class\n",
    "    '''\n",
    "    ## Your code here\n",
    "    def __init__(self, course_name, course_code, instructor_name, no_of_students, class_timings):\n",
    "        self.course_name = course_name\n",
    "        self.course_code = course_code\n",
    "        self.instructor_name = instructor_name\n",
    "        self.no_of_students = no_of_students\n",
    "        self.class_timings = class_timings\n",
    "        \n",
    "    def name(self):\n",
    "\n",
    "        \n",
    "    def code(self):\n",
    "\n",
    "        \n",
    "    def instructor_name(self):\n",
    "\n",
    "        \n",
    "    def no_of_students(self):\n",
    "\n",
    "        \n",
    "    def timing(self):\n",
    "\n",
    "        \n",
    "    def add_new_students(self, n):\n",
    "\n",
    "        \n",
    "    def remove_students(self, n):\n",
    "\n",
    "    \n",
    "    def change_class_timings(self, timing):\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The class has 15 students now.\n"
     ]
    }
   ],
   "source": [
    "micro_1 = Class('Microeconomics I', 'ECON 601', 'Takashi Kunimoto', 20, 'Mon 12:00pm')\n",
    "micro_1.remove_students(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The class has 14 students now.\n"
     ]
    }
   ],
   "source": [
    "md = Class('Mechanism Design', 'ECON 714', 'Shurojit Chatterji', 9, 'Thu 15:30pm')\n",
    "md.add_new_students(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Suppose there are some changes to the classes after the semester has commenced. Please reflect these changes:\n",
    "\n",
    "1. 5 students from ECON601 decided to switch to ECON714. Update this change using the methods, add_new_students and remove_students from the appropriate classes.\n",
    "2. Due to conflicting schedules, Professor Su Liangjun decided to change his classes from Tuesdays, 08:30am to Mondays, 15:30pm.\n",
    "3. 2 new students have joined Professor Nicolas Jacquet's class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The class starts at Mon 15:30pm now.\n"
     ]
    }
   ],
   "source": [
    "## Your code here\n",
    "econometrics = Class('Econometrics I', 'ECON 611', 'Su Liangjun', 18, 'Tue 08:30am')\n",
    "econometrics.change_class_timings('Mon 15:30pm')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The class starts at Mon 12:00pm now.\n"
     ]
    }
   ],
   "source": [
    "econometrics.change_class_timings('Mon 12:00pm')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}