dictionaries.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lists\n",
    "<img src=\"list.merm.png\">\n",
    "### Dictionaries\n",
    "<img src=\"key_value.merm.png\" width=\"600px\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Keys and values\n",
    "Dictionaries **map keys to values**. They represent **mappings** from one set of values to another. \n",
    "\n",
    "A **key** is something we want to use to **look up** a value later. It can be (pretty much) any value: it could be an integer; or a string; or a sequence of strings. \n",
    "\n",
    "A **value** can be any value at all: a string, an image, a network connection: anything we can store in a Python variable.\n",
    "\n",
    "For example, if I were building a dictionary to represent students in a class, I would use **matric numbers** as **keys** and student names and exam scores as **values**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Obviously, two lists could be used instead: one list of possible seasons and a corresponding list of the colours to lookup could be used. But that can be very inefficient as the table gets larger -- you have to step through each element of the table to find the corresponding lookup.\n",
    "\n",
    "Dictionaries are both a simple **and** very efficient way of doing this. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Literal syntax\n",
    "A dictionary has a literal syntax with curly braces, and each key mapped to one value with a colon to separate them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "letter_map = {\"a\": 1, \"b\": 2, \"c\": 3, \"d\": 4}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we wish to store information about every student in the classes exam result we could use lists.\n",
    "\n",
    "1. One method is to have a list of lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "exam = [[\"Ann\",15],[\"Bob\",9],[\"Calum\",19],[\"Dave\",2],[\"Eve\",12]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To access each student's information, we can iterate over it using a for loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for student in exam:\n",
    "    print(student)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now on each iteration student is a list in the form [name,exam].\n",
    "\n",
    "    To access the student's name we use student[0]\n",
    "    To access the student's exam score we use student[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for student in exam:\n",
    "    print(\"%s got %d in the exam\" %(student[0],student[1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Alternatively we could use 2 lists\n",
    "\n",
    "    names is a list of all the student's names.\n",
    "    marks is a list of all the student's marks.\n",
    "    \n",
    "The ith element of marks refers to the mark of the ith element of names."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "names = [\"Ann\",\"Bob\",\"Calum\",\"Dave\",\"Eve\"]\n",
    "marks = [15,9,19,2,12]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To print the information out together we need to access the position in the list. There are two methods of doing this, either iterate over the indicies or enumerate one of the lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ann got 15 in the exam\n",
      "Bob got 9 in the exam\n",
      "Calum got 19 in the exam\n",
      "Dave got 2 in the exam\n",
      "Eve got 12 in the exam\n",
      "\n",
      "Ann got 15 in the exam\n",
      "Bob got 9 in the exam\n",
      "Calum got 19 in the exam\n",
      "Dave got 2 in the exam\n",
      "Eve got 12 in the exam\n"
     ]
    }
   ],
   "source": [
    "#iterate over indices...\n",
    "for i in range(len(names)):\n",
    "    print(\"%s got %d in the exam\" %(names[i],marks[i]))\n",
    "    \n",
    "print()\n",
    "    \n",
    "#or enumerate one of the lists....\n",
    "for i,n in enumerate(names):\n",
    "    print(\"%s got %d in the exam\" %(n,marks[i]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Another option is to use a dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "results = {\"Ann\":15,\"Bob\":9,\"Calum\":19,\"Dave\":2,\"Eve\":12}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here the keys of the dictionary are the student's names and the values are their exam results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Ann', 'Bob', 'Calum', 'Dave', 'Eve']\n"
     ]
    }
   ],
   "source": [
    "#prints out all the keys in the dictionary.\n",
    "print(list(results.keys()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[15, 9, 19, 2, 12]\n"
     ]
    }
   ],
   "source": [
    "#prints out all the values in the dictionary\n",
    "print(list(results.values()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('Ann', 15), ('Bob', 9), ('Calum', 19), ('Dave', 2), ('Eve', 12)]\n"
     ]
    }
   ],
   "source": [
    "#print out all the tuples in the form (key,value)\n",
    "print(list(results.items()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ann got 15 in the exam\n",
      "Bob got 9 in the exam\n",
      "Calum got 19 in the exam\n",
      "Dave got 2 in the exam\n",
      "Eve got 12 in the exam\n"
     ]
    }
   ],
   "source": [
    "for key in results:\n",
    "    print(\"%s got %d in the exam\" %(key,results[key]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Arbitrary ordering\n",
    "**Dictionaries store keys in arbitrary order**. There is **no** guarantee about what order the keys are in. You should assume it is random. If you need ordering, use a list (or another datatype). A dictionary is an unordered collection: it just maintains the relation between keys and values. It can also have **no duplicate keys**. Keys form a set, and every element of a set must be unique."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Slices\n",
    "Note that there can be no **slices** since dictionaries have no order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# these are OK\n",
    "{5: 5, \"yes\": \"yes\", 2.0: 2.0}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# no: lists are mutable and thus cannot be keys\n",
    "{[1, 2]: [1, 2]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 4}\n",
      "{'a': 'hello'}\n"
     ]
    }
   ],
   "source": [
    "# note: if keys are repeated, the last assigned value will be the key\n",
    "d = {\"a\": 2, \"a\": 3, \"a\": 4}\n",
    "print(d)\n",
    "\n",
    "d[\"a\"] = \"hello\"\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indexing\n",
    "Indexing works just like on lists, except the indices don't need to be integers any more:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "welcome\n",
      "a wild float appears!\n",
      "polo!\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "test_dict = {\n",
    "    2: \"welcome\",\n",
    "    4.15: \"a wild float appears!\",\n",
    "    \"marco\": \"polo!\",\n",
    "    \"nine\": 9\n",
    "}\n",
    "print(test_dict[2])\n",
    "print(test_dict[4.15])\n",
    "print(test_dict[\"marco\"])\n",
    "print(test_dict[\"nine\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also set the keys of a dictionary using assignment. The keys don't need to exist; a new key will be created automatically. Any existing key will be overwritten."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{2: 'unwelcome', 4.15: 'a wild float appears!', 'marco': 'polo!', 'nine': 9, 'seven': 7}\n"
     ]
    }
   ],
   "source": [
    "test_dict[\"seven\"] = 7\n",
    "test_dict[2] = \"unwelcome\"\n",
    "print(test_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Indexing with an key that doesn't exist will cause an exception:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "\"this key doesn't exist\"",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-4-9e334450953a>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtest_dict\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"this key doesn't exist\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m: \"this key doesn't exist\""
     ]
    }
   ],
   "source": [
    "print(test_dict[\"this key doesn't exist\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "results = {\"Ann\":15,\"Bob\":9,\"Calum\":19,\"Dave\":2,\"Eve\":12}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's look at what we need to do to print out an individual's (Bob) result with each of these methods.\n",
    "\n",
    "1. List of lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for student in exam:\n",
    "    if student[0] == \"Bob\":\n",
    "        print(student[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Separate lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for i in range(len(names)):\n",
    "    if names[i] == \"Bob\":\n",
    "        print(marks[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print(results[\"Bob\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Advantages of Dictionaries over Lists.\n",
    "If we wish to access a key in the dictionary we do not need to search through the whole dictionary to find its value, we can directly acces it by using the key as an index into the dictionary.\n",
    "#### Disadvantage of Dictionaries over Lists.\n",
    "Dictionaries are not ideal for sorting information. If we wanted to store the students names in order of exam results, it would be easy to rearrange the lists. However there is no means of rearranging the dictionary to have the highest exam results first. Dictionarues should be considered to be unordered."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To get the exam mark(value) for Calum(key), we use the key as an index into the dictionary and the value associated with that key is returned."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "19\n"
     ]
    }
   ],
   "source": [
    "print(results[\"Calum\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To change the exam mark(value) of Dave(key), we use the key as an index into the dictionary and assign it the new value. This will replace any old values for this key."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "results[\"Dave\"] = 17"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To create a new entry into the dictionary, we can simply use the new key as an index into the dictionary and assign it a value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "results[\"Fred\"] = 5."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Find the average mark of all the results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The average mark was 11.4.\n"
     ]
    }
   ],
   "source": [
    "total = 0\n",
    "for name in results:\n",
    "    total += results[name]\n",
    "print(\"The average mark was %.1f.\" %(total/len(results)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Print out Eve's exam result.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Change Ann's exam result to 16\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Add Guy to the dictionary. His exam result was 8.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Update all the exam results to be double their original score.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Equality and comparison\n",
    "Dictionaries are equal if they have the same keys, and each of the keys maps to the same value.\n",
    "\n",
    "Order comparisons are not defined for dictionaries (although they do evaluate to a result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print({\"a\" : 1, \"b\" : 2} == {\"a\" : 1, \"b\" : 2})\n",
    "print({\"a\" : 1, \"b\" : 2} == {\"b\" : 2, \"a\" : 1}) # order does not matter\n",
    "print({\"a\" : 1, \"b\" : 2} == {\"a\" : 1, \"b\" : 2, \"c\" : 3}) # different keys\n",
    "print({\"a\" : 1, \"b\" : 2} == {\"a\" : 1, \"b\" : 20}) # different values for the same keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# cannot compare the ordering of dictionaries!\n",
    "print({\"a\" : 1, \"b\" : 2} > {\"a\" : 1, \"b\" : 20})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Membership test\n",
    "Just like lists, we can use `in` to find out if a key (not a value!) is in a dictionary. This is one of the major uses of dictionaries -- to keep a record of \"things that have been seen\"\n",
    "\n",
    "**But**, unlike a list, the time taken to find an element does not depend on how many elements are in the dictionary.\n",
    "\n",
    "**This is a massive difference!**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### get and default values\n",
    "`get()` lets us retrieve a value from a dictionary, substituting a **default** value if the key requested is not in the dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'apple': 3, 'banana': 2, 'orange': 1}\n",
      "{'apple': 3, 'banana': 2, 'orange': 1}\n"
     ]
    }
   ],
   "source": [
    "fruit = [\"apple\",\"banana\",\"apple\",\"apple\",\"orange\",\"banana\"]\n",
    "\n",
    "fruitCount1 = {}\n",
    "\n",
    "for f in fruit:\n",
    "    if f in fruitCount1:\n",
    "        fruitCount1[f] = fruitCount1[f]+1\n",
    "    else:\n",
    "        fruitCount1[f] = 1\n",
    "\n",
    "print(fruitCount1)\n",
    "\n",
    "fruitCount2 = {}\n",
    "\n",
    "for f in fruit:\n",
    "    fruitCount2[f] = fruitCount2.get(f,0) + 1\n",
    "\n",
    "print(fruitCount2)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Restrictions on keys\n",
    "Because dictionaries work by hashing, every **key** must be:\n",
    "* unique\n",
    "* hashable\n",
    "* immutable\n",
    "\n",
    "Whereas a **value** can be any type at all. There are no restrictions at all on **values**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Keys can be any immutable data type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "test = {1:\"one\", 2.5:1.66, \"two\":\"double\", False:\"a very long way away\"}\n",
    "for key in test.keys():\n",
    "    print(key, test[key])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But list can not be keys as they are mutable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unhashable type: 'list'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-34-b2c5d65e8c1e>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mnotAllowed\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m{\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: unhashable type: 'list'"
     ]
    }
   ],
   "source": [
    "notAllowed = {[2,4]:3}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But tuples are allowed as they are immutable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "allowed = {(2,4):3}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# One-to-many mappings\n",
    "So far we have assumed that our dictionaries map from one key to one value. Multiple keys can map to one value, but each key can only map to one value.\n",
    "\n",
    "### One-to-one\n",
    "    {\"a\":\"b\", \"c\":\"d\", \"e\":\"f\"}\n",
    "    \n",
    "### Many-to-one:\n",
    "    {\"a\":1, \"c\":1, \"d\":1}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each key can have only one value associated with it. Assigning another value to a key with replace the previous value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print(test[\"two\"])\n",
    "test[\"two\"]= \"twice\"\n",
    "print(test[\"two\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lists\n",
    "This is very easy to relax; we just make the values be lists (or any other compound data structure). **Now each key can map to any number of values.**\n",
    "\n",
    "### One-to-many"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "{\"a\": [1, 2, 3], \"b\": [2], \"c\": [1, 3]}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So now there can be multiple values associated with one key."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "test[\"two\"] = [\"double\",\"twice\"]\n",
    "print(test[\"two\"])\n",
    "test[\"two\"].append(\"both\")\n",
    "test[\"two\"]+=[\"second\"]\n",
    "print(test[\"two\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Values can be any data type. They can even be nested data structures."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "studentInfo = {\"Ann\":{\"matrix\":12543,\"email\":\"ann@gmail.com\",\"exams\":[21,34,5,14]},\n",
    "               \"Bob\":{\"matrix\":13524,\"email\":\"bob@gmail.com\",\"exams\":[32,15,7,22]},\n",
    "              \"Calum\":{\"matrix\":23145,\"email\":\"calum@gmail.com\",\"exams\":[2,39,65,98]},\n",
    "              \"Dave\":{\"matrix\":23562,\"email\":\"dave@gmail.com\",\"exams\":[97,78,92,88]},\n",
    "              \"Eve\":{\"matrix\":55223,\"email\":\"eve@gmail.com\",\"exams\":[9,11,23,16]},\n",
    "              }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can print out all the values of the keys."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for student in studentInfo:\n",
    "    print(studentInfo[student])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now to print just the matrix numbers of the students....."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for student in studentInfo:\n",
    "    print(studentInfo[student][\"matrix\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes if the dictionary is deeply nested it is easier to use variables rather than writing all the whole dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for student in studentInfo:\n",
    "    s = studentInfo[student]\n",
    "    print(s[\"matrix\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# print out all the names and their email addresses\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Insert Fred's information into the dictionary.\n",
    "\n",
    "    exams = [54,45,55,44]\n",
    "    matrix = 22121\n",
    "    email = fred@gmail.com\n",
    "    \n",
    "Does it matter the order the information is entered?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# find the average of every student's exam results and store the result in the dictionary.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# now save the students names in descending order of their average results \n",
    "# (use .sort() - ask a tutor if this is unclear).\n",
    "# print a congratulations message to the top three students telling them their position in the class.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a english/french dictionary. Ask the user to input a number between 1 - 10 and print out the corresponding word in french. (un, deux, trois, quatre, cinq, six, sept, huit, neuf, dix)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the number input is not in the dictionary (use not in) print out a message otherwise print out the number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You want to have a birthday book to store all your friends' birthdays.Your friends are....\n",
    "\n",
    "    Ann - June 28th\n",
    "    Bob - Dec 30th\n",
    "    Calum - May 2nd\n",
    "    Dave - June 12th\n",
    "    Eve - Jan 1st.\n",
    "    \n",
    "Store this information in an appropriate data structure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Print out Calum's birthday."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# You made a mistake, Dave's birthday is June 11th. Update his details."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Add Fred's birthday to your birthday book (June 3rd)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Print out everyone who has a birthday in December."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Print out everyone who has a birthday next month."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Whose birthday came first in June."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ask the user to input a date (you can enter the month and day separately - 2 inputs()). Print out all the birthdays that fall in the week after that date.\n",
    "For example if the date is today (June 22nd) anyone whose's birthday is between June 22 - June 29 should be printed out."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "Now what happens if we input next Monday (June 25th)? The range of birthdays will be between June 25 - July 2nd.\n",
    "\n",
    "    We need a to store information regarding how many days are in each month.\n",
    "    \n",
    "There are several methods of doing this.\n",
    "\n",
    "1. Use a dictionary. The keys could be the months and the values the number of days. Remember dictionaries are unordered so we need to store that July is after June.\n",
    "\n",
    "2. Separate lists - one containing all the months in order and the other containing the number of days. Finding the position of the month will give us the position of the number of days in the other list. This method will also give us the order of the months.\n",
    "\n",
    "3. A dictionary and a list. You could have a dictionary to return the number of days and a list to give the next month.\n",
    "\n",
    "Or something totally different. It is up to you to decide.....\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the date is Dec 28th, does your program return birthdays between Dec 28th - Jan 4th?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}