2016-17_Practical-03-Loops.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    },
    "nbpresent": {
     "id": "f730ab33-247e-4792-9e02-ab29c9f00c14"
    }
   },
   "source": [
    "# Practical 3: Dictionaries, Loops, Iteration\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    },
    "nbpresent": {
     "id": "cada64b6-f8c9-4dbb-9ab1-b5617d0cc16a"
    }
   },
   "source": [
    "## Learning Outcomes\n",
    "\n",
    "By the end of this practical you should:\n",
    "- Be familiar with the majority of the operators you’ll encounter in basic programming.\n",
    "- Be able to use two different types of loop.\n",
    "- Understand the principles of iteration.\n",
    "- Understand how dictionaries are structured, created and accessed. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "source": [
    "This document assumes you have created a working directory as described here: http://bit.ly/WorkingDirectory"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "source": [
    "## Loops and Iteration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "source": [
    "Loops are a form of iteration, the _repetition of a process_. There are two basic types of loop in Python; the [while loop](http://www.tutorialspoint.com/python/python_while_loop.htm) and the [for loop](https://www.tutorialspoint.com/python/python_for_loop.htm). Essentially, we use `for` loops to iterate over finite sequences of definite length, contrasting with `while` loops that we use when when our sequence is unknown or non-finite."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "source": [
    "#### TASK\n",
    "Run through the information and activites in Notebook 7 in the [Python Code Camp](https://kingsgeocomputation.org/teaching/code-camp/code-camp-python/lessons/). Do not do the _Code (Applied Geo-example)_ section at the end, nor the 'Challenge' immediately before that (_Iterate over the GeoJSON marker_). Return here once you're done. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "source": [
    "### Looping over a String\n",
    "Let’s do a few more tasks to make sure things are clear before we revisit one of last week's Exercises to see how we could have coded it more efficiently using a loop. \n",
    "\n",
    "First, let's use a `for` loop to see how `string` objects are themselves lists of characters. To do this, we'll write a `for` loop to print out `Element: ` before every element of the string `Bristol!`. You may remember that we saw the following in lecture:\n",
    "\n",
    "`for x in myList:`<br/>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`Do something`\n",
    "\n",
    "So all we need to do now is adapt this for our purposes as shown in the code cell below. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "outputs": [],
   "source": [
    "for x in \"Bristol!\":\n",
    "     print(\"Element: \" + x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "source": [
    "Note that the string could be an object, as shown in the next code cell. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "outputs": [],
   "source": [
    "city = \"Bristol!\"\n",
    "for x in city:\n",
    "     print(\"Element: \" + x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "source": [
    "#### TASK\n",
    "Run the last code cell and check you understand why the letters for `Bristol!` are printed and not those for `c`, `i`, `t`, `y`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "source": [
    "### Doing More with For\n",
    "It is often really useful to break a problem down into simple parts and then add detail in small steps to get the functionality that you want. Until you are quite confident as a programmer, this approach helps you to avoid simple mistakes that could give you major headaches later – you know that each bit is working before you add the next bit."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "source": [
    "With this in mind let’s try something a little harder – let’s assume we have a string of text that looks like a list, with values separated by commas :\n",
    "\n",
    "`myText = \"1, 3, 5, 7, 9, dog, cat\"`\n",
    "\n",
    "This is like the data we might find in a file that has a [comma separated values format](https://en.wikipedia.org/wiki/Comma-separated_values) (which we will meet again in future)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "source": [
    "Let's say we want add up all the numbers in this `text` object. For this, we’re going to need to use some string methods called `split()` and `isdigit()` (more on those below). Let’s do this in stages – make sure you get the right output at each stage before moving on to the next one. We'll put each stage in a new code cell. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "source": [
    "First, we'll turn it into something we can more easily deal with in a loop - a list! We can do this using the `string` method `split()` - read about this [here](http://www.tutorialspoint.com/python/string_split.htm). The code to do this is shown in the code cell below. Check you understand what it is doing (with reference to the link above)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "outputs": [],
   "source": [
    "myText = \"1, 3, 5, 7, 9, dog, cat\"\n",
    "myMixedList = myText.split(\", \")\n",
    "print(myMixedList)                  #just to check what it looks like"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "source": [
    "If you run the code above, hopefully you'll agree `myMixedList` looks like a list! Now we can start creating our loop to work through each element in this list. \n",
    "\n",
    "First, we'll just create a loop that  prints out each element in `myMixedList`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "source": [
    "#### TASK\n",
    "In the code below, change `???` as appropriate so that “1”, “3”, “5”, “7”, “9”, “dog”, “cat” are printed on separate lines."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "outputs": [],
   "source": [
    "for x in ???:\n",
    "    print(???)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "source": [
    "We'll now change this loop to print out `true` or `false` for every element based on whether or not it is a number. We'll do this using the string method `isdigit()` - read more about this method [here](http://www.tutorialspoint.com/python/string_isdigit.htm)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "source": [
    "#### TASK\n",
    "In the code below, change `???` as appropriate so that True, True, True, True, True, False, False are printed on separate lines. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "outputs": [],
   "source": [
    "for x in myMixedList:\n",
    "    print(???.isdigit())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "source": [
    "Next we will change our loop to use `isdigit()` as part of a condition – if the element is made of digits, then print it out, but don’t print anything that isn’t digits. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "source": [
    "#### TASK\n",
    "In the code below, change `???` as appropriate so that our loop prints any element made of digits but not anything else. This should print out “1”, “3”, “5”, “7”, “9” on separate lines."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "outputs": [],
   "source": [
    "for x in myMixedList:\n",
    "    if x.isdigit():\n",
    "        print(???)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "source": [
    "We're almost there. Now we need to create a variable called `total` before the `for` loop begins and then use the `+=` operator to add each integer to `total` as we iterate through the list. However, we need to remember that each 'number' is still a `string` so we'll have to convert to an integer using `int()` "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "source": [
    "#### TASK\n",
    "In the code below, change `???` as appropriate to add the integers and print out the total"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "outputs": [],
   "source": [
    "??? = 0\n",
    "for x in myMixedList:\n",
    "    if x.isdigit():\n",
    "        total ??? int(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "source": [
    "Finally, we'll add a line at the end of the loop to print out `Total: 25`  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "source": [
    "#### TASK\n",
    "Add this code: `print(\"Total: \" + str(???))`, changing `???` where appropriate, to the code cell above to print out the final total (25) once all the numbers in the list have been added.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "source": [
    "Note: the final code you should have produced above is shown at the very bottom of this notebook - try not to look at it until you have managed to produce the desired output!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "source": [
    "### Revisiting last week's Exercise\n",
    "Hopefully you tried to write the code for the final Exercise in week 2. You may have found it either a) impossible, or b) really, really tedious. The full code for _one_ solution to the problem is shown below (there are multiple, slightly different ways this could have been achieved)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "source": [
    "#### TASK\n",
    "Read through the code to ensure you understand what it is doing. Read the comments to help."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "outputs": [],
   "source": [
    "myInput = [1,4,2,1,2]\n",
    "\n",
    "maxValues = []     #list to hold most frequent value(s)\n",
    "maxValue  = 0      #the current most frequent value \n",
    "maxFreq = 0        #frequency of maxValue\n",
    "\n",
    "value = myInput[0]               #get the value to be counted\n",
    "if value not in maxValues:       #conditional: if this value has not already been checked\n",
    "    \n",
    "    count = myInput.count(value)  #for this value count how many times it occurs in the input list\n",
    "\n",
    "    if count > maxFreq:           #conditional: if this value is found more frequently than any other yet checked\n",
    "        maxValue = value          #update current most frequent value \n",
    "        maxFreq  = count          #update frequency of maxValue\n",
    "        maxValues = [value]       #set the maxValues list to hold ONLY this value\n",
    "    elif count == maxFreq:        #conditional: if this value has equal frequency to the current most frequently found value \n",
    "        maxValues.append(value)   #add this value to list of most frequently found values\n",
    "\n",
    "#repeat what we did for myInput[0]\n",
    "value = myInput[1]               \n",
    "if value not in maxValues:       \n",
    "    \n",
    "    count = myInput.count(value)  \n",
    "\n",
    "    if count > maxFreq:           \n",
    "        maxValue = value          \n",
    "        maxFreq  = count          \n",
    "        maxValues = [value]       \n",
    "    elif count == maxFreq:        \n",
    "        maxValues.append(value)   \n",
    "\n",
    "#repeat what we did for myInput[0]\n",
    "value = myInput[2] \n",
    "if value not in maxValues:\n",
    "    \n",
    "    count = myInput.count(value)  \n",
    "\n",
    "    if count > maxFreq:\n",
    "        maxValue = value\n",
    "        maxFreq  = count\n",
    "        maxValues = [value]\n",
    "    elif count == maxFreq:   \n",
    "        maxValues.append(value)\n",
    "\n",
    "#repeat what we did for myInput[0]\n",
    "value = myInput[3] \n",
    "if value not in maxValues:\n",
    "    \n",
    "    count = myInput.count(value)  \n",
    "\n",
    "    if count > maxFreq:\n",
    "        maxValue = value\n",
    "        maxFreq  = count\n",
    "        maxValues = [value]\n",
    "    elif count == maxFreq:   \n",
    "        maxValues.append(value)\n",
    "\n",
    "#repeat what we did for myInput[0]\n",
    "value = myInput[4] \n",
    "if value not in maxValues:\n",
    "    \n",
    "    count = myInput.count(value)  \n",
    "\n",
    "    if count > maxFreq:\n",
    "        maxValue = value\n",
    "        maxFreq  = count\n",
    "        maxValues = [value]\n",
    "    elif count == maxFreq:   \n",
    "        maxValues.append(value)\n",
    "\n",
    "if len(maxValues) > 1:             #if there is more than one value in this list, there is no single mode\n",
    "    print(\"There is no single mode in the input\")\n",
    "else:                              #otherwise there is a single mode\n",
    "    print(\"Mode is \" + str(maxValue))\n",
    "    print(\"It occurs \" + str(maxFreq) + \" times in the input\")\n",
    "print(myInput)                     #always print the input"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "source": [
    "You probably noticed that there are several blocks of code repeated in the script above. This should immediately get you thinking that this code could be improved by using a loop. \n",
    "\n",
    "Using a loop for this task will improve the code in at least two ways:\n",
    "\n",
    "1. It will reduce the number of lines of code, making it quicker both to write the code in the first place and easier to understand what the script is doing (theoretically!)\n",
    "2. It will allow us to evaluate lists of ANY length (not just length 5 as above)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "source": [
    "So where do we start? Often when coding loops it can be useful to think backwards from what you want the outcome to be. In this case we already have some code and we just want to [refactor](https://en.wikipedia.org/wiki/Code_refactoring) it. So here, first we should identify what should be within the loop, what should come before it, and what should come after the loop.\n",
    "\n",
    "Hopefully in this case it is clear that the block that repeats should be within the loop (because we're doing the same thing over and over which is the whole point of a loop!). The only thing that changes in these blocks is the index in the following line: `value = myInput[4]`. So this is our clue about what should be within the loop and what it will need to iterate over. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "source": [
    "#### TASK\n",
    "Before continuing, look at the code ABOVE and see if you can work out where you would add a line of code starting `for x in` to run the code as a loop."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "source": [
    "Now compare where the `for` command should go, by looking at the code below. How did you do? The code below is nearly the final version of the code above refactored to use a `for` loop. However, there are some elements of code missing (indicated by `???`) and all indentation has been removed. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "source": [
    "#### TASK\n",
    "In the code below, change `???` and add indentation as appropriate to make the loop work and produce the same output as the script above.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "outputs": [],
   "source": [
    "myInput = [1,4,2,1,2]\n",
    "\n",
    "maxValues = []     #list to hold most frequent value(s)\n",
    "maxValue  = 0      #the current most frequent value \n",
    "maxFreq = 0        #frequency of maxValue\n",
    "\n",
    "for x in ???:\n",
    "    \n",
    "value = myInput[???]                #get the value to be counted\n",
    "if value not in maxValues:        #conditional: if this value has not already been checked\n",
    "    \n",
    "count = myInput.count(value)  #for this value count how many times it occurs in the input list\n",
    "\n",
    "if count > maxFreq:           #conditional: if this value is found more frequently than any other yet checked\n",
    "maxValue = value          #update current most frequent value \n",
    "maxFreq  = count          #update frequency of maxValue\n",
    "maxValues = [value]       #set the maxValues list to hold ONLY this value\n",
    "elif count == maxFreq:        #conditional: if this value has equal frequency to the current most frequently found value \n",
    "maxValues.append(value)   #add this value to list of most frequently found values\n",
    "\n",
    "if len(maxValues) > 1:             #if there is more than one value in this list, there is no single mode\n",
    "print(\"There is no single mode in the input\")\n",
    "else:                              #otherwise there is a single mode\n",
    "print(\"Mode is \" + str(maxValue))\n",
    "print(\"It occurs \" + str(maxFreq) + \" times in the input\")\n",
    "print(myInput)                     #always print the input"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "source": [
    "If you have edited the code correctly the output for the initially given list should look like the following:\n",
    "\n",
    "`There is no single mode in the input`<br>\n",
    "`[1, 4, 2, 1, 2]`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "source": [
    "If not, things you might check are:\n",
    "\n",
    "- what is `x`? i.e. are you iterating over the elements of `myInput` or a sequence of integers produced using `xrange`?   \n",
    "- the `value` variable should be a value from `myInput` - are you creating this variable correctly? \n",
    "- have you got the indenting right? For example, `myInput` should always be printed out.  \n",
    "\n",
    "If you are still having trouble, a solution is at the bottom of this notebook... "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "source": [
    "Things to think about/try here:\n",
    "- check you understand how the indentation is is working and makes it easier to read the code\n",
    "- try chainging the length of the input list to see how the code will still execute for longer lists (check you understand why this is)\n",
    "- how would the code within the loop change if the loop used `for x in myInput` and not `xrange`? \n",
    "- why is using the `maxValues` list useful?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "source": [
    "## Solutions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "source": [
    "#### A solution to the tasks in the Dictionaries section"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "outputs": [],
   "source": [
    "cities = {\n",
    "'San Francisco': [37.77, -122.43, 'SFO'],\n",
    "'London': [51.51, -0.08, 'LDN'],\n",
    "'Paris': [48.86,2.29, 'PAR'],\n",
    "'Beijing': [39.92,116.40 ,'BEI'],\n",
    "}\n",
    "\n",
    "print(cities)\n",
    "cities['Rio de Janeiro'] = [-22.97, -43.18, 'RIO']\n",
    "print(cities)\n",
    "cities['Bristol!'] = [51.45, -2.59, 'BRI']\n",
    "\n",
    "print(cities['Bristol!'])\n",
    "print(cities.get('Bristol!'))\n",
    "\n",
    "del cities['London']\n",
    "print(cities)\n",
    "\n",
    "cities.pop('Paris')\n",
    "print(cities)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "source": [
    "#### A solution to 'Doing More with For'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "outputs": [],
   "source": [
    "myText = \"1, 3, 5, 7, 9, dog, cat\"\n",
    "myMixedList = myText.split(\", \")\n",
    "\n",
    "total = 0\n",
    "for x in myMixedList:\n",
    "    if x.isdigit():\n",
    "        total += int(x)\n",
    "print(\"Total: \" + str(total)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "source": [
    "#### A solution to writing last week's Exercise with a loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "outputs": [],
   "source": [
    "myInput = [1,2,2,1,2]\n",
    "\n",
    "maxValues = []     #list to hold most frequent value(s)\n",
    "maxValue  = 0      #the current most frequent value \n",
    "maxFreq = 0        #frequency of maxValue\n",
    "\n",
    "for x in xrange(len(myInput)):\n",
    "    \n",
    "    value = myInput[x]                #get the value to be counted\n",
    "    if value not in maxValues:        #conditional: if this value has not already been checked\n",
    "    \n",
    "        count = myInput.count(value)  #for this value count how many times it occurs in the input list\n",
    "\n",
    "        if count > maxFreq:           #conditional: if this value is found more frequently than any other yet checked\n",
    "            maxValue = value          #update current most frequent value \n",
    "            maxFreq  = count          #update frequency of maxValue\n",
    "            maxValues = [value]       #set the maxValues list to hold ONLY this value\n",
    "        elif count == maxFreq:        #conditional: if this value has equal frequency to the current most frequently found value \n",
    "            maxValues.append(value)   #add this value to list of most frequently found values\n",
    "\n",
    "if len(maxValues) > 1:             #if there is more than one value in this list, there is no single mode\n",
    "    print(\"There is no single mode in the input\")\n",
    "else:                              #otherwise there is a single mode\n",
    "    print(\"Mode is \" + str(maxValue))\n",
    "    print(\"It occurs \" + str(maxFreq) + \" times in the input\")\n",
    "print(myInput)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "source": [
    "#### A solution to using loops with dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "geopyter": {
     "Contributors": "James Millington (james.millington@kcl.ac.uk)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-08-17 19:06:58",
      "committed_date": "2017-08-17 19:06:58",
      "committer.name": "Jon Reades",
      "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
     }
    }
   },
   "outputs": [],
   "source": [
    "country_pops = {\n",
    "    'China': 1379150000,\n",
    "    'USA': 324644000,\n",
    "    'India': 1330910000,\n",
    "    'Indonesia': 260581000,\n",
    "    'USA': 324644000,\n",
    "    'India': 1330910000,\n",
    "}\n",
    "\n",
    "unique_pops = {}\n",
    "for country,pop in country_pops.iteritems():  \n",
    "    if country not in unique_pops.values():  \n",
    "        unique_pops[country] = pop  \n",
    "        \n",
    "print(unique_pops)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Credits!\n",
    "\n",
    "#### Contributors:\n",
    "The following individuals have contributed to these teaching materials: James Millington (james.millington@kcl.ac.uk)\n",
    "\n",
    "#### License\n",
    "These teaching materials are licensed under a mix of the MIT and CC-BY licenses...\n",
    "\n",
    "#### Acknowledgements:\n",
    "Supported by the [Royal Geographical Society](https://www.rgs.org/HomePage.htm) (with the Institute of British Geographers) with a Ray Y Gildea Jr Award.\n",
    "\n",
    "#### Potential Dependencies:\n",
    "This notebook may depend on the following libraries: None\n"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "geopyter": {
   "Contributors": [
    "James Millington (james.millington@kcl.ac.uk)"
   ],
   "git": {
    "active_branch": "master",
    "author.name": "Jon Reades",
    "authored_date": "2017-08-17 19:06:58",
    "committed_date": "2017-08-17 19:06:58",
    "committer.name": "Jon Reades",
    "sha": "5e3b396ae18a982d693c4bfd86c721c7e1e21051"
   },
   "libs": {}
  },
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}