python_1.4_flow_control.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python: conditional execution (`if`) and repetition structures (loops)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Required Reading\n",
    "\n",
    "1. [Conditional Execution](https://www.py4e.com/html3/03-conditional) from Python for Everybody by Charles Severance. (Supplementary [videos available here](https://www.py4e.com/lessons/logic))\n",
    "2. [Iteration](https://www.py4e.com/html3/05-iterations) from Python for Everybody by Charles Severance. (Supplementary [videos available here](https://www.py4e.com/lessons/loops))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the \"raw material\" of our data types and the operators to do math and compare variables, we're ready to begin using these tools to write useful programs. To do so, we typically control the flow of our programs with conditional statements (`if` statements) and loops (`for` and `while`). Through the readings and this notebook you'll learn how to use condition statement and loops to create more dynamic programs and explore an example of using these techniques to work with data.\n",
    "\n",
    "## if...elif...else\n",
    "If statements allow you to take different actions in your program depending on whether or not specific conditions are satisfied. For example, if a stoplight is green, you can drive your car forward, otherwise, you should not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "action = 'stop' # The current action is 'stop'\n",
    "light = 'green' # The light is 'green'\n",
    "\n",
    "\n",
    "if light == 'green':\n",
    "    action = 'drive' # The if statement changes the action to 'drive'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is the most basic form of the `if` statement, but we can add more to it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "drive\n"
     ]
    }
   ],
   "source": [
    "light = 'green'\n",
    "\n",
    "if light == 'green':\n",
    "    action = 'drive'\n",
    "else:\n",
    "    action = 'stop'\n",
    "\n",
    "print(action) # Prints the resulting action"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Aside: When you see a block of example code like this, and its output, take a moment to think through the code yourself and make sure you understand how the output was generated. If you aren’t sure why a certain chunk of code resulted in a certain output, it’s important that you figure that out before proceeding, since more complex examples will come later and you need to understand the earlier examples to build on. In fact, open up Spyder and type this into a new text file and run it. Make sure your output matches. Do this for all of the code blocks as you go through the material.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note a couple of things in the preceding block of code:\n",
    "1. If the `if` condition is not evaluated to be True, then the `else` statement is executed\n",
    "2. The if statement requires a colon at the end of it - this is required. \n",
    "3. The indentation at the beginning of the line after the if statement and the else statement is important - this is critical for your code to run since spaces have meaning in Python. \n",
    "\n",
    "Consider the following, which is the same as the last block but with the indentations removed. Note the error that results because there wasn't an indentation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "expected an indented block (<ipython-input-146-80f5d7a38e09>, line 4)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-146-80f5d7a38e09>\"\u001b[1;36m, line \u001b[1;32m4\u001b[0m\n\u001b[1;33m    action = 'drive'\u001b[0m\n\u001b[1;37m         ^\u001b[0m\n\u001b[1;31mIndentationError\u001b[0m\u001b[1;31m:\u001b[0m expected an indented block\n"
     ]
    }
   ],
   "source": [
    "light = 'green'\n",
    "\n",
    "if light == 'green':\n",
    "action = 'drive'\n",
    "else:\n",
    "action = 'stop'\n",
    "print(action)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we have more than one condition to consider, we use the `elif` statement, which is short for \"else if.\" In this case, the `if` expression is first evaluated and if true, the statement below it is run and no other component of the if/elif/else block are executed. If the `if` expression evaluates to `False`, then the program evaluates the first `elif` statement. Only if the `if` expression and all the `elif` expressions are evaluated as false will the `else` statement be executed.\n",
    "\n",
    "In the example below, the light is blue, so we begin walking through the conditions. The first `if` statement is evaluated, and it evaluates to `False` since the light is not green, so we proceed to the first `elif` statement, and since the light isn't blue, we proceed to the next `elif` statement. Since the light is not green, we finally proceed to the `else` statement. Since no other condition was met, the statement below `else` assigns `'proceed with caution - the light is broken!'` to `action`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "proceed with caution - the light is broken!\n"
     ]
    }
   ],
   "source": [
    "light = 'blue'\n",
    "\n",
    "if light == 'green':\n",
    "    action = 'drive'\n",
    "elif light == 'yellow':\n",
    "    action = 'stop'\n",
    "elif light == 'green':\n",
    "    action = 'drive'\n",
    "else:\n",
    "    action = 'proceed with caution - the light is broken!'\n",
    "print(action)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also add in other logical expressions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "stop\n"
     ]
    }
   ],
   "source": [
    "light = 'blue'\n",
    "action = 'drive'\n",
    "\n",
    "if not light == 'green':\n",
    "    action = 'stop'\n",
    "\n",
    "print(action)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There's also a shorthand for simple conditional statements. Suppose you want to use an expression as a switch to result in one value if the switch expression is true and a second value if it's false. This is called a **ternary** operator and it provides just that functionality.\n",
    "\n",
    "In honor of Python's namesake, Monty Python, we'll demonstrate the ternary operator through an example about spam. The expression below that is assigned to `reaction` is an example of the ternary operator. The condition that's being tested is `likes_spam`. If `likes_spam` evaluates to `True`, which it does not in this case, then `reaction` would be assigned the value of the variable `positive`, which is `'I LOVE spam!'`. However, `likes_spam` is `False`, so `reaction` is assigned the value stored in `negative`, which is `'I do NOT like spam.'`. Notice how readable the ternary operator is. The code expresses the intent of the programmer just by reading the line."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I do NOT like spam.\n"
     ]
    }
   ],
   "source": [
    "likes_spam = False\n",
    "negative   = 'I do NOT like spam.'\n",
    "positive   = 'I LOVE spam!'\n",
    "\n",
    "reaction   = positive if likes_spam else negative\n",
    "print(reaction)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iteration\n",
    "Loops are the primary way that we can call the same series of commands over and over to accomplish a task."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### While loops\n",
    "The while loop is the most basic of the Python looping structures. The while loop continues to execute the block of code as long as the test at the top of the loop is true. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "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": [
    "x = 0\n",
    "while x != 10:\n",
    "    x = x + 1\n",
    "    print(x)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using loops can occasionally end up with you stuck in an infinite loop if there's a logical error in the code or a problem with the input data. To stop execution on the IPython console (as in Spyder), hit control-c."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "9\n",
      "8\n",
      "7\n",
      "6\n",
      "5\n",
      "4\n",
      "3\n",
      "2\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "x = 10\n",
    "while x > 0:\n",
    "    print(x)\n",
    "    x -= 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You may occasionally encounter `break`, `continue`, and `pass` statements: `break` will jump out of the closest enclosing loop; `continue` immediately causes execution to jump to the top of the loop; and `pass` does nothing - it's simply an empty placeholder statement.\n",
    "\n",
    "The following code demonstrates the `break` statement by jumping execution out of the loop when the word 'done' is the entry into the loop. Notice that 'done' is never printed since the break statement jumps out of the loop. Make sure you go ahead and try this in Spyder."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "not right\n",
      "#please do not print this\n",
      "#do not print this\n",
      "Finished!\n"
     ]
    }
   ],
   "source": [
    "entries = ['not right', '#please do not print this', '#do not print this', 'stop']\n",
    "index = 0\n",
    "while True: \n",
    "    line = entries[index]\n",
    "    index += 1\n",
    "    if line == 'stop':\n",
    "        break\n",
    "    print(line)\n",
    "print('Finished!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can add in the `continue` statement to jump back to the top of the loop without finishing execution of the rest of the loop. In this case, we've placed the the `continue` statement such that it will only be reached if a hashtag is placed before the word. In that case, the line will not be printed. The loop will continue until the value `stop` is encountered. Of course, if 'stop' wasn't in the list, then an error would result because the program would try to access an an entry in the list `entries` that doesn't exist. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "not right\n",
      "Finished!\n"
     ]
    }
   ],
   "source": [
    "entries = ['not right', '#please do not print this', '#do not print this', 'stop']\n",
    "index = 0\n",
    "while True:\n",
    "    line = entries[index]\n",
    "    index += 1 \n",
    "    if line[0] == '#':\n",
    "        continue\n",
    "    if line == 'stop':\n",
    "        break\n",
    "    print(line)\n",
    "print('Finished!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### For loops\n",
    "For loops step through items in a sequence or other objects that can be iterated over - in other words, the line will be repeatedly executed, but the argument will change as the code loops through itself. In the example below, each time the loop repeats, it assigns the next value in the list on top to the variable `x`, which is then printed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "for x in [1, 2, 3, 4, 5]:\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One thing to keep in mind here - we don't have to use `x` - we can use any name we like (as long as id doesn't violate any of the naming rules we used earlier. For example, we can run the same loop with another index variable instead of `x` and get the same result:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "for my_randomly_named_variable in [1, 2, 3, 4, 5]:\n",
    "    print(my_randomly_named_variable)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly, while we explicitly wrote out the list [1, 2, 3, 4, 5] in the above examples, we could have alternatively assigned that to a variable and produced the same effect."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "simple_sequence = [1, 2, 3, 4, 5]\n",
    "for x in simple_sequence:\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This `for` loop works equally well with strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Four\n",
      "score\n",
      "and\n",
      "seven\n",
      "years\n",
      "ago\n"
     ]
    }
   ],
   "source": [
    "address = ['Four','score','and','seven','years','ago']\n",
    "for word in address:\n",
    "    print(word)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's add the numbers from 1 to 5 in a loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n"
     ]
    }
   ],
   "source": [
    "total = 0\n",
    "for y in [1, 2, 3, 4, 5]:\n",
    "    total += y\n",
    "print(total)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can iterate over tuples just as well"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n"
     ]
    }
   ],
   "source": [
    "total = 0\n",
    "for y in (1, 2, 3, 4, 5):\n",
    "    total += y\n",
    "print(total)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also iterate over characters in a string. Here again, there's no special meaning to the choice of `c` - it could be anything. Whatever value is used here will receive each value in the sequence of characters in the string as the loop repeats."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "w\n",
      "o\n",
      "r\n",
      "d\n",
      "s\n"
     ]
    }
   ],
   "source": [
    "for c in 'words':\n",
    "    print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use for loops with multiple assignments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3\n",
      "4 5 6\n"
     ]
    }
   ],
   "source": [
    "for (a, b, c) in [(1, 2, 3), (4, 5, 6)]:\n",
    "    print(a, b, c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List comprehensions\n",
    "List comprehensions combine `for` loops with lists to make a very compact and readable way of creating lists. Suppose you want to create a matrix of the squared value of a set of numbers for calculating the mean square error (as you may use to measure the quality of a regression model). We'll see this is super easy with `Numpy`, but for now it will illustrate this concept. We could start with a `for` loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n"
     ]
    }
   ],
   "source": [
    "mylist  = [1,2,3,4,5,6,7,8,9,10]\n",
    "squares = []\n",
    "for n in mylist:\n",
    "    squares.append(n**2)\n",
    "print(squares)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, we can do this with a list comprehension in one line:\n",
    "\n",
    "*Note: the variable `mylist` is defined in the last cell, so we don't write it here, but if you're running this code in spyder, you'll need to define `mylist` before running this example:*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n"
     ]
    }
   ],
   "source": [
    "squares = [n**2 for n in mylist]\n",
    "print(squares)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can construct a list comprehensions with the basic format of \n",
    "\n",
    "[ {some expression} `for` {the variable used for iteration} `in` {the quantity to iterate over} ]\n",
    "\n",
    "So instead, we could have multiplied each value by 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 6, 9, 12, 15, 18, 21, 24, 27, 30]\n"
     ]
    }
   ],
   "source": [
    "newlist = [n * 3 for n in mylist]\n",
    "print(newlist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also filter the values by placing an `if` statement at the end and the list comprehension will only iterate over values that return `True` from the `if` statement. For example, if we only wanted the list to include the squares of odd values in the list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 9, 25, 49, 81]\n"
     ]
    }
   ],
   "source": [
    "squares = [n**2 for n in mylist if n % 2 != 0]\n",
    "print(squares)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or we could filter out those values less than 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16]\n"
     ]
    }
   ],
   "source": [
    "squares = [n**2 for n in mylist if n < 5]\n",
    "print(squares)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, this becomes extremely readable - one of the touted benefits of Python by fans of the language. In the above example, it pretty much reads: \"Square the value for each value in the list that's less than 5.\" It's very close to how we would speak."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Next\n",
    "With loops and conditionals in our toolbox, we're ready to expand what we can do with Python and the types of operations we can perform by combining them with a number of core built in Python functions. And a reminder - we'll be covering how to create your own functions in the next unit."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}