Week 02 - Control Flow.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Week 02 - Control Flow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Drill\n",
    "Let us revise from last week's work. This mainly includes the basic syntax of Python, data types and operators. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What data type is `'social science'` using in Python? Use a Python code line to prove your answer. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compute 328 + 238 in Python. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a code to find all the odd numbered indices from the list `ls`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ls = [1, 3, 8, 9, 12, 13, 15]\n",
    "# Your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mary is packing 36 sandwiches into packs. Each pack has 5 sandwiches, how many can she pack? How many will remain? Use Python to show your answer. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Control Flow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The beauty of programming language is they can capture different inputes and give possibilities. For example, if the user input with the word `'cake'`, then the program can print out `'It's a lie.'`. While at other times, the program works normally. The first control flow is called the if statement. This includes the following syntax: \n",
    "```python \n",
    "a = 0\n",
    "if a < 0: \n",
    "    print('a is small.')\n",
    "elif a == 0: \n",
    "    print('That\\'s a good value.')\n",
    "else: \n",
    "    print('a is too big!')\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above code compares `a` with 0 first, if it is unsuccessful then it compares with the `elif` statement(s), and finally the `else` statement. Note that there are few points to take care about the syntax: \n",
    "* The statements after `if`, `elif` or `else` are indented with 4 characters. \n",
    "* The `if`, `elif` or `else` ends with a semi-colon. \n",
    "* Make sure you have defined the variables before starting the conditional statements. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden",
    "solution2_first": true,
    "solution_first": true
   },
   "source": [
    "__Exercise:__ What will happen from above code?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden"
   },
   "source": [
    "__Solution:__ The system will print 'That's a good value.'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden",
    "solution2_first": true,
    "solution_first": true
   },
   "source": [
    "__Exercise:__ Write a code which accepts user's input. You can assume it is a number with no decimals. The program will print `'This is the correct number.'` if the number is: \n",
    "* between 2 to 10, and\n",
    "* even number. \n",
    "Otherwise, print `'This is the wrong number.'`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write your code below\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "# Solution\n",
    "number = int(input('> '))\n",
    "if number % 2 == 0 and number >= 2 and number <= 10: \n",
    "    print('This is the correct number.')\n",
    "else: \n",
    "    print('This is the wrong number.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden",
    "solution2_first": true,
    "solution_first": true
   },
   "source": [
    "__Exercise:__ Write a code which accepts user's input. The program will print \n",
    "* `'There is a fish in here.'` if the input contains one existence of the word `'fish'`. \n",
    "* `'There are many fishes in here.'` if there are more than one word of `'fish'`. \n",
    "* `'There are no fishes in here.'` if the user did not input the word `'fish'`. \n",
    "The input is case insensitive, so `'Fish'` for example still counts. \n",
    "\n",
    "For example: \n",
    "* `'Fish'` would lead to `'There is a fishes in here.'`. \n",
    "* `'Fish fish'` would lead to `'There are many fishes in here.'`. \n",
    "* `'Fishy fishy'` would lead to `'There are many fishes in here.'`. \n",
    "* `'Fis hy'` would lead to `'There are no fishes in here.'`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write your code below\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are no fishes in here.\n"
     ]
    }
   ],
   "source": [
    "# Solution\n",
    "input_string = 'Some texts in here...'\n",
    "\n",
    "i = 0\n",
    "count = 0\n",
    "input_string = input_string.lower().strip()\n",
    "while i < len(input_string): \n",
    "    if input_string[i] == 'fish': \n",
    "        count += 1\n",
    "    i += 1\n",
    "\n",
    "if count == 1: \n",
    "    print('There is a fishes in here.')\n",
    "elif count > 1: \n",
    "    print('There are many fishes in here.')\n",
    "else: \n",
    "    print('There are no fishes in here.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Flow Chart"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In software engineering, we use flow charts to descibe the control flows. When we initiate a variable, we use a rectangle to indicate the variable. So as when we reassign the variable, we update them with rectangle as well. This is shown as below. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"fig/node.png\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When the program arrives to a decision point, we use a rhombus to indicate this. For example, \n",
    "```python\n",
    "if a > b: \n",
    "```\n",
    "then the flow chart looks like this. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"fig/decision.png\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A flowchart accomodates control flows of conditionals (i.e. `if`) and loops (i.e. `for` and `while`). The following figure shows the flowchart between conditionals and loops. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"fig/flowchart.png\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The left diagram represents an `if` statement, the right diagram represents a loop. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Exercise:__ Draw a flow chart diagram for the first code of the 'Control Flow' section. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## While Loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python another main control flow is loops. There are 2 types of loops in Python, they are: \n",
    "* `while` loop\n",
    "* `for` loop\n",
    "The main difference between `while` and `for` loops is their syntax. While the `while` loop operates whilist the condition remains true, `for` loop operates at a defined list. \n",
    "\n",
    "For example, let us see an example of printing numbers 1 to 10. Using `while` loop, we have \n",
    "````python\n",
    "i = 0\n",
    "while i <= 10: \n",
    "    print(i)\n",
    "    i += 1\n",
    "````\n",
    "Using `for` loop, we have \n",
    "````python\n",
    "for i in range(10): \n",
    "    print(i)\n",
    "````\n",
    "You can test this at below: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# test this\n",
    "i = 1\n",
    "while i <= 10: \n",
    "    print(i)\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# test this\n",
    "for i in range(1,11): \n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see there is not much to aware in the `for` loop, but the `while` loop. In the `while` loop, we can see that \n",
    "* the counter `i` is defined before the `while` loop, but not the `for` loop. \n",
    "* the counter `i` must be increased after the loop. \n",
    "\n",
    "One note: In programming, we use `i` as a convention for counters. Later in multi-dimensional arrays, or when we use nested loops. We use `i` then `j` and `k` etc. to loop our loops.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course, loops does not have to operate under counters. We can use a `while` loop if the condition remains true. For example, \n",
    "```python\n",
    "cmd = '' # We still have to define the elements used in the while loop. \n",
    "while True: \n",
    "    if cmd == 'quit': \n",
    "        break\n",
    "    cmd = input('> ').lower()\n",
    "````\n",
    "This code will still asks for input before the user says `quit`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "solution2": "hidden",
    "solution2_first": true
   },
   "outputs": [],
   "source": [
    "# Try this\n",
    "cmd = ''\n",
    "while True: \n",
    "    if cmd == 'quit': \n",
    "        break\n",
    "    cmd = input('> ').lower()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden",
    "solution_first": true
   },
   "source": [
    "__Exercise:__ \n",
    "\n",
    "In the following, print 1 to 10 using a for and while loop. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use while loop\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use for loop\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "solution": "hidden"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "# Solution (while loop)\n",
    "i = 1\n",
    "while i <= 10: \n",
    "    print(i)\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true,
    "solution": "hidden",
    "solution2": "hidden"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "# Solution (for loop)\n",
    "for i in range(0, 10): \n",
    "    print(i+1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden",
    "solution2_first": true,
    "solution_first": true
   },
   "source": [
    "__Exercise:__ Write a code for calculating average of a list of user inputs (The loop will end when user inputs `0`, but the average will exclude this last zero). For example: \n",
    "````\n",
    "> 1\n",
    "> 2\n",
    "> 3\n",
    "> 1\n",
    "> 0\n",
    "The average is 1.75. \n",
    "````"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write your code below\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "# Solution\n",
    "n = None\n",
    "while n != 0: \n",
    "    n = input('> ')\n",
    "    n = int(n)\n",
    "    print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Continue and Break your Loop\n",
    "\n",
    "Sometimes we would like to make our loop non linear, especially with complex data structure. This means we would like to set some criteria from the inputs and disrupt the loop. In Python, we could either: \n",
    "\n",
    "* use `continue` to let the step disrupts here and continue from the next round.\n",
    "* use `break` to entirely stops the loop. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see the effect using a simple dataset below. The codes are very similar, which it print even numbers from the list. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "data = [1, 3, 9, 11, 2, 0, 5]\n",
    "for i in range(len(data)): \n",
    "    if data[i] % 2 == 1: \n",
    "        continue\n",
    "    print(data[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = [1, 3, 9, 11, 2, 0, 5]\n",
    "for i in range(len(data)): \n",
    "    if data[i] % 2 == 1: \n",
    "        break\n",
    "    print(data[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What if we change the data list a little bit? If we let the first element becomes an even number, it would be appearent. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "data = [0, 1, 3, 9, 11, 2, 0, 5]\n",
    "for i in range(len(data)): \n",
    "    if data[i] % 2 == 1: \n",
    "        break\n",
    "    print(data[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, only the first element is printed but nothing else. This means the loop will seek for the first few elements whom are even numbers. If the compilor found the next element does not meet the criteria, it will cease the loop. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden",
    "solution2_first": true,
    "solution_first": true
   },
   "source": [
    "__Exercise:__ Write a code that will find the largest number in a list. There is a string inside the list and it will break the loop. Think about how could you skip that element. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code. \n",
    "num = [1, 3, 5, 8, 'a', 9, 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "# Solution\n",
    "num = [1, 3, 5, 8, 'a', 9, 0]\n",
    "\n",
    "max = num[0]\n",
    "for i in range(len(num)): \n",
    "    if type(num[i]) != int: \n",
    "        continue\n",
    "    if num[i] > max: \n",
    "        max = num[i]\n",
    "\n",
    "print(max)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden",
    "solution2_first": true,
    "solution_first": true
   },
   "source": [
    "__Exercise:__ Write a code that could spot the first character that does not started with the same character. Print that word. _(Note: The list is given to you. However, this exercise is applicable to find Twitter mentions in a tweet.)_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code.\n",
    "str_ls = ['eggs', 'eel', 'elf', 'Sam', 'eagle', 'echinda', 'emu', 'Eskimo', 'engine']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sam\n"
     ]
    }
   ],
   "source": [
    "# Solution\n",
    "str_ls = ['eggs', 'eel', 'elf', 'Sam', 'eagle', 'echinda', 'emu', 'Eskimo', 'engine']\n",
    "\n",
    "for i in range(len(str_ls)): \n",
    "    if str_ls[i][0] != str_ls[i-1][0]: \n",
    "        print(str_ls[i])\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One side note about `continue` and `break` is what happens the compilor reads them. \n",
    "* When the compilor reads `continue`, it will head to start of the loop.\n",
    "* When the compilor reads `break` it will either head to next line, or go back the parent loop (if multi-dimensional). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In today's session, we have: \n",
    "* understand the syntax of conditionals `if` and loops `for` and `while`. \n",
    "* use flow chart to model control flows. \n",
    "* apply the control flows in practical scenarios. "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.9"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": true,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}