Notebooks/ControlFlow.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Control Flow\n",
    "\n",
    "Last update: Sept 16th, 2020"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conditional Statements and Blocks\n",
    "\n",
    "Sometimes, we will only want to execute some piece of code if a certain condition\n",
    "is met. We use *conditionals* to run particular pieces of code when certain criterion\n",
    "are met.\n",
    "\n",
    "Conditionals are closely tied to booleans, so if you don’t remember what those are, go back to the last lecture for a refresher.\n",
    "\n",
    "The basic syntax for conditionals is"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hide-output": false
   },
   "source": [
    "```python\n",
    "if condition:\n",
    "    # code to run when condition is True\n",
    "else:\n",
    "    # code to run if no conditions above are True\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that immediately following the condition, there is a colon *and*\n",
    "that the next line begins with blank spaces.\n",
    "\n",
    "Using 4 spaces is a *very strong* convention, so that is what we do — we recommend that you do the same.\n",
    "\n",
    "Also note that the `else` clause is optional.\n",
    "\n",
    "Let’s see some simple examples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is where `True` code is run\n"
     ]
    }
   ],
   "source": [
    "if True:\n",
    "    print(\"This is where `True` code is run\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternatively, you could have a test which returns a booleans"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is where `True` code is run\n"
     ]
    }
   ],
   "source": [
    "if 1 < 2:\n",
    "     print(\"This is where `True` code is run\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This example is equivalent to just typing the print statement, but the\n",
    "example below isn’t…"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "if False:\n",
    "    print(\"This is where `True` code is run\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "if 1 > 2:\n",
    "     print(\"This is where `True` code is run\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that when you run the cells above nothing is printed.\n",
    "\n",
    "That is because the condition for the `if` statement was not true, so the code\n",
    "inside the indented block was never run.\n",
    "\n",
    "**The scope of code in Python depends on indentations.**\n",
    "\n",
    "This also allows us to demonstrate the role of indentation\n",
    "in determining the “block” of code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Code runs after 'if' block, regardless of val\n"
     ]
    }
   ],
   "source": [
    "val = False\n",
    "\n",
    "if val is True: # check an expression\n",
    "    print(\"This is where `True` code is run\")\n",
    "    print(\"More code in the if block\")\n",
    "print(\"Code runs after 'if' block, regardless of val\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "The next example shows us how `else` works."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is where `False` code is run\n",
      "More else code\n",
      "Code runs after 'if' block, regardless of val\n"
     ]
    }
   ],
   "source": [
    "val = (2 == 4)  # returns False\n",
    "if val is True:\n",
    "    print(\"This is where `True` code is run\")\n",
    "else:\n",
    "    print(\"This is where `False` code is run\")\n",
    "    print(\"More else code\")\n",
    "print(\"Code runs after 'if' block, regardless of val\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `if False: ...` part of this example is the same as the example\n",
    "before, but now, we added an `else:` clause.\n",
    "\n",
    "In this case, because the conditional for the `if` statement was not\n",
    "`True`, the if code block was not executed, but the `else` block was.\n",
    "\n",
    "Finally, the `Condition is True` is assumed in the `if` statement, and is often left out.  For example, the following are identical"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 < 2\n",
      "1 < 2\n"
     ]
    }
   ],
   "source": [
    "if (1 < 2) is True:\n",
    "    print(\"1 < 2\")\n",
    "\n",
    "if 1 < 2:\n",
    "    print(\"1 < 2\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `elif` clauses\n",
    "\n",
    "Sometimes, you have more than one condition you want to check.\n",
    "\n",
    "For example, you might want to run a different set of code based on which\n",
    "quarter a particular transaction took place in.\n",
    "\n",
    "In this case you could check whether the date is in Q1, or in Q2, or in Q3, or if not\n",
    "any of these it must be in Q4.\n",
    "\n",
    "The way to express this type of conditional is to use one or more `elif`\n",
    "clause in addition to the `if` and the `else`.\n",
    "\n",
    "The syntax is"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hide-output": false
   },
   "source": [
    "```python\n",
    "if condition1:\n",
    "    # code to run when condition1 is True\n",
    "elif condition2:\n",
    "    # code to run when condition2 is True\n",
    "elif condition3:\n",
    "    # code to run when condition3 is True\n",
    "else:\n",
    "    # code to run when none of the above are true\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can include as many `elif` clauses as you want.\n",
    "\n",
    "As before, the `else` part is optional.\n",
    "\n",
    "Here’s how we might express the quarter example referred to above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Halloween is in Q4\n"
     ]
    }
   ],
   "source": [
    "import datetime\n",
    "halloween = datetime.date(2017, 10, 31)\n",
    "\n",
    "if halloween.month > 9:\n",
    "    print(\"Halloween is in Q4\")\n",
    "elif halloween.month > 6:\n",
    "    print(\"Halloween is in Q3\")\n",
    "elif halloween.month > 3:\n",
    "    print(\"Halloween is in Q2\")\n",
    "else:\n",
    "    print(\"Halloween is in Q1\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iterations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `for` Loops\n",
    "\n",
    "The general structure of a standard `for` loop is as follows."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hide-output": false
   },
   "source": [
    "```python\n",
    "for item in iterable:\n",
    "   # operation 1 with item\n",
    "   # operation 2 with item\n",
    "   # ...\n",
    "   # operation N with item\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "where `iterable` is anything capable of producing one item at a time (see\n",
    "[here](https://docs.python.org/3/glossary.html#term-iterable) for official\n",
    "definition from the Python team).\n",
    "\n",
    "Note that we can have as many operations as we want inside the indented block.\n",
    "\n",
    "We will refer to the indented block as the “body” of the loop.\n",
    "\n",
    "When the for loop is executed, `item` will take on one value from `iterable`\n",
    "at a time and execute the loop body for each value.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "a\n",
      "1\n",
      "a\n",
      "2\n",
      "a\n",
      "3\n",
      "a\n",
      "4\n",
      "a\n",
      "5\n",
      "a\n",
      "6\n",
      "a\n",
      "7\n",
      "a\n",
      "8\n",
      "a\n",
      "9\n",
      "a\n"
     ]
    }
   ],
   "source": [
    "for i in range(10):\n",
    "    print(i)\n",
    "    print(\"a\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "res = 0\n",
    "for i in range(10):\n",
    "    print(i)\n",
    "    res = res + i\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Also, recall that the value of a `enumerate(iterable)` is a tuple of the\n",
    "form `(i, x)` where `iterable[i] == x`.\n",
    "\n",
    "When we use `enumerate` in a for loop, we can “unpack” both values at the same\n",
    "time as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "quarter 0 revenue is $5.12 million\n",
      "quarter 1 revenue is $5.2 million\n",
      "quarter 2 revenue is $5.5 million\n",
      "quarter 3 revenue is $6.5 million\n"
     ]
    }
   ],
   "source": [
    "# revenue by quarter\n",
    "company_revenue = [5.12, 5.20, 5.50, 6.50]\n",
    "\n",
    "for index, value in enumerate(company_revenue):\n",
    "    print(f\"quarter {index} revenue is ${value} million\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `while` Loops\n",
    "\n",
    "A related but slightly different form of iteration is to repeat something\n",
    "until some condition is met.\n",
    "\n",
    "This is typically achieved using a `while` loop.\n",
    "\n",
    "The structure of a while loop is"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hide-output": false
   },
   "source": [
    "```python\n",
    "while True_condition:\n",
    "    # repeat these steps\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "where `True_condition` is some conditional statement that should evaluate to\n",
    "`True` when iterations should continue and `False` when Python should stop\n",
    "iterating.\n",
    "\n",
    "For example, suppose we wanted to know the smallest `N` such that\n",
    "$ \\sum_{i=0}^N i > 1000 $.\n",
    "\n",
    "We figure this out using a while loop as follows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The answer is 45\n"
     ]
    }
   ],
   "source": [
    "total = 0\n",
    "i = 0\n",
    "while total <= 1000:\n",
    "    i = i + 1\n",
    "    # print(\"the number to add in this round is \", i)\n",
    "    total = total + i\n",
    "    # print(\"the sum of all integers from 1 to i is \", total)\n",
    "\n",
    "print(\"The answer is\", i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let’s check our work."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "990"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Should be just less than 1000 because range(45) goes from 0 to 44\n",
    "sum(range(45))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1035"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# should be between 990 + 45 = 1035\n",
    "sum(range(46))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A warning: one common programming error with while loops is to forget to\n",
    "set the variable you use in the condition prior to executing.  For example,\n",
    "take the following code which correctly sets a counter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "i = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And then executes a while loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "done\n"
     ]
    }
   ],
   "source": [
    "while i < 3:\n",
    "    print(i)\n",
    "    i = i + 1\n",
    "print(\"done\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No problems. But if you were to execute the above cell again, or another cell, the `i = 3` remains, and code is never executed (since `i < 3` begins as False)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n"
     ]
    }
   ],
   "source": [
    "while i < 3:\n",
    "    print(i)\n",
    "    i = i + 1\n",
    "print(\"done\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `break` and `continue`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `break` Out of a Loop\n",
    "\n",
    "Sometimes we want to stop a loop early if some condition is met.\n",
    "\n",
    "Let’s revisit the example of finding the smallest `N` such that\n",
    "$ \\sum_{i=0}^N i > 1000 $.\n",
    "\n",
    "Clearly `N` must be less than 1000, so we know we will find the answer\n",
    "if we start with a `for` loop over all items in `range(1001)`.\n",
    "\n",
    "Then, we can keep a running total as we proceed and tell Python to stop\n",
    "iterating through our range once total goes above 1000."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The answer is 45\n"
     ]
    }
   ],
   "source": [
    "total = 0\n",
    "for i in range(1001):\n",
    "    total = total + i\n",
    "    if total > 1000:\n",
    "        break\n",
    "\n",
    "print(\"The answer is\", i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `continue` to the Next Iteration\n",
    "\n",
    "Sometimes we might want to exit from one iteration inside the body of a loop early if a condition is met.\n",
    "\n",
    "To do this we can use the `continue` keyword.\n",
    "\n",
    "The basic syntax for doing this is:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hide-output": false
   },
   "source": [
    "```python\n",
    "for item in iterable:\n",
    "    # always do these operations\n",
    "    if condition:\n",
    "        continue\n",
    "\n",
    "    # only do these operations if condition is False\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Inside the loop body, Python will stop that loop iteration of the loop and continue directly to the next iteration when it encounters the `continue` statement.\n",
    "\n",
    "For example, suppose I ask you to loop over the numbers 1 to 10 and print out\n",
    "the message “{i} An odd number!” whenever the number `i` is odd, and do\n",
    "nothing otherwise.\n",
    "\n",
    "You can use continue to do this as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 is an odd number!\n",
      "3 is an odd number!\n",
      "5 is an odd number!\n",
      "7 is an odd number!\n",
      "9 is an odd number!\n"
     ]
    }
   ],
   "source": [
    "for i in range(1, 11):\n",
    "    if i % 2 == 0:  # an even number... This is modulus division\n",
    "        continue\n",
    "    print(i, \"is an odd number!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}