Chapter 6 - Dictionaries.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After lists the second major Python data structure is the **dictionary**. While lists and dictionaries might come across as very similar, they have different pros and cons. Programming is mostly about solving real-world problems as efficiently as possible, but it is also important to write and organize code in a human readable fashion. A dictionary offers a kind of abstraction that comes in handy a lot of times: it is a type of \"associative memory\" or key:value storage. It allows you to describe two pieces of data and their relationship. This might seem a bit too abstract, but lets break it down.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We would sometimes like to describe several pieces of information in a way that it is clear that they belong together.  For example if I want to keep track of the grade of a student I can store their u-number and their grade in a tuple as such:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "student = ('u123456', 8.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, if there are multiple students then we cannot suffice with a single tuple. Previously we have worked with lists, and a first straightforward solution seems to be to store this information in two lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "unumbers = ['u123456', 'u223416', 'u383213', 'u234178']\n",
    "grades = [8.5, 7, 8, 6.5]\n",
    "print(sum(grades) / len(grades)) # Calculate the average grade"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This solution allows us to store the information of multiple students, and makes it very easy to analyse the grades. Eventhough we model the relationship between the grade and the u-number by list indexes, I would argue it is not the most intuitive absraction. Also, we impose an implicit ordering on students, which is unnecessary. \n",
    "\n",
    "Another solution is to store a list of tuples, like so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "students = [('u123456', 8.5), ('u223416', 7), ('u383213', 8), ('u234178', 6.5)]\n",
    "# Calculating the average grade:\n",
    "sum_of_grades = 0\n",
    "for (unumber, grade) in students: \n",
    "    sum_of_grades = sum_of_grades + grade\n",
    "print(sum_of_grades / len(students)) # The average grade"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using a list of tuples we can store multiple students while clearly modeling the relationship between the student and their grade. Calculating the average grade is also not that complicated as we just have to loop over the list and extract the grade from the tuple in order to calculate the sum of all the grades. However, what if we would like to **look up** the grade of a particular student? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "students = [('u123456', 8.5), ('u223416', 7), ('u383213', 8), ('u234178', 6.5)]\n",
    "query = 'u234178'\n",
    "for student in students:\n",
    "    if student[0] == query:\n",
    "        print student[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We needed to go through the first 3 students and then find out the grade of the student in question. But imagine if this list was way longer containing all the archive data as well e.g.: for 5000 students per year the list would be 50,000 element long for 10 years of data. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's imagine that we cant't reuse the u-numbers and every time we have a new student we have to make sure that the newly generated number is not among the old ones. In other words we need to **check the membership** of a u-number. So what do we do?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "students = [('u123456', 8.5), ('u223416', 7), ('u383213', 8), ('u234178', 6.5)]\n",
    "candidate = 'u123457'\n",
    "unumbers = []\n",
    "\n",
    "for student in students:\n",
    "    unumbers.append(student[0])\n",
    "    \n",
    "print(candidate in unumbers) # checking membership"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def verbose_in(name, records):\n",
    "    \"\"\" Writing \"in\" out explicitly \"\"\"\n",
    "    for student in students:\n",
    "        if student[0] == name:\n",
    "            return True\n",
    "    return False\n",
    "\n",
    "print(verbose_in(candidate, students))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We went through the whole list just to check out if we have an element in it or not! Thats pretty inefficient. The take home message here is that **lists are not really good if we want to look things up in it or for checking the membership of an element**. Dictionaries for the rescue!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At first glance the Python code for using a dictionary looks very similar to to that for lists, with the difference being that for lists we use [] to create them and for dictionaries we use {}:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "empty_list = [] # Create an empty list\n",
    "empty_dict = {} # Create an empty dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A dictionary consists of one or more **key:value pairs**, the key is the 'identifier' or \"name\" that is used to describe the value. If we would want to store the ordinal values for a list of characters we could for example do the following: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "phonebook = {'Lewis Lame':1122345,'Andrew Parson':8806336,'Peter Power':7658344,'Emily Everett':6784346}\n",
    "\n",
    "print phonebook, '\\n'        # printing the phonebook\n",
    "print phonebook.keys(), '\\n' # method to retrieve the keys\n",
    "print phonebook.values()     # method to retrieve the values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us examine what just happened a bit. We created a phonebook a dictionary of the form {'name': phonenumber}, where the **keys** are strings of the names of people and the **values** are integers representing phone numbers. Note that when we print out the dictionary the key:value pairs are in a different order. This is very important difference between **lists** and **dictionaries**: lists are odereded, while dictionaries are undordered collections. The methods .keys() and .values() can be thought of as differen **views** of the dictionary. .items() is another view.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "phonebook.items()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For another example let's create a dictionary containing the u-numbers and the grades. We can directly create a dictionary from scratch as we did before or we can convert our list of tuples to a dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'u383213': 8, 'u223416': 7, 'u234178': 6.5, 'u123456': 8.5}\n",
      "{'u383213': 8, 'u223416': 7, 'u234178': 6.5, 'u123456': 8.5}\n"
     ]
    }
   ],
   "source": [
    "# From scratch:\n",
    "dict_students = {'u123456': 8.5, 'u223416' : 7, 'u383213' : 8, 'u234178' : 6.5}\n",
    " # Convert the list of tuples to a dictionary using the dict() function:\n",
    "students = [('u123456', 8.5), ('u223416', 7), ('u383213', 8), ('u234178', 6.5)]\n",
    "alternative_dict = dict(students)\n",
    "\n",
    "print(dict_students)\n",
    "print(alternative_dict)\n",
    "# From the print statements we can see that the two dictionaries are identical.\n",
    "# Note: the order of the dictionary as printed below might not be identica to how we created it,\n",
    "# a dictionary is unordered, as such the order of the elements is random."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can access the elements of a dictionary, given a key they return the corresponding value. So if we want to retrieve the grade of the student with u-number u223416 we can do:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "print(dict_students['u223416'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For a list we can only do this in the same way if we know the position in the list that the student is at, and if the position is unknown we have to check all elements of the list (which can be slow for big lists):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "('u223416', 7)\n"
     ]
    }
   ],
   "source": [
    "# If you don't know the position in the lists of tuples:\n",
    "students = [('u123456', 8.5), ('u223416', 7), ('u383213', 8), ('u234178', 6.5)]\n",
    "for (unumber, grade) in students:\n",
    "    if unumber == 'u223416':\n",
    "        print(grade)\n",
    "\n",
    "# If we do know the position:\n",
    "print(students[1]) # When we created our list this student was added second, so it is at position 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we want to modify the content of a dictionary we can use the key to access the element we want to change:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'u383213': 8, 'mistake': 0, 'u223416': 7, 'u234178': 6.5, 'u123456': 8.5}\n",
      "{'u383213': 8, 'u223416': 7, 'u234178': 6.5, 'u123456': 8.5}\n"
     ]
    }
   ],
   "source": [
    "dict_students['u223416'] = 8 # Change the grade of student u223416 to an 8\n",
    "dict_students['u223416'] -= 1 # and back to a 7\n",
    "\n",
    "dict_students['mistake'] = 0 # 'Accidently' add a mistake to our dict, notice that this adds a new element to the dict!\n",
    "print(dict_students)\n",
    "\n",
    "del dict_students['mistake'] # Remove the mistake\n",
    "print(dict_students)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Be careful however with the\n",
    "    \n",
    "    dict[key]\n",
    "   \n",
    "style indexing as if the value does not exist you will get an error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "'Wubben'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-28-55473ddf76fd>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mphoneBook\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m{\u001b[0m\u001b[1;34m'Brown'\u001b[0m\u001b[1;33m:\u001b[0m \u001b[1;36m1443\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'Smith'\u001b[0m\u001b[1;33m:\u001b[0m \u001b[1;36m3253\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'Johnson'\u001b[0m\u001b[1;33m:\u001b[0m \u001b[1;36m3938\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mphoneBook\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'Wubben'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m: 'Wubben'"
     ]
    }
   ],
   "source": [
    "phoneBook = {'Brown': 1443, 'Smith': 3253, 'Johnson': 3938}\n",
    "phoneBook['Wubben']\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To prevent this, you can use\n",
    "\n",
    "    dict.get(key, defaultvalue)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1443\n",
      "None\n",
      "20\n"
     ]
    }
   ],
   "source": [
    "print(phoneBook.get('Brown'))\n",
    "print(phoneBook.get('Wubben'))\n",
    "print(phoneBook.get('Wubben', 20))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iterating over dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dictionaries also support the \n",
    "\n",
    "    for var in iterable:\n",
    "    \n",
    "style iteration and during the iteration dictionaries yield their keys. Remember, dictionaries are unordered, but in the case for example of calculating the average grade for students the order doesn't matter anyway:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'u383213': 8, 'u223416': 7, 'u234178': 6.5, 'u123456': 8.5}\n",
      "u383213 8\n",
      "u223416 7\n",
      "u234178 6.5\n",
      "u123456 8.5\n",
      "7.5\n"
     ]
    }
   ],
   "source": [
    "print dict_students\n",
    "dict_sum = 0\n",
    "for unumber in dict_students:\n",
    "    grade = dict_students[unumber] # Retrieve the grade from the dictionary\n",
    "    dict_sum = dict_sum + grade\n",
    "    print unumber, grade\n",
    "\n",
    "print(dict_sum / len(dict_students))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, this is even more complicated than our list of tuples example, so you might now be wondering how dictionaries are better for this example. Dictionaries are very useful because we can iterate over them in different ways, and there are several functions that help you with this:\n",
    "\n",
    "* dict.keys(), to return a list of all the keys in our dict\n",
    "* dict.items(), to return a list of tuples of all the (key, value) pairs in our dict\n",
    "* dict.values(), to return a list of all the values in our dict\n",
    "\n",
    "As you saw in the above for loop, by default Python will choose the dict.keys() function and loop over all the keys in the dict. So the same example, but more explicit would be:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['u383213', 'u223416', 'u234178', 'u123456']\n",
      "7.5\n"
     ]
    }
   ],
   "source": [
    "dict_sum = 0\n",
    "print dict_students.keys()\n",
    "for unumber in dict_students.keys():\n",
    "    grade = dict_students[unumber] # Retrieve the grade from the dictionary\n",
    "    dict_sum = dict_sum + grade\n",
    "print(dict_sum / len(dict_students))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also use the dict.items() function for this example: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('u383213', 8), ('u223416', 7), ('u234178', 6.5), ('u123456', 8.5)]\n",
      "7.5\n"
     ]
    }
   ],
   "source": [
    "dict_sum = 0\n",
    "print dict_students.items()\n",
    "for (unumber, grade) in dict_students.items(): # destructing\n",
    "    # Now we no longer need to retrieve the grade from the dictionary\n",
    "    dict_sum = dict_sum + grade\n",
    "print(dict_sum / len(dict_students))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, because we can also return a list of all the values we can simplify the code to calculate the average grade significantly, by taking the sum of the dict.values() and dividing this by the number of elements in our dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print(sum(dict_students.values()) / len(dict_students)) # Calculate the average grade"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because dictionaries are a very clever, it is possible to use them as lists of tuples, and as multiple lists. Which is something we can verify using some print statements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('unumbers:', ['u123456', 'u223416', 'u383213', 'u234178'])\n",
      "('dict_students.keys():', ['u383213', 'u223416', 'u234178', 'u123456'])\n",
      "()\n",
      "('grades:', [8.5, 7, 8, 6.5])\n",
      "('dict_students.values():', [8, 7, 6.5, 8.5])\n",
      "()\n",
      "[('u123456', 8.5), ('u223416', 7), ('u383213', 8), ('u234178', 6.5)]\n",
      "[('u383213', 8), ('u223416', 7), ('u234178', 6.5), ('u123456', 8.5)]\n"
     ]
    }
   ],
   "source": [
    "# The unumbers list from our multiple lists example\n",
    "unumbers = ['u123456', 'u223416', 'u383213', 'u234178']\n",
    "print('unumbers:', unumbers)\n",
    "# contains the same unumbers as dict_students.keys() (but in a different order, because dictionaries are unodered)\n",
    "dict_students = {'u123456': 8.5, 'u223416' : 7, 'u383213' : 8, 'u234178' : 6.5}\n",
    "print('dict_students.keys():', dict_students.keys())\n",
    "\n",
    "print()\n",
    "\n",
    "# And the same for the grades\n",
    "grades = [8.5, 7, 8, 6.5]\n",
    "print('grades:', grades)\n",
    "# and dict_student.values()\n",
    "print('dict_students.values():', dict_students.values())\n",
    "\n",
    "print()\n",
    "\n",
    "# Similar the list of tuples\n",
    "students = [('u123456', 8.5), ('u223416', 7), ('u383213', 8), ('u234178', 6.5)]\n",
    "print(students)\n",
    "# Contains the same tuples as dict_students.items()\n",
    "print(dict_students.items())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Thanks to these possibilities of dictionaries we have all the benefits of both lists of tuples and multiples lists, and none of the downsides."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Testing if a key is in a dictionary\n",
    "\n",
    "Dictionaries really excel in the speed of lookup times and in a lot of cases it can be important to know whether an entry with a certain key already exists. To make sure that dictionaries are fast containers Python does not allow to create different values with the same key. Membership can be checked using the 'in' keyword and the list of keys that can be retrieved using the .keys() method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('u123456', 'is in our dictionary')\n",
      "('u223416', 'is in our dictionary')\n",
      "('u000000', 'is NOT in our dictionary')\n",
      "()\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "dict_students = {'u123456': 8.5, 'u223416' : 7, 'u383213' : 8, 'u234178' : 6.5}\n",
    "\n",
    "for unum in ['u123456', 'u223416', 'u000000']: # List of students we want to check\n",
    "    if unum in dict_students:\n",
    "        print(unum, 'is in our dictionary')\n",
    "    else:\n",
    "        print(unum, 'is NOT in our dictionary')   \n",
    "print()\n",
    "\n",
    "# because the .keys() method returns a list the following simply prints the outcome of the boolean expression.\n",
    "print('u123456' in dict_students)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Storing more complex values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Until now we have only considered the case in which the key:value pairs that we want to store consist of a single value. However, it is possible to store much more complex values in dictionaries. Actually, values can be arbitrary Python objects. We could for example store an entire  list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Statistics\n",
      "Data processing\n",
      "Introduction HAIT\n"
     ]
    }
   ],
   "source": [
    "courses = {'Data processing': ['u123456', 'u383213', 'u234178'], \n",
    "           'Statistics' : ['u123456', 'u223416', 'u234178'], \n",
    "           'Introduction HAIT' : ['u123456', 'u223416', 'u383213']}\n",
    "\n",
    "#print(courses)\n",
    "for i in courses:\n",
    "    print i"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Which allows us to store which students are taking which courses. But because we have shown in the previous examples that we would like to store the students grades, we can actually also store another dictionary as the value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "()\n",
      "Statistics\n",
      "{'u223416': 7.2, 'u234178': 8, 'u123456': 5.2}\n",
      "Data processing\n",
      "{'u383213': 8, 'u234178': 6.5, 'u123456': 8}\n",
      "Introduction HAIT\n",
      "{'u383213': 7, 'u223416': 6.6, 'u123456': 8}\n"
     ]
    }
   ],
   "source": [
    "courses_grades = {'Data processing': {'u123456': 8, 'u383213' : 8, 'u234178' : 6.5}, \n",
    "           'Statistics' : {'u123456': 5.2, 'u223416' : 7.2, 'u234178' : 8}, \n",
    "           'Introduction HAIT' : {'u123456': 8, 'u223416' : 6.6, 'u383213' : 7}}\n",
    "\n",
    "#print(courses_grades)\n",
    "\n",
    "print()\n",
    "#print courses_grades.items()\n",
    "# Calculating the average grade per course:\n",
    "for (course, results) in courses_grades.items():\n",
    "    print course\n",
    "    print results\n",
    "    avg = sum(results.values()) / len(results)\n",
    "    #print(course, avg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Additionally, we could repeat this pattern indefinitely, or we can choose to store a list of multiple grades rather than a single grade per course. However, it depends on your use case and how complex your data structure needs to be. Often simpler is better.\n",
    "\n",
    "Repeatedly placing data structures inside similar other data structures is commonly referred to as nesting, which allows to create an hierarchy of (nested) data structures."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## More complex keys"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So far all the keys we've used were strings, but they don't have to be. In fact, Python is happy with a great variety of key types. In this section we'll consider two additional key types: integers, and tuples.\n",
    "\n",
    "When using an integer as the key a dictionary can look a lot like a list, as we can see from the following example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Create a dictionary and a list of our 8 digit number.\n",
    "integer_dict = {0: 4, 1: 0, 2: 6, 3: 3, 4: 1, 5: 7, 6: 8, 7: 5} \n",
    "integer_list = [4, 0, 6, 3, 1, 7, 8, 5]\n",
    "\n",
    "# Go over the numbers one by one and compare them\n",
    "for i in range(0, 8):\n",
    "    print(\"Entry\", i, \"has the value\", integer_dict[i], \"in the dictionary, and\", integer_list[i], \"in the list.\")\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see we can use the same syntax to access the values in both the dictionary and the list, and because we assigned them similarly all the values are the same. Yet, on closer inspection you will notice that a dictionary and a list behave very differently:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Create another dict and list \n",
    "another_dict = {0: 4, 1: 0, 2: 6, 3: 3, 4: 1, 5: 7, 6: 8, 7: 5} \n",
    "another_list = [4, 0, 6, 3, 1, 7, 8, 5]\n",
    "# Print their values\n",
    "print(another_dict.values())\n",
    "print(another_list)\n",
    "print()\n",
    "# Remove the 4th element from both the list and the dict\n",
    "del another_dict[4]\n",
    "del another_list[4]\n",
    "# Print their values again\n",
    "print(another_dict.values())\n",
    "print(another_list)\n",
    "print()\n",
    "# They look similar enough right?\n",
    "# But what if we print the keys for the dictionary\n",
    "print(another_dict.keys())\n",
    "# The 4 is gone, but it still goes to 7\n",
    "print(range(0, len(another_list)))\n",
    "# Yet the list goes from 0 to 6\n",
    "print()\n",
    "# and if we try to print the 4th element from the list\n",
    "print(another_list[4])\n",
    "# It works well, but the dict will give an error\n",
    "print(another_dict[4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hopefully this example makes it clear that it can be tempting to think of a dictionary as a list, but that their behaviour is very different and it can lead to problems if we treat a dictionary as a list.\n",
    "\n",
    "A more useful application for dictionaries with integers as keys is found when the keys have more importance, and we don't want to start at 0, for example when we want to keep track in which year a group of students were born:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1992: ['u383213'], 1989: ['u123456'], 1991: ['u223416', 'u234178']}\n"
     ]
    }
   ],
   "source": [
    "birthyears = {1989: ['u123456'], 1991: ['u223416', 'u234178'], 1992: ['u383213']}\n",
    "print(birthyears)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the case of birthyears it is useful that we can use a dictionary instead of a list as we do not want to create a list that starts at 0, because of the severe lack of students that were born before the year 1900. \n",
    "\n",
    "It is also possible to create a dictionary with a tuple as the key, this can be useful when we want to use two distinct pieces of information to create the key. An example of this is when we have a list of courses and grades for multiple years, as the courses are taught every year."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7.16666666667\n",
      "7.83333333333\n"
     ]
    }
   ],
   "source": [
    "yearly_courses_grades = {('Data processing', '2013/2014'): {'u123456': 8, 'u383213' : 8, 'u234178' : 6.5}, \n",
    "                         ('Data processing', '2014/2015'): {'u423486': 7, 'u213242' : 9, 'u265421' : 7.5},\n",
    "                         ('Statistics', '2013/2014') : {'u123456': 5.2, 'u223416' : 7.2, 'u234178' : 8},\n",
    "                         ('Statistics', '2014/2015') : {'u423486': 6.5, 'u213242' : 8, 'u265421' : 7}}\n",
    "\n",
    "\n",
    "for (course, grades) in yearly_courses_grades.items():\n",
    "    if course[1] == '2014/2015':\n",
    "        print sum(grades.values()) / len(grades)\n",
    "\n",
    "# And we can retrieve the information using the same tuples\n",
    "#print('The grade for u123456 for Data Processing 2013/2014 was:', \n",
    "#      yearly_courses_grades[('Data processing', '2013/2014')]['u123456'])\n",
    "\n",
    "#print('The grade for u123456 for Data Statistics 2013/2014 was:', \n",
    "#      yearly_courses_grades[('Statistics', '2013/2014')]['u123456'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Take  all the 2014/2015 courses and calculate the average grades for them"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly to the values, the keys can be made very complex (any immutable object can be a key), but often you don't need such complexity. Try to keep it simple and appropriate for your purpose. Below we show an example where we use a dictionary to represent a lot of information about composters:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Composer': {'first': 'Johannes', 'last': 'Brahms'},\n",
       " 'Period': 'Romantic',\n",
       " 'Piece': ['Piano Concerto No. 1',\n",
       "  'Piano Concerto No. 2',\n",
       "  'Symphony No. 1',\n",
       "  'Symphony No. 2',\n",
       "  'Violin Concerto in D Major',\n",
       "  'Hungarian Dances']}"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " D = {'Composer': {'first': 'Johannes', 'last' : 'Brahms'},\n",
    "      'Period': 'Romantic',\n",
    "      'Piece' : ['Piano Concerto No. 1', 'Piano Concerto No. 2',\n",
    "                'Symphony No. 1', 'Symphony No. 2',\n",
    "\t\t         'Violin Concerto in D Major',\n",
    "                 'Hungarian Dances'] }\n",
    "D"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Excercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Ex 1. \n",
    "\n",
    "+ Write a function that given two lists returns a dictionary whose keys are the first list, and the values the second list. Then call your function with the two lists below and print the title and IMDB rating for each movie. \n",
    "\n",
    "+ Write a function that calculates the average of the reviews\n",
    "+ Write the function that returns the movie with the max and min ratings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'12 Angry Men': 8.6,\n",
       " 'Pulp Fiction': 8.9,\n",
       " \"Schindler's List\": 6.9,\n",
       " 'The Dark Knight': 8.4,\n",
       " 'The Godfather': 9.1,\n",
       " 'The Godfather: Part II': 9.0,\n",
       " 'The Shawshank Redemption': 9.2}"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "keyList = ['The Shawshank Redemption', 'The Godfather', 'The Godfather: Part II', 'The Dark Knight', '12 Angry Men', 'Schindler\\'s List', 'Pulp Fiction']\n",
    "valueList = [9.2, 9.1, 9.0, 8.4, 8.6, 6.9, 8.9]\n",
    "dict( zip(keyList, valueList) )\n",
    "# Your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### a.kadar@uvt.nl"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Ex 2. Add the movies from the newEntries list of tuples to the dictionary you created in excercise 1. If the movie is already in your dictionary you shouldn't try and add it again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "newEntries = [('Fight Club', 8.8), ('Forrest Gump', 8.7), ('The Godfather', 'WRONG'), ('Spirited Away', 8.5), ('A Clockwork Orange', 8.3), ('The Dark Knight', 'WRONG')]\n",
    "\n",
    "# Your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Ex 3. Copy the 'courses_grades' dictionary from the example above and calculate the average grade for the student with u-number 'u123456' across all three courses."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Extra on mutability"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To make understanding easier variables are usually taught with the metaphore that they are like little bags that you put stuff into. In reality however variables do not contain values (like a tupper box contains food), they actually point to\n",
    "values in the memory, like a name points to a person."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "mike = ['khakis', 't-shirt', 'shoes']\n",
    "mr_dawson = mike\n",
    "honey = mike"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['khakis', 't-shirt', 'shoes'] \n",
      "['khakis', 't-shirt', 'shoes'] \n",
      "['khakis', 't-shirt', 'shoes']\n"
     ]
    }
   ],
   "source": [
    "print mike,'\\n', mr_dawson,'\\n',honey"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So now, both mike, mr_dawson and honey are point to the list ['khakis', 't-shirt', 'shoes']. Now if we change mike, we also change mr_dawson and honey."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['khakis', 'jean jacket', 'shoes', 'glasses']\n",
      "['khakis', 'jean jacket', 'shoes', 'glasses', 'glasses']\n",
      "['khakis', 'jean jacket', 'shoes', 'glasses', 'glasses']\n"
     ]
    }
   ],
   "source": [
    "print(mike)\n",
    "mr_dawson.append('glasses')\n",
    "print(mike)\n",
    "honey[1] = 'jean jacket'\n",
    "print(mike)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "akos\n"
     ]
    }
   ],
   "source": [
    "a = 'Akos'\n",
    "b = a.replace('A', 'a')\n",
    "print b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This can be dangerous, because we can modify mr_dawson by accident and still think that mike is the same list we started out with. Such phenomena are usually referred to as **side-effects** of **mutable** data structures. In Pyhton both **lists** and **dictionaries** are mutable. However, this is not true for strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'str' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-1-49b3617bc9f6>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mname\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m\"Bob Burger\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mname\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m's'\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'str' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "name = \"Bob Burger\"\n",
    "name[-1] = 's'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('a', 12343), ('c', 235234), ('b', 2342345)]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p = {\"a\":12343, \"b\": 2342345, \"c\": 235234}\n",
    "p.items()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('a', 12343), ('c', 235234), ('b', 2342345)]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p.keys()\n",
    "p.values()\n",
    "p.items()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "From the point of view of dictionaries this is an important as they can only take as keys **immutable** types, such as **integers**, **strings** or **tuples**."
   ]
  }
 ],
 "metadata": {
  "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}