notebooks/2-Flow_Control.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# On the way to programming with Python\n",
    "By now you have a solid understanding of a few of the data types that Python makes available to everyone.  Numbers, strings and lists.  But often times we want to do more than just Python as a fancy calculator or simple word processor, for this need to combine together a set of actions that will be completed over and over again.  Let's take a look at a set of statements that calculates the Fibonacci series."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "a, b = 0, 1 # Here are just initializing the variables a and b to 0 and 1 respectively\n",
    "while a < 10:\n",
    "    print (a)\n",
    "    a = b\n",
    "    b = a+b\n",
    "print('All done.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So what's happening here?\n",
    "- The first line assigns the value of 0 and 1 to the variables `a` and `b` respectively.  we could have done this in two lines, first assigning `a` and then `b` on two separate lines\n",
    "- Next the `while` starts a loop that will execute all the statements that are in the body until the condition that is provided is true (`a < 10`).  In Python, any non-zero integer value is true; zero is false.  This test uses a simple comparison `<`, we can use many different kinds of comparisons `>`, `==`, `<=` for instance or any expression that results in a boolean value (either `True` or `False`)\n",
    "- The _body_ of the loop is indented.  Indention is how Python decides that statements should be grouped together.  All the statements that should be in the body of the function need to be indented the exact same number of spaces (usually 4), most Python editors know to automatically indent lines in a group, but they don't know when you are done with the grouping, so it's up to you to un-indent when you are done closing the body.  You will see in the example above, that the first `print` statement and two assignment statements are indented 4 spaces after the while statement.  The second `print` statement is on the same level as the `while`.  This means that until the condition is met, these three expressions in the body will be executed and only after the while completes will the final `print` be run."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Flow Control\n",
    "Python has many of the same features as other languages to manage the control of the logic steps in the function.  In this next section we'll take a look at them\n",
    "\n",
    "## if Statements\n",
    "The most well-worn statement in all of programming is the `if` statement.  This expressions says, _if the following condition is true, then execute the next block of code_ for instance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "x = int(input(\"Please enter integer\"))\n",
    "if x < 0:\n",
    "    x = 0\n",
    "    print('Negative numbers set to zero')\n",
    "elif x == 0:\n",
    "    print('Zero')\n",
    "elif x == 1: \n",
    "    print('One')\n",
    "else:\n",
    "    print('More')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`if` statements are incredibly valuable and are seen nearly everywhere in all different kinds of applications.  Every language uses `if` statements, it is just the syntax that changes.  For instance, you have likely seen in Excel something like \n",
    "```vba\n",
    "=IF(A1 < B1, \"Yes\", \"No\")\n",
    "```\n",
    "In this simple example, we are testing if the value in cell A1 is less than the value in B1 and if so, place _Yes_ in the current cell, otherwise fill the cell with _No_.\n",
    "\n",
    "In the example above you will notice the `elif` statement as well.  This is short for _else-if_.  So in the case above the way this reads in English is\n",
    "> If the value of x is less than 0, print 'Negative numbers set to zero'\n",
    "<br/>Otherwise, if the value of x is equal to 0, print 'Zero'\n",
    "<br/>Otherwise, if the value of x is 1 then print 'One'\n",
    "<br/>Otherwise just print the word 'More'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## for Statements\n",
    "The `for` statement in Python is another incredibly valuable and prevalent statement.  This statement will iterate over a some sequence of items (e.g. a list, letters in a string) with each pass assigning the next item to a common variable.  Let's take for instance\n",
    "```python\n",
    "words = ['cat','house','window']\n",
    "for w in words:\n",
    "    print(f'{w}:{len(w)}')\n",
    "```\n",
    "In this simple example, the variable `w` is assigned the value `cat` for the duration of the code block following the for statement, then when the block has completed, `w` is assigned the value `house` and finally `window`.  The next cell shows this in action.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "words = ['cat','house','window']\n",
    "for w in words:\n",
    "    print(f'{w}:{len(w)}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Here's another fun example\n",
    "# In order to type an emoji anywhere in Windows, just press ⊞ Win + .\n",
    "all_the_fruits = '🍇🍈🍉🍊🍌🍍🍑🍒🍓🍋🍐🍎🍏🥭'\n",
    "fruits_i_like = ['🍇','🍊','🍌','🍍','🍒','🍓']\n",
    "\n",
    "\n",
    "for f in all_the_fruits:\n",
    "    if f in fruits_i_like:\n",
    "        print(f'I like this one {f}!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using just these two simple satements can allow us to make some pretty interesting use cases.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Your turn - Alphabet Soup\n",
    "For this challenge, using what you have learned about `for` loops and `if` statements to capitalize all the vowels (a,e,i,o,u) in the string provided and print the results.  To help you out, the letters of the alphabet have been provided.  The next cell provides an outline of the steps in English.  Working through the logic in English first can make solving problems a bit easier.  Try working through the steps one by one and translating each line into the Python code that executes the action.  Bonus, leaving the comments in place essentially creates automated documentation for your code!\n",
    "\n",
    "**HINT**: Remember strings are just a sequence of letters which can be iterated and also concatenated simply with `+`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This is the word for which you should be replacing the vowels\n",
    "alphabet = 'abcdefghijklmnopqrstuvwxyz'\n",
    "\n",
    "# create a variable to hold the new set of letters\n",
    "# for each letter in the word provided\n",
    "    #  if the letter is an `a` then add a captial `A` to the new set of letters\n",
    "    #  otherwise if the letter is an `e` then add a capital `E` to the new set of letters\n",
    "    #  otherwise if the letter is an `i` then add a capital `I` to the new set of letters\n",
    "    #  otherwise if the letter is an `e` then add a capital `O` to the new set of letters\n",
    "    #  otherwise if the letter is an `e` then add a capital `U` to the new set of letters\n",
    "    #  otherwise add the current letter to the new set of letters\n",
    "# print the new string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## while Statements\n",
    "You have already seen an example of the `while` statement a bit earlier, but it is helpful to address again briefly.  The `while` statement is useful when the condition that is being tested happens in the code block of the loop.  For instance, `while` loops are often used when reading lines from a file.  \n",
    "```python\n",
    "line = ''\n",
    "while not line is not None:\n",
    "    print(line)\n",
    "    line = read_line_from_file(f)\n",
    "```\n",
    "In this case, we bootstrap the value of `line` to be an empty string, then we tell Python to continue to execute the code block until the iteration when the value of `line` has no more value.  If we were to do this with a `for` loop, we would need to know ahead of time how many lines were in the file or have a specific number of lines in mind.\n",
    "\n",
    "One more common use of `while` is to avoid getting bad data from user inputs.  So for instance, the next cell shows an example of asking the user to specify a value between 1-10.  So long as the user doesn't provide a valid value, the prompt is repeated.\n",
    "\n",
    "**Question** What would happen if we bootstrapped the value of `user_input` to say 4?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "user_input = -1 # bootstrapping\n",
    "while (user_input < 0 or user_input > 10):\n",
    "    user_input = int(input('Please enter a value between 0 and 10'))\n",
    "print('Thank you!  Your response has been recorded.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Two last items\n",
    "### range\n",
    "In order to execute a for loop, it is sometimes helpful to have a sequence of numbers to iterate over.  And while you could type out a list with each number it in, that gets cumbersome and error prone.  This is where the `range` function comes in.  `range` will generate an arithmetic progression given the number of items you specify for instance.\n",
    "```python\n",
    "for i in range(5):\n",
    "    print(i)\n",
    "0\n",
    "1\n",
    "2\n",
    "3\n",
    "4\n",
    "```\n",
    "In this case, we asked for 5 numbers, so Python started at 0 and created us 5 numbers (0-4).  You can also specify a different starting number and the increment (or decrement!) called step.  Here's a few examples.  (Note: `range` is a special datatype which doesn't have an expected string representation, so we have to make it into a list for viewing, this is not necessary when using it directly)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(range(5,10)) # Values starting with 5 up to (not including 10)\n",
    "list(range(0,10,3)) # Every 3rd number starting at 0 up until (not including 10)\n",
    "list(range(10,0,-1)) # Starting at 10, count *down* to 0 (not including 0)\n",
    "\n",
    "for i in range(10,0,-1):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### pass\n",
    "There are rare occassions when our code requires us to have a block of statements even though we don't want to do anything with them.  This is common when we are starting to write our code and we want a placeholder or we aren't sure what to do just yet, but we want to be syntactically correct.  This is where we can use the keyword `pass` similar to comments, this is skipped over by the computer, but makes sure that our code works correctly.\n",
    "```python\n",
    "if x is True:\n",
    "    pass\n",
    "else:\n",
    "    do_something_useful\n",
    "```\n",
    "This is a poor paradigm to actually use, just know that it is helpful when you are building up your program and need a short-term placeholder."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusion\n",
    "Logical decision making and looping are essential building blocks in nearly every single computer application.  Everything from ensuring that data is entered correctly, to making business decisions.  Even video games are based on loops.  The main function of a video game loop is usually something like\n",
    "```python\n",
    "while(application_is_running):\n",
    "    if move_right:\n",
    "        move_spaceship_right()\n",
    "    if move_left:\n",
    "        move_spaceship_left()\n",
    "    if button_pressed:\n",
    "        fire_missles()\n",
    "    if missle_hit_invader:\n",
    "        score_points()\n",
    "        remove_invader()\n",
    "    update_screen()\n",
    "```    \n",
    "\n",
    "In the next [section](3\\-Fuctions.ipynb), we'll focus on how to break our code into steps that both make it more readable and reusable by creating _functions_\n",
    "\n",
    "\n",
    "[prev](1-\\Introduction.ipynb)|[next](3\\-Function.ipynb)|[toc](toc.ipynb)\n"
   ]
  }
 ],
 "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}