notebook-6 Dictionaries.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Notebook-6: Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lesson Content \n",
    "\n",
    "Welcome back to the fifth Code Camp notebook! In this lesson we'll continue our exploration of more advanced data structures. Last time we took a peek at a way to represent ordered collections of items via **lists**.\n",
    "\n",
    "This time we'll use **dictionaries** to create collections of unordered items (this is just an easy distinction - there's much more to it - but it's a good way to start wrapping your head around the subject).\n",
    "\n",
    "### In this Notebook\n",
    "\n",
    "- Creating dictionaries\n",
    "- Accessing elements of dictionaries\n",
    "- Methods of dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dictionaries\n",
    "----\n",
    "\n",
    "Dictionaries are another kind of data structure that is frequently used in Python. Like lists, the dictionary is also found in other programming languages, often under a different name. For instance, Python dictionaries might be referred to elsewhere as \"maps\", \"hashes\", or \"associative arrays\").\n",
    "\n",
    "According to the [Official Docs](https://docs.python.org/2/tutorial/datastructures.html#dictionaries):\n",
    "\n",
    "> It is best to think of a dictionary as an unordered set of key-value pairs, with the requirement that the keys are unique (within one dictionary). A pair of braces creates an empty dictionary: {}\n",
    "\n",
    "In other words, dictionaries are not lists: instead of just a checklist, we now have a _key_ and a _value_. We use the key to find the value. So a generic dictionary looks like this:\n",
    "\n",
    "```python\n",
    "theDictionary = {\n",
    "    key1: value1,\n",
    "    key2: value2,\n",
    "    key3: value3,\n",
    "    ...\n",
    "}\n",
    "```\n",
    "Each key/value _pair_ is linked by a ':', and each pair is separated by a ','. It doesn't really matter if you put everything on new lines (as we do here) or all on the same line. We're just doing it this way to make it easier to read.\n",
    "\n",
    "Here's a real one:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "myDict = {\n",
    "    \"key1\": \"Value 1\",\n",
    "    \"key2\": \"2nd Value\",\n",
    "    3: \"3rd Value\",\n",
    "    \"Fourth Key\": [4.0, 'Jon']\n",
    "}\n",
    "print (myDict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Did you notice that when we printed out `myDict` it didn't print out the elements of dictionary in the same order as we put items into it? That's what we mean when we say that dictionaries are _un_-ordered. Always remember that you have no idea how things are stored in a dictionary can't rely on indexing like you can with a list. Explaining _why_ this works this way is something you'd encounter in a first year Computer Science course.\n",
    "\n",
    "And notice too that every type of data can go into a dictionary: strings, integers, and floats. There's even a _list_ in there (`[4.0, 'Jon']`)! The _only_ constraint is that the **key must be *immutable***; this means that it is a simple, static identifier and that can't change the value of a key later such as you might using a list, dictionary, or changing variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# this will result in an error\n",
    "myFaultyDict = {\n",
    "    [\"key1\", 1]: \"Value 1\", \n",
    "    \"key2\": \"2nd Value\", \n",
    "    3: \"3rd Value\", \n",
    "    8.0: [5, 'jon']\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This doesn't work because you can't use a list (`[\"key1\",1]`) as a key, though as you saw above you can use a list as a _value_. For more on the subject of (im)mutability checkout [this SO answer](http://stackoverflow.com/a/8059504) ).\n",
    "\n",
    "## Accessing Dictionaries\n",
    "\n",
    "Like lists, we access an element in a dictionary using a 'location' marked out by a pair of square brackets (*[...]*). The difference is that the index is no longer an integer indicating the position of the item that we want to access, but is a *key* in the *key:value* pair:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print (myDict[\"key1\"])\n",
    "print (myDict[3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice how now we just jump straight to the item we want? We don't need to think about \"Was that the fourth item in the list? Or the fifth?\", we just use a sensible key and we can ask for the associated value directly.\n",
    "\n",
    "#### A challenge for you!\n",
    "\n",
    "How would you print out \"2nd Value\" from `myDict`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print (myDict[???])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When it comes to error messages, `dict`s and `list`s behave in similar ways. If you try to access a dictionary using a key that doesn't exist then Python raises an *exception*. \n",
    "\n",
    "What is the name of the exception? Can you find it the [Official Docs](https://docs.python.org/2/library/exceptions.html)?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print (myDict[99])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Handy, no? Again, Python's error messages are giving you helpful clues about where the problem it's encountering might be! Up above we had a `TypeError` when we tried to create a key using a list. Here, we have a `KeyError` that tells us something must be wrong with using `99` as a key in `myDict`. In this case, it's that there is no key 99!\n",
    "\n",
    "## Creating a Simple Phone Book\n",
    "\n",
    "One of the simplest uses of a dictionary is as a phone book! One of us did this in BASIC back in 1989 (Yes, James is that old! Much older than Jon who definitely never did anything in BASIC, no sirree!).\n",
    "\n",
    "So here are some useful contact numbers:\n",
    "1. American Emergency Number: 911\n",
    "2. British Emergency Number: 999\n",
    "3. Icelandic Emergency Number: 112\n",
    "4. French Emergency Number: 112\n",
    "5. Russian Emergency Number: 102\n",
    "\n",
    "Now, how would you create a dictionary that allowed us to look up and print out an emergency phone number based on the [two-character ISO country code](http://www.nationsonline.org/oneworld/country_code_list.htm)? It's going to look a little like this:\n",
    "```python\n",
    "eNumbers = {\n",
    "    ...\n",
    "}\n",
    "print (\"The Icelandic emergency number is \" + eNumbers['IS'])\n",
    "print (\"The American emergency number is \" + eNumbers['US'])\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "eNumbers = {\n",
    "    ???\n",
    "}\n",
    "print (\"The Icelandic emergency number is \" + eNumbers['IS'])\n",
    "print (\"The American emergency number is \" + eNumbers['US'] )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Useful Dictionary Methods\n",
    "\n",
    "We are going to see in the next couple of notebooks how to systematically access values in a dictionary (amongst other things). For now, let's also take in the fact the dictionaries _also_ have utility *methods* similar what we saw with the `list`. And as with the list, these methods are functions that only make sense _when_ you're working with a dictionary, so they're bundled up in a way that makes them easy to use.\n",
    "\n",
    "Let's say that you have forgotten what *keys* you put in your dictionary..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "dictionary = {\n",
    "    \"Charles\": \"Babbage\",\n",
    "    \"Ada\": \"Lovelace\",\n",
    "    \"Alan\": \"Turing\"\n",
    "}\n",
    "\n",
    "print (dictionary.keys())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or maybe you just need to access all of the values without trouble to ask for each key:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print (dictionary.values())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or maybe you even need to get them as pairs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Output is a list of key-value pairs!\n",
    "print (dictionary.items())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Are You On the List? (Part 2)\n",
    "\n",
    "As with the `list` data type, you can check the presence or absence of a key in a dictionary, using the *in* / *not in* operators... but note that they only work on keys."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print (\"Charles\" in dictionary)\n",
    "print (\"Babbage\" in dictionary)\n",
    "print (True  not in dictionary)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What Do You Do if You're Not On the List?\n",
    "\n",
    "One challenge with dictionaries is that sometimes we have no real idea if a key exists or not. With a list it's pretty easy to figure out whether or not an index exists because we can just ask Python to tell us the _length_ of the list. So that makes it fairly easy to avoid having the list 'blow up' by throwing an exception.\n",
    "\n",
    "Rather harder for a dictionary though, so that's why we have the dedicated **`get()`** method: it not only allows us to fetch the *value* associated with a *key*, it also allows us to specify a default value in case the key does not exist:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print (dictionary.get(\"Lady Ada\", \"Are you sure you spelled that right?\" ))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "See how this works: they key doesn't exist, but unlike what happened when we asked for `myDict[99]` we don't get an exception, we get the default value specified as the _second_ input to the method `get`. \n",
    "\n",
    "So you've learned two things here: that functions can take more than one input (this one takes both the key that we're looking for, and a value to return if Python can't find the key); and that different types (or classes) of data have different methods (there's no `get` for lists)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists of Lists, Dictionaries of Lists, Dictionaries of Dictionaries... Oh my!\n",
    "\n",
    "OK, this is where it's going to get a little weird but you're also going to see how programming is a little like Lego: once you get the building blocks, you can make lots of cool/strange/useful contraptions from some pretty simple concepts.\n",
    "\n",
    "Remember that a list or dictionary can store _anything_: so the first item in your list could itself _be_ a list! For most people starting out on programming this is the point where their brain starts hurting (it happened to us) and you might want to throw up your hands in frustration thinking \"I'm never going to understand this!\" But if you stick with it, you will. \n",
    "\n",
    "And this is really the start of the power of computation.\n",
    "\n",
    "### A Data Set of City Attributes\n",
    "\n",
    "Let's start out with what some (annoying) people would call a 'trivial' example of how a list-of-lists (LoLs, though most people aren't laughing) can be useful. Let's think through what's going on below: what happens if we write `cityData[0]`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Format: city, country, population, area (km^2)\n",
    "cityData = [\n",
    "    ['London','U.K.',8673713,1572],\n",
    "    ['Paris','France',2229621,105],\n",
    "    ['Washington, D.C.','U.S.A.',672228,177],\n",
    "    ['Abuja','Nigeria',1235880,1769],\n",
    "    ['Beijing','China',21700000,16411],\n",
    "]\n",
    "\n",
    "print (cityData[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So how would we access something inside the list returned from `cityData[0]`?\n",
    "\n",
    "Why not try:\n",
    "```python\n",
    "cityData[0][1]\n",
    "```\n",
    "See if you can figure out how to retrieve and print the following from `cityData`:\n",
    "1. France\n",
    "2. 16411\n",
    "3. Washington, D.C.\n",
    "Type the code into the coding area below..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A Phonebook+\n",
    "\n",
    "So that's a LoL (list-of-lists). Let's extend this idea to what we'll call Phonebook+ which will be a DoL (dictionary-of-lists). In other words, a phonebook that can _do more_ than just give us phone numbers! We're going to build on the emergency phonebook example above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# American Emergency Number: 911\n",
    "# British Emergency Number: 999\n",
    "# Icelandic Emergency Number: 112\n",
    "# French Emergency Number: 112\n",
    "# Russian Emergency Number: 102\n",
    "eNumbers = {\n",
    "    'IS': ['Icelandic',112],\n",
    "    'US': ['American',911],\n",
    "}\n",
    "print (\"The \" + eNumbers['IS'][0] + \" emergency number is \" + str(eNumbers['IS'][1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "See if you can create the rest of the `eNumbers` dictionary and then print out the Russian and British emergency numbers.\n",
    "\n",
    "### Dictionary-of-Dictionaries\n",
    "\n",
    "OK, this is the last thing we're going to through at you today – getting your head around 'nested' lists and dictionaries is _hard_. Really hard. But it's the all-important first step to thinking about data the way that computer 'thinks' about it. This is really abstract: something that you access by keys, which in turn give you access to other keys... it's got a name: recursion. And it's probably one of the cleverest thing about computing. \n",
    "\n",
    "Here's a bit of a complex DoD, combined with a DoL, and other nasties:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "cityData2 = {\n",
    "    'London' : {\n",
    "        'population': 8673713,\n",
    "        'area': 1572, \n",
    "        'location': [51.507222, -0.1275],\n",
    "        'country': {\n",
    "            'ISO2': 'UK',\n",
    "            'Full': 'United Kingdom',\n",
    "        },\n",
    "    },\n",
    "    'Paris' : {\n",
    "        'population': 2229621,\n",
    "        'area': 105.4,\n",
    "        'location': [48.8567, 2.3508],\n",
    "        'country': {\n",
    "            'ISO2': 'FR',\n",
    "            'Full': 'France',\n",
    "        },\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Try the following code in the coding area below:\n",
    "```python\n",
    "print (cityData2['Paris'])\n",
    "print (cityData2['Paris']['country']['ISO2'])\n",
    "print (cityData2['Paris']['location'][0])\n",
    "```\n",
    "\n",
    "Now, figure out how to print:\n",
    "`The population of Paris, the capital of France (FR), is 2229621. It has a density of 21153.899 persons per square km.`\n",
    "\n",
    "Do the same for London."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Code (Applied Geo-example)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's continue our trips around the world! This time though, we'll do things better, and instead of using a simple URL, we are going to use a real-word geographic data type, that you can use on a web-map or in your favourite GIS software.\n",
    "\n",
    "If you look down below at the `KCL_position` variable you'll see that we're assigning it an apparently complex and scary data structure.  Don't be afraid!  If you look closely enough you will notice that is just made out the \"building blocks\" that we've seen so far: `floats`, `lists`, `strings`..all wrapped comfortably in a cosy `dictionary`!\n",
    "\n",
    "This is simply  a formalised way to represent a *geographic marker* (a pin on the map!) in a format called `GeoJSON`.\n",
    "\n",
    "According to the awesome [Lizy Diamond](https://twitter.com/lyzidiamond?lang=en-gb) \n",
    "\n",
    ">[GeoJSON](http://geojson.org/geojson-spec.html) is an open and popular geographic data format commonly used in web applications. It is an extension of a format called [JSON](http://json.org), which stands for *JavaScript Object Notation*. Basically, JSON is a table turned on its side. GeoJSON extends JSON by adding a section called \"geometry\" such that you can define coordinates for the particular object (point, line, polygon, multi-polygon, etc). A point in a GeoJSON file might look like this:\n",
    "\n",
    "    {\n",
    "      \"type\": \"Feature\",\n",
    "      \"geometry\": {\n",
    "        \"type\": \"Point\",\n",
    "        \"coordinates\": [\n",
    "          -122.65335738658904,\n",
    "          45.512083676585156\n",
    "        ]\n",
    "      },\n",
    "      \"properties\": {\n",
    "        \"name\": \"Hungry Heart Cupcakes\",\n",
    "        \"address\": \"1212 SE Hawthorne Boulevard\",\n",
    "        \"website\": \"http://www.hungryheartcupcakes.com\",\n",
    "        \"gluten free\": \"no\"\n",
    "      }\n",
    "    }\n",
    "    \n",
    ">GeoJSON files have to have both a `\"geometry\"` section and a `\"properties\"` section. The `\"geometry\"` section houses the geographic information of the feature (its location and type) and the `\"properties\"` section houses all of the descriptive information about the feature (like fields in an attribute table). [Source](https://github.com/lyzidiamond/learn-geojson)\n",
    "\n",
    "\n",
    "Now, in order to have our first \"webmap\", we have to re-create such `GeoJSON` structure. \n",
    "\n",
    "As you can see there are two variables containing King's College Longitude/Latitude coordinate position. Unfortunately they are in the wrong data type. Also, the variable `longitude` is not included in the list `KCLCoords` and the list itself is not assigned as a value to the `KCLGeometry`dictionary.\n",
    "\n",
    "Take all the necessary steps to fix the code, using the functions we've seen so far.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# don't worry about the following line\n",
    "# I'm simply requesting a module from Python\n",
    "# to have additional functions at my disposal\n",
    "# which usually are not immediately available\n",
    "import json\n",
    "\n",
    "# King's College coordinates\n",
    "# What format are they in? Does it seem appropriate?\n",
    "# How would you convert them back to numbers?\n",
    "longitude = '-0.11596798896789551'\n",
    "latitude = '51.51130657591914'\n",
    "\n",
    "# Set this up as a coordinate pair \n",
    "KCLCoords = [??? , latitude ]\n",
    "\n",
    "# How can you assign KCLCoords to \n",
    "# the key KCLGeometry[\"coordinates\"]?\n",
    "KCLGeometry = {\n",
    "        \"type\": \"Point\",\n",
    "        \"coordinates\": ???\n",
    "      }\n",
    "\n",
    "KCL_position = {\n",
    "  \"type\": \"FeatureCollection\",\n",
    "  \"features\": [\n",
    "    {\n",
    "      \"type\": \"Feature\",\n",
    "      \"properties\": {\n",
    "        \"marker-color\": \"#7e7e7e\",\n",
    "        \"marker-size\": \"medium\",\n",
    "        \"marker-symbol\": \"building\",\n",
    "        \"name\": \"KCL\"\n",
    "      },\n",
    "      \"geometry\": KCLGeometry\n",
    "    }\n",
    "  ]\n",
    "}\n",
    "\n",
    "# OUTPUT\n",
    "# -----------------------------------------------------------\n",
    "# I'm just using the \"imported\" module to print the output\n",
    "# in a nice and formatted way\n",
    "print(json.dumps(KCL_position, indent=4))\n",
    "\n",
    "# here I'm saving the variable to a file on your local machine\n",
    "# You should see it if you click on the 'Home' tab in your open\n",
    "# browser window (it's the one where you started this notebook)\n",
    "with open('my-first-marker.geojson', 'w') as outfile:\n",
    "    json.dump(json.dumps(KCL_position, indent=4), outfile)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After you've run the code, Python will have saved a file called `my-first-marker.geojson` in the folder where you are running the notebook. Try to upload it on [this website (Geojson.io)](http://geojson.io/#map=2/20.0/0.0) and see what it shows!                                               "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "**Congratulations on finishing your sixth notebook!**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Further references:\n",
    "\n",
    "General list or resources\n",
    "- [Awesome list of resources](https://github.com/vinta/awesome-python)\n",
    "- [Python Docs](https://docs.python.org/2.7/tutorial/introduction.html)\n",
    "- [HitchHiker's guide to Python](http://docs.python-guide.org/en/latest/intro/learning/)\n",
    "- [Python for Informatics](http://www.pythonlearn.com/book_007.pdf)\n",
    "- [Learn Python the Hard Way - Lists](http://learnpythonthehardway.org/book/ex32.html)\n",
    "- [Learn Python the Hard Way - Dictionaries](http://learnpythonthehardway.org/book/ex39.html)\n",
    "- [CodeAcademy](https://www.codecademy.com/courses/python-beginner-en-pwmb1/0/1)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*The content and structure of this teaching project itself is licensed under the [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 license](https://creativecommons.org/licenses/by-nc-sa/4.0/) , and the contributing source code is licensed under [The MIT License](https://opensource.org/licenses/mit-license.php).   *"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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": 1
}