Chapter 3 - Loops.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chapter 3: Loops\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Data Processing with Python, a course for Communication and Information Sciences*\n",
    "\n",
    "<a href=mailto:s.wubben@tilburguniversity.edu>s.wubben@tilburguniversity.edu</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-------------------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In programming, it is often very useful do carry out a the same action for a series of different items. You might, for instance, want to go through a list of words and count and print the number of characters in each word. Or, you might want to do a calculation multiple times. Basically, if you have a program where you repeat certain steps, it is a good idea to use loops. A loop let's Python perform a specific piece of code multiple times. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##The `for` loop\n",
    "The first kind of loop we will examine is the `for` loop\n",
    "The code for this looks roughly like this:\n",
    "\n",
    "    for a_single_item in an_iterable_something:\n",
    "        do_something_with(a_single_item)\n",
    "\n",
    "That almost reads like English. We can print all letters of the word *banana* as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for letter in \"banana\":\n",
    "    print(letter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The code in the loop is executed as many times as there are letters, with a different value for the variable `letter` at each iteration. (**Read the previous sentence again, until you fully understand it.**)\n",
    "\n",
    "Note that the notation is similar to the `if` statement. The statement is closed with a `:` and indentation is used to denote the piece of code to run in the `for` loop. The variable *letter* is truly variable: each step of the loop it contains one letter from the word 'banana'.\n",
    "\n",
    "###`range`\n",
    "We can also use loops if we work with lots of numbers. Instead of printing out each number seperately, we can use loops to do it for us. We can use the `range` function to loop through a range of numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "for x in range(10):\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's combine a `for` loop with an `if` statement to only print all the even numbers under 10:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "for x in range(10):\n",
    "    if x%2==0:\n",
    "        print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<img src=\"https://c1.staticflickr.com/1/38/88285545_5653789979_b.jpg\" width=300 align=right>\n",
    "###Starting from 0\n",
    "Notice anything weird about the numbers in the example? Python starts counting at 0 and only goes up to the number defined in the `range` function. So 10 is never printed.\n",
    "\n",
    "**It is important to understand that Python starts counting at 0 and not 1 as we tend to do.** Python is just like an elevator!\n",
    "\n",
    "Luckily, we can tell the `range` function explicitly where to start and where to end:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "for x in range(1,11):\n",
    "      print (x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** apart from start and end, the `range` function can take a third argument. Edit the example above to see what it does.\n",
    "\n",
    "**Exercise:** now that you know how range works, can you write a script that prints all even numbers between 0 and 20  in only two lines of code?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#even numbers between 0-20\n",
    "#in two lines"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###looping through collections\n",
    "We can also define the range of numbers by hand:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "for x in (10,100,1000,10000):\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or iterate through a collection of strings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "for x in (\"apple\",\"pear\",\"orange\",\"banana\"):\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quite often we have a list of items - effectively a finite set of things.\n",
    "With the `for` loop we can iterate trough these sets. \n",
    "These loops are called “definite loops” because they execute an exact number of times.\n",
    "\n",
    "Definite loops iterate through the members of a set."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##The `while` loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "n = 5\n",
    "while n > 0 :\n",
    "    print(n)\n",
    "    n = n - 1\n",
    "print(\"Blastoff!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above you see the `while` loop. This is a loop that is tied to a logical expression. A `while` loop will run as long the specified expression is evaluated to be `True`. In the example, we first initialize the variable `n` to 5. We then run a loop that only executes while n is larger than 0. Since 5 is larger than 0, it executes! In the loop we subtract 1 from `n`. This means that at some point `n` will not be bigger than 0 and the loop will end.\n",
    "\n",
    "`while` loops are called “indefinite loops” because they keep going until  a logical condition becomes `False`.\n",
    "The loops we have seen so far are pretty easy to examine to see if they will terminate or if they will be “infinite loops”. Check out the following example:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "n = 2\n",
    "while n < 2 :\n",
    "    print(\"Wax on!\")\n",
    "print(\"Wax off!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Do you see what's going wrong here? The condition is never `True`! With the `while` statement it is important to remember what the status of the variable used in the loop is. \n",
    "\n",
    "**Warning!** Likewise, we can have a loop that keeps on going because it always evaluates to `True`. This will cause a notebook to crash so make sure you never create such a loop! If you do create and run such a loop, make sure to restart the kernel.\n",
    "\n",
    "Now, let's increment the value of `n` in the loop:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "n = 0\n",
    "while n < 1 :\n",
    "    print(\"Wax on!\")\n",
    "    print(\"Wax off!\")\n",
    "    #increment n\n",
    "    n+=1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###break\n",
    "\n",
    "The `break` statement lets us escape a loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "word = \"hippopotamus\"\n",
    "\n",
    "for letter in word:\n",
    "    print(letter)\n",
    "    if letter ==\"o\":\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###continue\n",
    "\n",
    "The continue statement ends the current iteration and jumps to the top of the loop and starts the next iteration.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "word = \"hippopotamus\"\n",
    "\n",
    "for letter in word:\n",
    "    if letter ==\"o\":\n",
    "        continue\n",
    "    print(letter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "In the two examples above, not all letters in the word 'hippopotamus' are printed. See if you can figure out what's happening.\n",
    "\n",
    "Both `break` and `continue` teleport you to another part of the code. `break` teleports out of the loop, `continue` teleports you to the next iteration of the loop. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##Making “smart” loops\n",
    "\n",
    "We can use loops for lots of things, but how do you know which loop to use and how to use it? The trick is “knowing” something about the whole loop when you are stuck writing code that only sees one entry at a time. Usually you will end up doing something like this:\n",
    "\n",
    "    Set some variables to initial values\n",
    "\n",
    "    for thing in data:\n",
    "        do something to each entry separately/\n",
    "        update a variable\n",
    "\n",
    "    look at the variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print(\"start\")\n",
    "for thing in (3,6,2,1,5,9,8):\n",
    "    print(thing)\n",
    "print(\"end\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's adapt the code above to print only the largest number in a set. How do we solve this? Well, let's first adapt the piece of pseudocode above to this task, and worry about the Python code later:\n",
    "\n",
    "\n",
    "    Set largest_number to 0\n",
    "\n",
    "    for current_number in set_of_numbers:\n",
    "        if current_number is bigger than largest_number:\n",
    "            assign value of current_number to largest_number \n",
    "\n",
    "    print largest_number\n",
    "\n",
    "\n",
    "For this we need a variable that contains the largest number. We first initialize it. Let's set it to 0 because that's a number we aren't likely to encounter. We then for each number in the set check if it is bigger than the largest number. If so, we update `largest_number` with the new value. Finally, outside the loop we print `largest_number`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "largest_number = 0\n",
    "\n",
    "for current_number in (3,2,6,4,9,5,8):\n",
    "    if current_number > largest_number:\n",
    "        largest_number = current_number\n",
    "        \n",
    "print(\"the largest number is\", largest_number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That seems to be working as planned! \n",
    "\n",
    "**Exercise:** Now to see what's happening, print `largest_number` during each iteration. See how it updates. What happens when you don't set `largest_number` to 0 before the loop? And if you set `largest_number` to 0  inside the loop?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###Counting\n",
    "\n",
    "Now, let's again adapt the code to count the numbers in the set:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "count = 0\n",
    "print('start', count)\n",
    "for number in (3,2,6,4,9,5,8):\n",
    "    #remember: this is the same as count +=1\n",
    "    count = count + 1\n",
    "    print(number, count)\n",
    "print('end', count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So apparently there are 7 numbers in the set. Count them manually if you want to check!\n",
    "\n",
    "###Summing\n",
    "\n",
    "We can also sum over all the numbers in the set in a loop:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "summed = 0\n",
    "print('start', summed)\n",
    "for number in (3,2,6,4,9,5,8):\n",
    "    summed = summed + number\n",
    "    print(number, summed)\n",
    "print('end', summed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The sum of all the numbers is 37. Calculate by hand and see if it is right! You have seen counting and summing in a loop now, but of course there are many more possibilities. Again, Python is like a set of lego bricks which you can assemble in any way you like!\n",
    "\n",
    "###Nested loops\n",
    "\n",
    "Suppose you have multiple sets that you want to use. You can do this easily with nested loops. In the following example we multiply all numbers in the first set with all numbers in the second set.\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "for x in (1,2,3):\n",
    "    for y in (1,2,3):\n",
    "        print (x,\"times\",y,\"equals\",x*y)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What we have learned"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is an overview of the new concepts, statements and functions we have learned in this section. Again, go through the list and make sure you understand them all.\n",
    "\n",
    "-  loop\n",
    "-  `for` statement\n",
    "-  `while` statement\n",
    "-  break\n",
    "-  continue\n",
    "-  variable assignment in a `for` loop\n",
    "- initializing and updating a variable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Exercise 1:** Can you write a code block that prints the length of the string `lengthy_word` that you will define? Use a `for` loop and a variable `counter`. Getting the length of a word is basically counting the number of letters!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# lengthy word code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Exercise 2:** \"99 Bottles of Beer\" is a traditional song in the United States and Canada. It is popular to sing on long trips, as it has a very repetitive format which is easy to memorize, and can take a long time to sing. The song's simple lyrics are as follows: \"99 bottles of beer on the wall, 99 bottles of beer. Take one down, pass it around, 98 bottles of beer on the wall.\" The same verse is repeated, each time with one fewer bottle. The song is completed when the singer or singers reach zero. Your task here is write a Python code block capable of generating all the verses of the song. Use a `counter` integer variable and a `while` loop. Make sure that your loop will come to an end and that the inflection of the word bottle is adapted to the counter!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# bottles of beer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Exercise 3:** In the notebook you have seen examples of counting the amount and calculating the sum of a set of numbers. Can you combine these two examples to calculate the average of a set of numbers?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#average of a set of numbers\n",
    "\n",
    "#intitialize variables\n",
    "\n",
    "for number in (3,2,6,4,9,5,8):\n",
    "    #code for calculating average here\n",
    "    \n",
    "print(average)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-------------\n",
    "Way to go! This concludes Chapter 3."
   ]
  }
 ],
 "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.4.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}