02 Control statements.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction\n",
    "\n",
    "Control statements are central to computing. They allow a program to change what it does depending on input or other data.\n",
    "Typical flows in a computer program involve structures like:\n",
    "\n",
    "- if 'X' do task 'A', else if 'Y' do task 'B'\n",
    "- perform the task 'A' 'N' times\n",
    "- perform the task 'B' until 'X' is true\n",
    "\n",
    "Flows like these are implemented using 'control statements'. Control statements are a major part of all non-trivial computer programs.\n",
    "\n",
    "\n",
    "## Objectives\n",
    "\n",
    "- Introduce Boolean types\n",
    "- Introduce comparison operators\n",
    "- Learn to use control statements\n",
    "\n",
    "\n",
    "## Example of a control statement in pseudo code\n",
    "\n",
    "An electric window opener, attached to a rain sensor and a temperature \n",
    "gauge, might be controlled by the following program:\n",
    "\n",
    "    if raining:  # If raining, close the window\n",
    "        close_window()\n",
    "    else if temperature > 26:  # If the temperature is over 26 deg, open window\n",
    "        open_window()\n",
    "    else if temperature < 19:  # If the temperature is below 19 deg, close window\n",
    "        close_window()\n",
    "    else:  # Otherwise, do nothing and leave window as it is\n",
    "        pass\n",
    "\n",
    "It is easy to imagine the program being made more sophisticated using the time of the day and the day of the week, or being attached to a smoke alarm.\n",
    "\n",
    "We will look at different types of control statements, but first we need to introduce boolean types and comparison operators."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Booleans\n",
    "\n",
    "Before starting with control statements, we need to introduce booleans.\n",
    "A Boolean is a type of variable that can take on one of two values - true or false."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = True\n",
    "print(a)\n",
    "\n",
    "a = False\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Booleans are used extensively in control statements."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Comparison operators\n",
    "\n",
    "We often want to check in a program how two variables are related to each other, for example if one is less than the other, or if two variables are equal. We do this with 'comparison operators', such as `<`, `<=`, `>`, `>=` and `==`. These are examples of *binary operators*.\n",
    "\n",
    "Below is an example checking if a number `a` is less than or greater than a number `b`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 10.0\n",
    "b = 9.9\n",
    "print(a < b)\n",
    "print(a > b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Equality is checked using '`==`', and '`!=`' is used to test if two variables are not equal. Below are some examples to read through."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 14\n",
    "b = -9\n",
    "c = 14\n",
    "\n",
    "# Check if a is equal to b \n",
    "print(\"Is a equal to b?\")\n",
    "print(a == b)\n",
    "\n",
    "# Check if a is equal to c \n",
    "print(\"Is a equal to c?\")\n",
    "print(a == c)\n",
    "\n",
    "# Check if a is not equal to c \n",
    "print(\"Is a not equal to c?\")\n",
    "print(a != c)\n",
    "\n",
    "# Check if a is less than or equal to b \n",
    "print(\"Is a less than or equal to b?\")\n",
    "print(a <= b)\n",
    "\n",
    "# Check if a is less than or equal to c \n",
    "print(\"Is a less than or equal to c?\")\n",
    "print(a <= c)\n",
    "\n",
    "# Check if two colours are the same\n",
    "colour0 = 'blue'\n",
    "colour1 = 'green'\n",
    "print(\"Is colour0 the same as colour1?\")\n",
    "print(colour0 == colour1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Boolean operators\n",
    "\n",
    "In the above we have only used one comparison at a time. Boolean operators allow us to 'string' together multiple checks using the operators '`and`', '`or`' and '`not`'.\n",
    "The operators '`and`' and '`or`' take a boolean on either side, and the code\n",
    "```python\n",
    "X and Y\n",
    "```\n",
    "will evaluate to `True` if `X` *and* `Y` are both true, and otherwise will evaluate to `False`. The code\n",
    "```python\n",
    "X or Y\n",
    "```\n",
    "will evaluate to `True` if `X` *or* `Y` is true, and otherwise will evaluate to `False`.\n",
    "Here are some examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# If 10 < 9 (false) and 15 < 20 (true) -> false\n",
    "print((10 < 9) and (15 < 20))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Check if 10 < 9 (false) or 15 < 20 (true) -> true\n",
    "print((10 < 9) or (15 < 20))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The meaning of the statement becomes clear if read left-to-right.\n",
    "\n",
    "Below is a very simple example that, given the current time of day reports \n",
    "\n",
    "- true if it is lunch time; and \n",
    "- true if we are outside of working hours."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "time = 13.05  # The current time\n",
    "\n",
    "work_starts = 8.00  # Start of working day \n",
    "work_ends = 17.00  # End of working day\n",
    "\n",
    "lunch_starts = 13.00  # Start of lunchtime\n",
    "lunch_ends = 14.00  # End of lunchtime\n",
    "\n",
    "# Check if it's lunch time\n",
    "print(\"Is it lunchtime?\")\n",
    "is_lunchtime = time >= lunch_starts and time < lunch_ends\n",
    "print(is_lunchtime)\n",
    "\n",
    "# Check if we're outside of working hours\n",
    "print(\"Are we outside of working hours?\")\n",
    "outside_working_hours = time < work_starts or time >= work_ends\n",
    "print(outside_working_hours)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the comparison operators (`>=`, `<=`, `<` and `>`) are evaluated before the Boolean operators (`and`, `or`).\n",
    "\n",
    "In Python, the '`not`' operator negates a statement, e.g.:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Is 12 *not* less than 7 -> true\n",
    "a = 12\n",
    "b = 7\n",
    "print(not a < b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Only use '`not`' when it makes a program easy to read. For example,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(not 12 == 7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "is not good practice. Better is"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(12 != 7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is a double-negation, which is very cryptic (and poor programming):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(not not 12 == 7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multiple comparison operators\n",
    "\n",
    "The examples so far use at most two comparison operators. In some cases we might want to perform more checks. We can control the order of evaluation using brackets. For example, if we want to check if a number is strictly between 100 and 200, or between 10 and 50:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "value = 150.5\n",
    "print ((value > 100 and value < 200) or (value > 10 and value < 50)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The two checks in the brackets are evaluated first (each evaluates to `True` or `False`), and then the '`or`' checks if one of the two is true."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Control statements\n",
    "\n",
    "Now that we've covered comparisons, we are ready to look at control statements. Here is a control statement in pseudo code:\n",
    "\n",
    "    if A is true\n",
    "        Perform task X (only)\n",
    "    else if B is true\n",
    "        Perform task Y (only)\n",
    "    else   \n",
    "        Perform task Z (only)\n",
    "\n",
    "The above is an 'if-else' statement. Another type of control statement is\n",
    "\n",
    "    do task X 10 times\n",
    "    \n",
    "We make this concrete below with some examples."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `if` statements\n",
    "\n",
    "Below is a simple example that demonstrates the Python syntax for an if-else control statement. \n",
    "For a value assigned to a variable `x`, the program prints a message and modifies `x`.\n",
    "The message and the modification of `x` depend on the initial value of `x`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial x is less than zero\n",
      "New x value: 11.0\n"
     ]
    }
   ],
   "source": [
    "x = -10.0  # Initial x value\n",
    "\n",
    "if x > 0.0:  \n",
    "    print('Initial x is greater than zero')\n",
    "    x -= 20.0\n",
    "elif x < 0.0:  \n",
    "    print('Initial x is less than zero')\n",
    "    x += 21.0\n",
    "else: \n",
    "    print('Initial x is not less than zero and not greater than zero, therefore it must be zero')\n",
    "    x *= 2.5\n",
    "\n",
    "# Print new x value\n",
    "print(\"New x value:\", x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Try changing the value of `x` and re-running the cell to see the different paths the code can follow."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now dissect the control statement example. The control statement begins with an `if`, followed by the expression to check, followed by '`:`'\n",
    "```python\n",
    "if x > 0.0:\n",
    "```\n",
    "Below that is a block of code, indented by four spaces, that is executed if the check `x > 0.0` is true:\n",
    "````python\n",
    "    print('Initial x is greater than zero')\n",
    "    x -= 20.0\n",
    "````\n",
    "and in which case the program will then move beyond the end of the control statement. If the check evaluates to false, then the `elif` (else if) check  \n",
    "```python\n",
    "elif x < 0.0:\n",
    "    print('Initial x is less than zero')\n",
    "    x += 21.0\n",
    "```      \n",
    "is performed, and if true `print('x is less than zero')` is executed and the control block is exited. The code following the `else` statement is executed\n",
    "```python\n",
    "else:\n",
    "    print('Initial x is not less than zero and not greater than zero, therefore it must be zero')\n",
    "```\n",
    "if none of the preceding statements were true."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example: currency trading\n",
    "\n",
    "A currency trader makes a commission by selling US dollars to travellers at a rate below the market rate. The mark-down multiplier they apply is show below.  \n",
    "\n",
    "|Amount (GBP)                                |reduction on market rate |\n",
    "|--------------------------------------------|-------------------------|\n",
    "| Less than $100$                            | 0.9                     |   \n",
    "| From $100$ and less than $1,000$           | 0.925                   |   \n",
    "| From $1,000$ and less than $10,000$        | 0.95                    |   \n",
    "| From $10,000$ and less than $100,000$      | 0.97                    |   \n",
    "| Over $100,000$                             | 0.98                    |   \n",
    "\n",
    "The currency trader incurs extra costs for handling cash over electronic transactions, so for cash transactions they retain an extra 10% after conversion. \n",
    "\n",
    "At the current market rate 1 GBP is 1.25607 USD."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Amount in GBP sold: 15600.05\n",
      "Amount in USD purchased: 17106.2209434555\n",
      "Effective rate: 1.09654911\n"
     ]
    }
   ],
   "source": [
    "GBP  = 15600.05  # The amount in GBP to be changed into USD\n",
    "cash = True  # True if selling cash, otherwise False\n",
    "\n",
    "market_rate = 1.25607  # 1 GBP is worth this many dollars at the market rate\n",
    "\n",
    "# Apply the appropriate reduction depending on the amount being sold\n",
    "if GBP < 100:\n",
    "    USD = 0.9*market_rate*GBP\n",
    "elif GBP < 1000:  \n",
    "    USD = 0.925*market_rate*GBP\n",
    "elif GBP < 10000:\n",
    "    USD = 0.95*market_rate*GBP\n",
    "elif GBP < 100000:\n",
    "    USD = 0.97*market_rate*GBP\n",
    "else:\n",
    "    USD = 0.98*market_rate*GBP\n",
    "\n",
    "if cash:\n",
    "    USD *= 0.9  # recall that this is shorthand for USD = 0.9*USD \n",
    "    \n",
    "print(\"Amount in GBP sold:\", GBP)\n",
    "print(\"Amount in USD purchased:\", USD)\n",
    "print(\"Effective rate:\", USD/GBP)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `for` loops\n",
    "\n",
    "A `for` loop is a block that repeats an operation a specified number of times (loops). The concept is rich, but we start with the simplest and most common usage:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----\n",
      "0 0\n",
      "----\n",
      "1 1\n",
      "----\n",
      "2 4\n",
      "----\n",
      "3 9\n"
     ]
    }
   ],
   "source": [
    "for n in range(4):\n",
    "    print(\"----\")\n",
    "    print(n, n**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above executes the loop 4 times over the integers 0, 1, 2 and 3. The statement \n",
    "```python\n",
    "for n in range(4):\n",
    "```\n",
    "says that we want to loop over four integers, and by default it starts from zero\n",
    "(see https://docs.python.org/3/library/stdtypes.html#range for the documentation for `range`). \n",
    "The value of `n` is incremented in each loop iteration. The code we want to execute inside the loop is indented by four spaces: \n",
    "```python\n",
    "    print(\"----\")\n",
    "    print(n, n**2)\n",
    "```\n",
    "The loop starts from zero and does not include 4 - `range(4)` is a shortcut for `range(0, 4)`. We can change the starting value if we need to:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-2\n",
      "-1\n",
      "0\n",
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "for i in range(-2, 3):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The loop starts at -2, but does not include 3. If we want to increment in steps of three rather than one:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "3\n",
      "6\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for n in range(0, 10, 3):\n",
    "    print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example: conversion table from degrees Fahrenheit to degrees Celsius\n",
    "\n",
    "We can use a `for` loop to create a conversion table from degrees Fahrenheit ($T_F$) to degrees Celsius ($T_c$), using the formula:\n",
    "\n",
    "$$\n",
    "T_c = 5(T_f - 32)/9\n",
    "$$\n",
    "\n",
    "Computing the conversion from -100 F to 200 F in steps of 20 F (not including 200 F):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T_f,    T_c\n",
      "-100 -73.33333333333333\n",
      "-80 -62.22222222222222\n",
      "-60 -51.111111111111114\n",
      "-40 -40.0\n",
      "-20 -28.88888888888889\n",
      "0 -17.77777777777778\n",
      "20 -6.666666666666667\n",
      "40 4.444444444444445\n",
      "60 15.555555555555555\n",
      "80 26.666666666666668\n",
      "100 37.77777777777778\n",
      "120 48.888888888888886\n",
      "140 60.0\n",
      "160 71.11111111111111\n",
      "180 82.22222222222223\n"
     ]
    }
   ],
   "source": [
    "print(\"T_f,    T_c\")\n",
    "for Tf in range(-100, 200, 20):\n",
    "    print(Tf, (Tf - 32)*5/9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `while` loops\n",
    "\n",
    "We have seen that `for` loops execute the loop body a specified number of times. A `while` loop performs a task while a specified statement is true. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Start of while statement\n",
      "-2\n",
      "-1\n",
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "End of while statement\n"
     ]
    }
   ],
   "source": [
    "print(\"Start of while statement\")\n",
    "x = -2\n",
    "while x < 5:\n",
    "    print(x)\n",
    "    x += 1  # Increment x\n",
    "print(\"End of while statement\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The body of the `while` statement, which follows the `while` statement and is indented four spaces, is executed and repeated until `x < 5` is `False`.\n",
    "\n",
    "It can be quite easy to cause a crash using a `while` loop. E.g.,\n",
    "```python\n",
    "x = -2\n",
    "while x < 5:\n",
    "    print(x)\n",
    "```\n",
    "will continue indefinitely since `x < 5 == False`  will never be satisfied. This is known as an *infinite loop*. It is usually good practice to add checks to avoid an infinite loop, e.g. specify a maximum number of permitted loops. More on avoiding infinite loops below.\n",
    "\n",
    "The above example could have been implemented using a `for` loop, and a `for` loop would be preferred in this case. The following is an example of where a `while` is appropriate:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.81\n",
      "0.6561000000000001\n",
      "0.43046721000000016\n",
      "0.18530201888518424\n",
      "0.03433683820292518\n",
      "0.001179018457773862\n",
      "1.390084523771456e-06\n"
     ]
    }
   ],
   "source": [
    "x = 0.9\n",
    "while x > 0.001:\n",
    "    # Square x (we could have used the shorthand x *= x)\n",
    "    x = x*x\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "since we might not know beforehand how many steps are required before `x > 0.001` becomes false. \n",
    "\n",
    "If $x \\ge 1$, the above would lead to an infinite loop. To make a code robust, it would be good practice to check that $x < 1$ before entering the `while` loop."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `break`, `continue` and `pass`\n",
    "\n",
    "### `break`\n",
    "\n",
    "Sometimes we want to break out of a `for` or `while` loop. Maybe in a `for` loop we can check if something is true, and then exit the loop prematurely, e.g."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "Time to break out\n"
     ]
    }
   ],
   "source": [
    "for x in range(10):\n",
    "    print(x)\n",
    "    if x == 5:\n",
    "        print(\"Time to break out\")\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below is a program for finding prime numbers that uses a `break` statement. Take some time to understand what it does. It might be helpful to add some print statements to understand the flow."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "5\n",
      "7\n",
      "11\n",
      "13\n",
      "17\n",
      "19\n",
      "23\n",
      "29\n",
      "31\n",
      "37\n",
      "41\n",
      "43\n",
      "47\n"
     ]
    }
   ],
   "source": [
    "N = 50  # Check numbers up 50 for primes (excludes 50)\n",
    "\n",
    "# Loop over all numbers from 2 to 50 (excluding 50)\n",
    "for n in range(2, N):\n",
    "\n",
    "    # Assume that n is prime\n",
    "    n_is_prime = True\n",
    "\n",
    "    # Check if n can be divided by m, where m ranges from 2 to n (excluding n)\n",
    "    for m in range(2, n):\n",
    "         if n % m == 0:  # This is true if the remainder for n/m is equal to zero\n",
    "            # We've found that n is divisable by m, so it can't be a prime number. \n",
    "            # No need to check for more values of m, so set n_is_prime = False and\n",
    "            # exit the 'm' loop.\n",
    "            n_is_prime = False\n",
    "            break\n",
    "\n",
    "    #  If n is prime, print to screen        \n",
    "    if n_is_prime:\n",
    "        print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Try modifying the code for finding prime numbers such that it finds the first $N$ prime numbers (since you do not know how many numbers you need to check to find $N$ primes, use a `while` loop)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `continue`\n",
    "\n",
    "Sometimes we want to go prematurely to the next iteration in a loop, skipping the remaining code in the loop body.\n",
    "For this we use `continue`. Here is an example that loops over 20 numbers (0 to 19) and checks if the number is divisible by 4. If it is divisible by 4 it prints a message before moving to the next value. If it is not divisible by 4 it advances the loop. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number is not divisible by 4: 1\n",
      "Number is not divisible by 4: 2\n",
      "Number is not divisible by 4: 3\n",
      "Number is not divisible by 4: 5\n",
      "Number is not divisible by 4: 6\n",
      "Number is not divisible by 4: 7\n",
      "Number is not divisible by 4: 9\n",
      "Number is not divisible by 4: 10\n",
      "Number is not divisible by 4: 11\n",
      "Number is not divisible by 4: 13\n",
      "Number is not divisible by 4: 14\n",
      "Number is not divisible by 4: 15\n",
      "Number is not divisible by 4: 17\n",
      "Number is not divisible by 4: 18\n",
      "Number is not divisible by 4: 19\n"
     ]
    }
   ],
   "source": [
    "for j in range(20):\n",
    "    if j % 4 == 0:  # Check remained of j/4\n",
    "        continue  # jump to next iteration over j\n",
    "    print(\"Number is not divisible by 4:\", j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `pass`\n",
    "\n",
    "Sometimes we need a statement that does nothing. It is often used during development where syntactically some code is required but which you have not yet written. For example:  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25\n",
      "36\n",
      "49\n",
      "64\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for x in range(10):\n",
    "    if x < 5:\n",
    "        # TODO: implement handling of x < 5 when other cases finished \n",
    "        pass\n",
    "    elif x < 9:\n",
    "        print(x*x)\n",
    "    else:\n",
    "        print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It can also help readability. Maybe in a program nothing needs to be done for specific cases, but someone reading the code might reasonably think that something should be done and suspect a bug. Using `pass` says to the reader that it was the programmer's intention that nothing should be done."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Infinite loops: cause and guarding against\n",
    "\n",
    "A common bug, especially when using `while` statements, is the [infinite loop](https://en.wikipedia.org/wiki/Infinite_loop). This is when a loop is entered but never terminates (exits).\n",
    "Infinite loops can render a system unresponsive, sometimes requiring a shutdown to restore function.\n",
    "\n",
    "It is good practice, espeically when learning, to add guards against infinite loops. For example, "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loop count exceeded 2000. Exiting\n"
     ]
    }
   ],
   "source": [
    "x = 0.0\n",
    "\n",
    "counter = 0\n",
    "while x < 0.05:\n",
    "\n",
    "    # Guard against infinite loop\n",
    "    counter += 1\n",
    "    if counter > 2000:\n",
    "        print(\"Loop count exceeded 2000. Exiting\")\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercises\n",
    "\n",
    "Complete now the [02 Exercises](Exercises/02%20Exercises.ipynb) notebook."
   ]
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}