8_Dictionaries.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "g-lkfdphxbR0"
   },
   "source": [
    "# 8: Dictionaries\n",
    "\n",
    "## What are dictionaries and why should we care about them?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "X8Q343PRGhMR"
   },
   "source": [
    "Dictionaries are for **associating data** and **quick lookup**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Ku3vlFoMjfUt"
   },
   "source": [
    "Motivating example: I am making an index for a book, because I want to know which concepts show up on which pages, to make it easier to jump back to the right spots."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "id": "jJvItvK9fnAY"
   },
   "outputs": [],
   "source": [
    "# how to know which chapters talk about strings? or debugging?\n",
    "book = [\n",
    "  \"Chapter 1: talks about strings and how they have the property of immutability also some basic debugging\",\n",
    "  \"Chapter 2: continues talking about advanced methods for strings and also introduces the concept of functions\",\n",
    "  \"Chapter 3: discusses iteration and lists and also debugging\",\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's what it might look like *without* dictionaries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 1051,
     "status": "ok",
     "timestamp": 1617628957741,
     "user": {
      "displayName": "Joel Chan",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GiBPPpBf_QqgDL3pMurAsPu9WJJE_x_6UtgW13UFQ=s64",
      "userId": "15153559228409906865"
     },
     "user_tz": 240
    },
    "id": "yT5ZIVumf_P2",
    "outputId": "b67cf244-9223-47ec-829f-3f8a1543de29"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['strings', 'Chapter 1'],\n",
       " ['debugging', 'Chapter 1'],\n",
       " ['immutability', 'Chapter 1'],\n",
       " ['strings', 'Chapter 2'],\n",
       " ['debugging', 'Chapter 3']]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "concepts = ['strings', 'debugging', 'immutability']\n",
    "index = []\n",
    "\n",
    "for chapter in book:\n",
    "    # split into elements based on the colon\n",
    "    elements = chapter.split(\":\")\n",
    "    # first element is the chapter\n",
    "    chapter = elements[0]\n",
    "    # second element is the text\n",
    "    text = elements[1]\n",
    "    \n",
    "    # parse the text\n",
    "    words = text.split()\n",
    "    for keyconcept in concepts:\n",
    "        if keyconcept in words:\n",
    "            index.append([keyconcept, chapter])\n",
    "index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Chapter 1', 'Chapter 2']\n"
     ]
    }
   ],
   "source": [
    "# given this data structure, how to find \n",
    "# all the chapters that have strings in them?\n",
    "query = \"strings\"\n",
    "results = []\n",
    "# go through every item in the index\n",
    "for item in index:\n",
    "    concept, chapter = item\n",
    "    # if the concept matches the query\n",
    "    if query == concept:\n",
    "        results.append(chapter)\n",
    "\n",
    "print(results)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And here is what it might look like *with* dictionaries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# now consider if the concept index is in a dictionary (much more like what you might see in a book!)\n",
    "index_d = {\n",
    "    'strings': ['Chapter 1', 'Chapter 2'],\n",
    "    'debugging': ['Chapter 1', 'Chapter 3']\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Chapter 1', 'Chapter 2']"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# given this data structure, how to find \n",
    "# all the chapters that have strings in them?\n",
    "query = \"strings\"\n",
    "index_d.get(\"strings\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "K4Oz3D5RWLaJ"
   },
   "source": [
    "Another common use case: attributes of data entries. For instance, attributes of a class, like credit hours, pre-reqs, instructor, location, hours, and so on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "KLkWDQeYWkTU"
   },
   "outputs": [],
   "source": [
    "# without dictionaries\n",
    "courses = [\n",
    "    [\"INST126\", 3, \"no\", \"Chan\", \"hybrid\", \"MWF\"],\n",
    "    [\"INST256\", 4, \"yes\", \"Kanishka\", \"in-person\", \"TR\"]\n",
    "]\n",
    "\n",
    "# look up INST126 and check whether it has prereqs\n",
    "for course in courses:\n",
    "    if course[0] == \"INST126\":\n",
    "        print(course[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "w4hAS5h6WrNQ"
   },
   "source": [
    "Rather than trying to remember which position we happened to have decided to use to store a particular attribute (if we used lists), we can use **semantically meaningful indices for values**, i.e., keys!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "executionInfo": {
     "elapsed": 643,
     "status": "ok",
     "timestamp": 1617629581900,
     "user": {
      "displayName": "Joel Chan",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GiBPPpBf_QqgDL3pMurAsPu9WJJE_x_6UtgW13UFQ=s64",
      "userId": "15153559228409906865"
     },
     "user_tz": 240
    },
    "id": "H5RTBIm6Wm-Y",
    "outputId": "224b3b33-0f7d-4bf4-9830-f7e21651a26f"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Rony'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# with dictionaries\n",
    "courses = {\n",
    "    \"INST126\": {\n",
    "      \"credit hours\": 3, \"prereqs\": \"no\", \"instructor\": \"Chan\", \"location\": \"hybrid\", \"hours\": \"MWF\"\n",
    "      },\n",
    "    \"INST256\": {\n",
    "      \"credit hours\": 4, \"prereqs\": \"yes\", \"instructor\": \"Rony\", \"location\": \"in-person\", \"hours\": \"TR\"\n",
    "      },\n",
    "}\n",
    "\n",
    "# look up INST126 and check whether it has prereqs\n",
    "courses.get(\"INST256\").get(\"instructor\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "BfuFZabhWsx5"
   },
   "source": [
    "It's a lot easier to remember keys (if we name them useful things) compared to just indices. And Python can help us remember too!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bmdU6yPtgCUu"
   },
   "source": [
    "If you're interested, there are also formal technical reasons to prefer dictionaries over lists if you care about speed/efficiency and your computational task is **checking** if an item exists in a collection *and* you're dealing with very large scale data: https://www.jessicayung.com/python-lists-vs-dictionaries-the-space-time-tradeoff/. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "59UWIOJ_jgrs"
   },
   "source": [
    "Later we will learn the `pandas` library (and the `dataframe` data structure, which is sort of a hybrid of `lists` and `dictionaries`): you can do really fast lookup, but also sort stuff!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "rt-d9q-YGx3F"
   },
   "source": [
    "## Anatomy of a dictionary\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "XMfeWgyvG3W7"
   },
   "source": [
    "Dictionaries are not so different from... our dictionaries in real life. :) Basically *map* a bunch of **keys** (e.g., a word) to corresponding **values** (e.g., a definition). Another example is indices in the back of print(!!!) books that map key terms to pages where that term shows up, or tags on websites, that map tags to webpages that include those tags.\n",
    "\n",
    "The key parts of a dictionary `literal` are:\n",
    "1. The `{ }` curly braces, which tell you and Python that it's a dictionary (similar to `\"\"` for strings, or `[]` for lists)\n",
    "2. At least one **entry** (but usually several), that maps a **value** on the right of a  `:` --- which functions like the `=` expression --- to a **key** on the left. For example, our first entry maps the value \"apple\" to the key \"a\".\n",
    "3. Similar to lists, we include `,` to separate multiple entries in the dictionary.\n",
    "\n",
    "Let's look at a simple example that maps letters to an example word that starts with the letter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 'apple', 'b': 'ball', 'c': 'crayon'}"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = {\n",
    "   'a': 'apple', # an entry that maps the value apple to the letter a\n",
    "   'b': 'ball', # another entry that maps the value ball to the letter b\n",
    "   'c': 'crayon' \n",
    "}\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Style note: the indentation inside the dictionary is more for readability. Python doesn't care, as long as there are commas between the dictionary entries. \n",
    "\n",
    "You can also write it out like this, but i find it harder to read:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 'apple', 'b': 'ball', 'c': 'crayon'}"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = {'a': 'apple', 'b': 'ball', 'c': 'crayon'} \n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here are some other examples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "mEFRGErFZGnx"
   },
   "outputs": [],
   "source": [
    "# map letters to numbers\n",
    "another = {\n",
    "    'a': 1,\n",
    "    'b': 2,\n",
    "    'c': 3\n",
    "}\n",
    "\n",
    "# map letter grades to list of scores\n",
    "grades = {\n",
    "    'A': [93, 100],\n",
    "    'B': [87, 93]\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "oAEDQBdsa9ut"
   },
   "source": [
    "### Properties of a dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "61xw1VxSh-6q"
   },
   "source": [
    "Here are some key properties of a dictionary in Python:\n",
    "\n",
    "#### Dictionaries have length\n",
    "\n",
    "Similar to lists, dictionaries have **length**. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 509,
     "status": "ok",
     "timestamp": 1617630053089,
     "user": {
      "displayName": "Joel Chan",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GiBPPpBf_QqgDL3pMurAsPu9WJJE_x_6UtgW13UFQ=s64",
      "userId": "15153559228409906865"
     },
     "user_tz": 240
    },
    "id": "O8NZneQoubnI",
    "outputId": "652ced5f-0f81-4b9a-a655-14f5e07dc53f"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = {\n",
    "   'a': 'apple', # an entry that maps the value apple to the letter a\n",
    "   'b': 'ball', # another entry that maps the value ball to the letter b\n",
    "   'c': 'crayon' \n",
    "}\n",
    "len(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dictionaries do not have an order or indexing by position\n",
    "\n",
    "Different from lists, dictionaries **do not have an order**. So you can't really sort a list, or grab things by position. You grab things by... key!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "0",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/xz/_hjc5hsx743dclmg8n5678nc0000gn/T/ipykernel_68702/1089268471.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0md\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m: 0"
     ]
    }
   ],
   "source": [
    "# can't get things by position\n",
    "d[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'dict' object has no attribute 'sort'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/xz/_hjc5hsx743dclmg8n5678nc0000gn/T/ipykernel_68702/1147858021.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# though you can sort\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0md\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msort\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: 'dict' object has no attribute 'sort'"
     ]
    }
   ],
   "source": [
    "# can't sort either\n",
    "d.sort()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'b', 'c']"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(d) # this does *not* sort the dictionary; it returns a sorted list of the keys"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Though as we will see next week, you can sneakily get some order, bc now Python allows you to actually iterate through a dictionary in the order that stuff was put into it. It's not reliable though! If you need your collection to have an actual sequence to it, don't use dictionaries!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### All keys in a dictionary are unique\n",
    "\n",
    "Also, all keys in a dictionary have to be **unique**. This makes dictionaries handy for keeping track of unique items (in contrast to say, lists, where you can have duplicate entries). \n",
    "\n",
    "Values in the dictionary do *not* have to be unique, though: you can have different keys point to the same value, but not multiple values point to duplicate keys. There is a related data structure that has a similar property called `sets` if you're interested."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 582,
     "status": "ok",
     "timestamp": 1617630275741,
     "user": {
      "displayName": "Joel Chan",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GiBPPpBf_QqgDL3pMurAsPu9WJJE_x_6UtgW13UFQ=s64",
      "userId": "15153559228409906865"
     },
     "user_tz": 240
    },
    "id": "F4T1rspjROFZ",
    "outputId": "81b96fab-8a67-47aa-9cb0-798e5c84e7e0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 'animal', 'b': 'ball', 'c': 'crayon', 'd': 'ball'}\n"
     ]
    }
   ],
   "source": [
    "d = {\n",
    "   'a': 'apple', # an entry that maps the value apple to the letter a\n",
    "   'b': 'ball', # another entry that maps the value ball to the letter b\n",
    "   'c': 'crayon',\n",
    "   'a': 'animal',\n",
    "   'd': 'ball'\n",
    "}\n",
    "print(d) # oops, where did apple go? overwritten by the last a:animal entry since we can't have duplicate keys. d:ball is fine though, even though we already have b:ball."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dictionaries are mutable\n",
    "\n",
    "Like lists, dictionaries are also **mutable**: you can modify them directly (in contrast to strings, where you never modify them directly, but only ever create a new modified version of the string)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "d before modification: {'a': 'animal', 'b': 'ball', 'c': 'crayon', 'd': 'ball'}\n",
      "modifying d, by adding an entry mapping the key f to the value friend\n",
      "d after modification: {'a': 'animal', 'b': 'ball', 'c': 'crayon', 'd': 'ball', 'f': 'friend'}\n"
     ]
    }
   ],
   "source": [
    "print(f\"d before modification: {d}\")\n",
    "print(\"modifying d, by adding an entry mapping the key f to the value friend\")\n",
    "d.update({\"f\": \"friend\"})\n",
    "print(f\"d after modification: {d}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "BiQBWTMsRANw"
   },
   "source": [
    "### What kinds of data can we put in a dictionary?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "B4JROzB4iXWL"
   },
   "source": [
    "#### Anything goes for values\n",
    "\n",
    "Basically anything goes for **values**. You can even nest a dictionary inside another dictionary, by mapping a dictionary value to some key."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': ['apple', 'animal'],\n",
       " 'b': 'ball',\n",
       " 'c': 2,\n",
       " 'd': [1, 3, 'denizen'],\n",
       " 'e': <function __main__.hello()>}"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def hello():\n",
    "    print(\"hello world!\")\n",
    "\n",
    "d = {\n",
    "   'a': ['apple', \"animal\"], # an entry that maps the value apple to the letter a\n",
    "   'b': 'ball', # another entry that maps the value ball to the letter b\n",
    "   'c': 2,\n",
    "   'd': [1, 3, \"denizen\"],\n",
    "   'e': hello # even a function is fine!\n",
    "}\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "id": "Z1kM-kPKuvuC"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'joel': {'major': 'info sci',\n",
       "  'year': 'senior',\n",
       "  'interests': ['programming', 'football', 'dancing']}}"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "students = {\n",
    "    'joel': {\n",
    "        'major': 'info sci',\n",
    "        'year': 'senior',\n",
    "        'interests': ['programming', 'football', 'dancing']\n",
    "    },\n",
    "}\n",
    "students"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "D8_0Ztt_vF7u"
   },
   "source": [
    "#### Keys must be hashable\n",
    "\n",
    "But **keys** need to be *hashable*. \n",
    "\n",
    "What does this mean?\n",
    "\n",
    "From the [Python glossary](https://docs.python.org/2/glossary.html):\n",
    "\n",
    "> An object is hashable if it has a hash value which never changes during its lifetime (it needs a __hash__() method), and can be compared to other objects (it needs an __eq__() or __cmp__() method). Hashable objects which compare equal must have the same hash value. Hashability makes an object usable as a dictionary key and a set member, because these data structures use the hash value internally.\n",
    "\n",
    "> All of Python’s immutable built-in objects are hashable, while no mutable containers (such as lists or dictionaries) are. Objects which are instances of user-defined classes are hashable by default; they all compare unequal, and their hash value is their id().\n",
    "\n",
    "More info here: https://stackoverflow.com/questions/14535730/what-does-hashable-mean-in-python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 171
    },
    "executionInfo": {
     "elapsed": 486,
     "status": "error",
     "timestamp": 1604330351921,
     "user": {
      "displayName": "Joel Chan",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GiBPPpBf_QqgDL3pMurAsPu9WJJE_x_6UtgW13UFQ=s64",
      "userId": "15153559228409906865"
     },
     "user_tz": 300
    },
    "id": "UTyQyy3sRIjj",
    "outputId": "6803dedd-47d3-4ec4-f899-38a10368aab7"
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unhashable type: 'list'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/xz/_hjc5hsx743dclmg8n5678nc0000gn/T/ipykernel_5859/1583147795.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0md\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'3'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'apple'\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: unhashable type: 'list'"
     ]
    }
   ],
   "source": [
    "d = {['3']: 'apple'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_fBRR1MSROdJ"
   },
   "source": [
    "I mention this because a common error when first working with dictionaries is to try to use an unhashable data structure as a key. \n",
    "\n",
    "Understanding hashes is not something to worry about *for now*. We can focus on a basic rule of thumb for now: strings and numbers are ok as keys; everything else (that you'll learn now) is not."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ifBcaTKuA2jN"
   },
   "source": [
    "## Working with dictionaries: basics\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "RKgca-CfnFK9"
   },
   "source": [
    "### Create a dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "JG-iNe0ZHJVn"
   },
   "outputs": [],
   "source": [
    "d = {\n",
    "   'a': 'apple',\n",
    "   'b': 'ball',\n",
    "   'c': 'crayon', \n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "QwKbf3Uwb0oB"
   },
   "source": [
    "You can also start with an empty dictionary, and then add stuff later, programmatically or with other functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 713,
     "status": "ok",
     "timestamp": 1617630715701,
     "user": {
      "displayName": "Joel Chan",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GiBPPpBf_QqgDL3pMurAsPu9WJJE_x_6UtgW13UFQ=s64",
      "userId": "15153559228409906865"
     },
     "user_tz": 240
    },
    "id": "6j9jmcjgvqp2",
    "outputId": "c84f7f38-b73c-4ef7-abf9-e787aaaef92a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "emptyd = {} # dictionary with nothing in it\n",
    "emptyd = dict() # same thing\n",
    "print(emptyd)\n",
    "len(emptyd)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**PRACTICE**: make a dictionary e that has the following entries: smith:A, chan:B, abuye:A+"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "DgkOR-cIm2Iy"
   },
   "source": [
    "### Get the value associated with a key from a dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "executionInfo": {
     "elapsed": 680,
     "status": "ok",
     "timestamp": 1617630845043,
     "user": {
      "displayName": "Joel Chan",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GiBPPpBf_QqgDL3pMurAsPu9WJJE_x_6UtgW13UFQ=s64",
      "userId": "15153559228409906865"
     },
     "user_tz": 240
    },
    "id": "X7me-B5Nj5AZ",
    "outputId": "10c194c6-812a-47f7-fe57-d6fb6e00df87"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'crayon'"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = {\n",
    "   'a': 'apple',\n",
    "   'b': 'ball',\n",
    "   'c': 'crayon' \n",
    "}\n",
    "d['c'] # put a key inside square brackets associated with a dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "dyck9whqwBOA"
   },
   "source": [
    "This is called the \"old style\" or \"indexing\" pattern. Looks a little bit like lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "executionInfo": {
     "elapsed": 529,
     "status": "ok",
     "timestamp": 1617630850560,
     "user": {
      "displayName": "Joel Chan",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GiBPPpBf_QqgDL3pMurAsPu9WJJE_x_6UtgW13UFQ=s64",
      "userId": "15153559228409906865"
     },
     "user_tz": 240
    },
    "id": "PwcS2638j6jn",
    "outputId": "5a99b8d5-c894-46e4-fc20-b15e20b96c61"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'crayon'"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = {\n",
    "   'a': 'apple',\n",
    "   'b': 'ball',\n",
    "   'c': 'crayon' \n",
    "}\n",
    "d.get('c') # use the get function to get the value for the key that we give it"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "tKLOMLdHwkuw"
   },
   "source": [
    "This is the newer pattern that I prefer for clarity."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "fbSUFCiVZwv5"
   },
   "source": [
    "It also has the advantage of not breaking your program if you try to access a key that doesn't exist."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 207
    },
    "executionInfo": {
     "elapsed": 822,
     "status": "error",
     "timestamp": 1617630872336,
     "user": {
      "displayName": "Joel Chan",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GiBPPpBf_QqgDL3pMurAsPu9WJJE_x_6UtgW13UFQ=s64",
      "userId": "15153559228409906865"
     },
     "user_tz": 240
    },
    "id": "suoKyO9rZ1jG",
    "outputId": "d8eb6435-8891-4361-f417-4d2a5c2d16fd"
   },
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "'d'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/xz/_hjc5hsx743dclmg8n5678nc0000gn/T/ipykernel_68702/42338292.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      4\u001b[0m    \u001b[0;34m'c'\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'crayon'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m }\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0md\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'd'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;31m# will crash the program with key error\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m: 'd'"
     ]
    }
   ],
   "source": [
    "d = {\n",
    "   'a': 'apple',\n",
    "   'b': 'ball',\n",
    "   'c': 'crayon' \n",
    "}\n",
    "d['d'] # will crash the program with key error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wtUfguW7at3_"
   },
   "source": [
    "`.get()` lets you specify a default value that should come back if the key doesn't exist. This is very useful for writing clean and understandable dictionary patterns, such as indexing, which we'll dig into next week."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 593,
     "status": "ok",
     "timestamp": 1617630952947,
     "user": {
      "displayName": "Joel Chan",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GiBPPpBf_QqgDL3pMurAsPu9WJJE_x_6UtgW13UFQ=s64",
      "userId": "15153559228409906865"
     },
     "user_tz": 240
    },
    "id": "-lTzN_qrZ8sW",
    "outputId": "2aecf4ff-ad11-4943-baec-3ecfb90478a5"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Key not found\n"
     ]
    }
   ],
   "source": [
    "d = {\n",
    "   'a': 'apple',\n",
    "   'b': 'ball',\n",
    "   'c': 'crayon' \n",
    "}\n",
    "result = d.get('d', \"Key not found\") # will return None as a default\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**PRACTICE**: how do you get the value associated with the key `a`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4PzmOryUjF2r"
   },
   "source": [
    "### Adding entries to a dictionary (or updating entries)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "UovJdgpCaUDv"
   },
   "source": [
    "Classic style, using indexing and assignment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 664,
     "status": "ok",
     "timestamp": 1617631040586,
     "user": {
      "displayName": "Joel Chan",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GiBPPpBf_QqgDL3pMurAsPu9WJJE_x_6UtgW13UFQ=s64",
      "userId": "15153559228409906865"
     },
     "user_tz": 240
    },
    "id": "7gKu9TnzcZbG",
    "outputId": "11eb333c-363f-4b32-c2e4-990f5e4b92e6"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 'apple', 'b': 'ball', 'c': 'crayon'}\n",
      "{'a': 'apple', 'b': 'ball', 'c': 'crayon', 'e': 'egg'}\n",
      "{'a': 'apple', 'b': 'bread', 'c': 'crayon', 'e': 'egg'}\n",
      "{'a': 'ashes', 'b': 'bread', 'c': 'charming', 'e': 'egg'}\n"
     ]
    }
   ],
   "source": [
    "d = {\n",
    "   'a': 'apple',\n",
    "   'b': 'ball',\n",
    "   'c': 'crayon' \n",
    "}\n",
    "print(d)\n",
    "# add a new entry for e\n",
    "d['e'] = 'egg' # map the value egg to the key e\n",
    "print(d)\n",
    "# update the entry for b\n",
    "d['b'] = 'bread' # map the value bread to the key b (which happens to already exist, so we update it)\n",
    "print(d)\n",
    "# update the entries for a and c\n",
    "d['a'] = 'ashes'\n",
    "d['c'] = 'charming' \n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wT_GF7fwaXGC"
   },
   "source": [
    "Newer style, using `.update()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 365,
     "status": "ok",
     "timestamp": 1604334301559,
     "user": {
      "displayName": "Joel Chan",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GiBPPpBf_QqgDL3pMurAsPu9WJJE_x_6UtgW13UFQ=s64",
      "userId": "15153559228409906865"
     },
     "user_tz": 300
    },
    "id": "ZBmVNv4DkBEf",
    "outputId": "89c90fd1-3911-447a-c601-44feea1a0a34"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 'apple', 'b': 'ball', 'c': 'crayon'}\n",
      "{'a': 'apple', 'b': 'ball', 'c': 'crayon', 'e': 'egg'}\n",
      "{'a': 'apple', 'b': 'bread', 'c': 'crayon', 'e': 'egg'}\n",
      "{'a': 'ashes', 'b': 'bread', 'c': 'charming', 'e': 'egg'}\n"
     ]
    }
   ],
   "source": [
    "d = {\n",
    "   'a': 'apple',\n",
    "   'b': 'ball',\n",
    "   'c': 'crayon' \n",
    "}\n",
    "print(d)\n",
    "# add a new entry for e\n",
    "d.update({'e': 'egg'}) # map the value egg to the key e\n",
    "print(d)\n",
    "# update the entry for b\n",
    "d.update({'b': 'bread'}) # map the value bread to the key b (which happens to already exist, so we update it)\n",
    "print(d)\n",
    "# update the entries for a and c\n",
    "new_for_a = \"ashes\"\n",
    "d.update({'a': new_for_a, 'c': 'charming'})\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**PRACTICE**: how do you update d with new entry `h:hello`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**PRACTICE**: how do you update d so that `a` maps to the value `asteroid`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "r6WneQ0eadIy"
   },
   "source": [
    "`.update()` has the advantage of being able to add multiple key-value pairs at once."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 567,
     "status": "ok",
     "timestamp": 1617631177589,
     "user": {
      "displayName": "Joel Chan",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GiBPPpBf_QqgDL3pMurAsPu9WJJE_x_6UtgW13UFQ=s64",
      "userId": "15153559228409906865"
     },
     "user_tz": 240
    },
    "id": "CbhVPy9iVBkJ",
    "outputId": "745604a1-d8e7-4c04-870f-90a7df58d197"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 'apple', 'b': 'ball', 'c': 'crayon'}\n",
      "{'a': 'ashes', 'b': 'bread', 'c': 'charming', 'e': 'egg'}\n"
     ]
    }
   ],
   "source": [
    "d = {\n",
    "   'a': 'apple',\n",
    "   'b': 'ball',\n",
    "   'c': 'crayon' \n",
    "}\n",
    "print(d)\n",
    "d.update({'a': 'ashes', 'b':'bread', 'c':'charming', 'e': 'egg'})\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**PRACTICE**: how do you update d with new entries `f:friend` and `g:grapes` in a single operation?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**PRACTICE**: how do you update d so that `f` now points to `funny` and `b` points to `bundle`, in a single operation?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "AhUAWXgfnCgR"
   },
   "source": [
    "You can use the pattern that is comfortable for you, but I prefer `.get()` and `.update()` for now because it's more readable and robust."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "cy1zzm0wb2TU"
   },
   "source": [
    "### List keys and values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "FHjARN_sb8wW"
   },
   "source": [
    "`.keys()` gives you all the keys in the dictionary\n",
    "\n",
    "`.values()` gives you allt he values in the dictionary\n",
    "\n",
    "`.items()` gives you all the entries in the dictionary\n",
    "\n",
    "each of these is iterable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 502,
     "status": "ok",
     "timestamp": 1617631424701,
     "user": {
      "displayName": "Joel Chan",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GiBPPpBf_QqgDL3pMurAsPu9WJJE_x_6UtgW13UFQ=s64",
      "userId": "15153559228409906865"
     },
     "user_tz": 240
    },
    "id": "zYX-SeJOWKbs",
    "outputId": "0a557156-b398-4718-f404-5fffe52c37ec"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 'ashes', 'b': 'bread', 'c': 'charming', 'e': 'egg'}"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 638,
     "status": "ok",
     "timestamp": 1617631401989,
     "user": {
      "displayName": "Joel Chan",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GiBPPpBf_QqgDL3pMurAsPu9WJJE_x_6UtgW13UFQ=s64",
      "userId": "15153559228409906865"
     },
     "user_tz": 240
    },
    "id": "WvQ9-ZGxV3aS",
    "outputId": "923a80d5-053b-4913-df49-b514bfd9f39c"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['a', 'b', 'c', 'e', 'f', 'g'])"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# list all the keys in the dictionary\n",
    "d.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 667,
     "status": "ok",
     "timestamp": 1617631417064,
     "user": {
      "displayName": "Joel Chan",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GiBPPpBf_QqgDL3pMurAsPu9WJJE_x_6UtgW13UFQ=s64",
      "userId": "15153559228409906865"
     },
     "user_tz": 240
    },
    "id": "n8QrDEAFWGbm",
    "outputId": "d1741aca-07c6-47e1-8e12-d59b89e61aca"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values(['ashes', 'bundles', 'charming', 'egg', 'funny', 'grapes'])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# list all the values in the dictionary\n",
    "d.values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 537,
     "status": "ok",
     "timestamp": 1617631448973,
     "user": {
      "displayName": "Joel Chan",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GiBPPpBf_QqgDL3pMurAsPu9WJJE_x_6UtgW13UFQ=s64",
      "userId": "15153559228409906865"
     },
     "user_tz": 240
    },
    "id": "8hCyfNOHWMpk",
    "outputId": "78bf5787-311e-4eec-ef6d-b039c4fbb18b"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_items([('a', 'ashes'), ('b', 'bundles'), ('c', 'charming'), ('e', 'egg'), ('f', 'funny'), ('g', 'grapes')])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# list all the key-value pairs in the dictionary\n",
    "d.items()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 740,
     "status": "ok",
     "timestamp": 1617631479307,
     "user": {
      "displayName": "Joel Chan",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GiBPPpBf_QqgDL3pMurAsPu9WJJE_x_6UtgW13UFQ=s64",
      "userId": "15153559228409906865"
     },
     "user_tz": 240
    },
    "id": "KzdaIBa6WV8e",
    "outputId": "b8415314-32ad-424a-cca0-97adfd7ee8ff"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a ashes\n",
      "b bundles\n",
      "c charming\n",
      "e egg\n",
      "f funny\n",
      "g grapes\n"
     ]
    }
   ],
   "source": [
    "# this means you can iterate through the keys/values\n",
    "for key in d.keys():\n",
    "    print(key, d.get(key))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 557,
     "status": "ok",
     "timestamp": 1617631524162,
     "user": {
      "displayName": "Joel Chan",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GiBPPpBf_QqgDL3pMurAsPu9WJJE_x_6UtgW13UFQ=s64",
      "userId": "15153559228409906865"
     },
     "user_tz": 240
    },
    "id": "5aPlx12dWbUN",
    "outputId": "bfefbe4b-1474-4393-c663-8316571e8fa6"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is associated with the value ashes\n",
      "b is associated with the value bundles\n",
      "c is associated with the value charming\n",
      "e is associated with the value egg\n",
      "f is associated with the value funny\n",
      "g is associated with the value grapes\n"
     ]
    }
   ],
   "source": [
    "# iterate through the items\n",
    "for key, value in d.items():\n",
    "    print(f'{key} is associated with the value {value}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_dzPHNSlmTsl"
   },
   "source": [
    "### Check if a key is in a dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 361,
     "status": "ok",
     "timestamp": 1604334598605,
     "user": {
      "displayName": "Joel Chan",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GiBPPpBf_QqgDL3pMurAsPu9WJJE_x_6UtgW13UFQ=s64",
      "userId": "15153559228409906865"
     },
     "user_tz": 300
    },
    "id": "GhYfo75IyqHE",
    "outputId": "587d0238-fd60-4fe9-9b44-8ab960eb3dd6"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "d = {\n",
    "   'a': 'apple',\n",
    "   'b': 'ball',\n",
    "   'c': 'crayon' \n",
    "}\n",
    "print('h' in d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "gZcJLnKtW03b"
   },
   "source": [
    "Can only use 'in' operator with keys"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "VgTqsvbkayPx"
   },
   "source": [
    "You can also do this with `.get()`!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "id": "_O75i7x2W8zO"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# retrieve value for a, if it's not found, say \"not found\"\n",
    "d.get(\"h\", False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**PRACTICE**: how do you check if the key \"c\" is in the dictionary `d`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6kRTTq8Pb-CW"
   },
   "source": [
    "### Reverse look up keys from values: YOU CAN'T! Not really..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wohpC8NFdPsx"
   },
   "source": [
    "Dictionaries are very powerful transformations of your data that make it REALLY easy to do a specific kind of operation, but lock you out of doing other things. So design the structure of the dictionary carefully. For example, if you make an index, and find that you actually care a lot about grabbing the top N words, you probably want to map counts (as keys) to words (as values), not words to counts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 478,
     "status": "ok",
     "timestamp": 1617631742446,
     "user": {
      "displayName": "Joel Chan",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GiBPPpBf_QqgDL3pMurAsPu9WJJE_x_6UtgW13UFQ=s64",
      "userId": "15153559228409906865"
     },
     "user_tz": 240
    },
    "id": "0dj1GWMtcJGQ",
    "outputId": "b78fc7d7-fe75-4828-bd58-b0f3d87692f8"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'she': 1,\n",
       " 'sells': 1,\n",
       " 'sea': 6,\n",
       " 'shells': 2,\n",
       " 'by': 1,\n",
       " 'the': 4,\n",
       " 'shore': 1,\n",
       " 'in': 1,\n",
       " 'and': 2}"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = \"she sells sea shells by the sea shore in the sea and the shells and the sea sea sea\"\n",
    "\n",
    "d = {} # define a dictionary to hold hte index\n",
    "# go through word by word\n",
    "for word in s.split():\n",
    "  # get the current count for the word, default to 0 if we haven't seen it\n",
    "  current_count = d.get(word, 0)\n",
    "  # update the count\n",
    "  new_count = current_count + 1\n",
    "  # update the dictionary with the word and count\n",
    "  d.update({word: new_count})\n",
    "\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hWwxHRnweD8U"
   },
   "source": [
    "Could try to invert it, but...."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "LobWJns8ckNq"
   },
   "outputs": [],
   "source": [
    "def reverse_dictionary(d):\n",
    "    return {v: k for k, v in d.items()}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "tseYtydPeHPD"
   },
   "source": [
    "You actually lose information, because remember: keys are unique! No duplicates! So we lose one of our \"2\" entries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 734,
     "status": "ok",
     "timestamp": 1617631814176,
     "user": {
      "displayName": "Joel Chan",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GiBPPpBf_QqgDL3pMurAsPu9WJJE_x_6UtgW13UFQ=s64",
      "userId": "15153559228409906865"
     },
     "user_tz": 240
    },
    "id": "ET8zg0eJd4MK",
    "outputId": "05b132f2-eb34-4bf2-adbe-9f9991d5b412"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: 'in', 2: 'and', 4: 'the', 6: 'sea'}"
      ]
     },
     "execution_count": 44,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d_invert = reverse_dictionary(d)\n",
    "d_invert"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 594,
     "status": "ok",
     "timestamp": 1617631967572,
     "user": {
      "displayName": "Joel Chan",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GiBPPpBf_QqgDL3pMurAsPu9WJJE_x_6UtgW13UFQ=s64",
      "userId": "15153559228409906865"
     },
     "user_tz": 240
    },
    "id": "yS-djFp0X92U",
    "outputId": "ef4a1b10-8dc4-4714-825f-4ab1a690e9ee"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: ['she', 'sells', 'by', 'shore', 'in'],\n",
       " 2: ['shells', 'and'],\n",
       " 4: ['the'],\n",
       " 6: ['sea']}"
      ]
     },
     "execution_count": 45,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d_invert = {}\n",
    "for word, count in d.items():\n",
    "    words = d_invert.get(count, []) # get the current list of words associated with this count\n",
    "    words.append(word)\n",
    "    d_invert.update({count: words})\n",
    "d_invert"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "RqOYMjCVeUN5"
   },
   "source": [
    "## Dictionary Application: Indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "I7ExfNqfirdv"
   },
   "source": [
    "Now that we have the dictionary data structure, we can apply it in a program that can *create* an index.\n",
    "\n",
    "### Example\n",
    "\n",
    "Here's an example from above that takes a list of book chapter strings and a list of key concepts, and spits out an index that maps key concepts to chapters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ZYI-1uBoy-eL"
   },
   "outputs": [],
   "source": [
    "# how to know which chapters talk about strings? or debugging?\n",
    "book = [\n",
    "  \"Chapter 1: talks about strings and how they have the property of immutability also some basic debugging\",\n",
    "  \"Chapter 2: continues talking about advanced methods for strings and also introduces the concept of functions\",\n",
    "  \"Chapter 3: discusses iteration and lists and also debugging\",\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 518,
     "status": "ok",
     "timestamp": 1617629113990,
     "user": {
      "displayName": "Joel Chan",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GiBPPpBf_QqgDL3pMurAsPu9WJJE_x_6UtgW13UFQ=s64",
      "userId": "15153559228409906865"
     },
     "user_tz": 240
    },
    "id": "PHur06kRgBNk",
    "outputId": "3542af42-5020-4b91-8934-5256143668d0",
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'strings': ['Chapter 1', 'Chapter 2'],\n",
       " 'debugging': ['Chapter 1', 'Chapter 3'],\n",
       " 'lists': ['Chapter 3'],\n",
       " 'iteration': ['Chapter 3']}"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# define what we want to index as keys\n",
    "concepts = ['strings', 'debugging', \"lists\", \"iteration\"]\n",
    "\n",
    "# make a dictionary to hold the index\n",
    "index = {}\n",
    "\n",
    "# go through every chapter\n",
    "for chapter in book:\n",
    "    \n",
    "    # split into chapter and descr based on the colon\n",
    "    chapter, descr = chapter.split(\":\")\n",
    "    \n",
    "    # index the concepts\n",
    "    \n",
    "    # for every concept we care about\n",
    "    for keyconcept in concepts:\n",
    "        # check if it's in this chapter descr\n",
    "        if keyconcept in descr:\n",
    "            # if so, get the current list of chapters associated with this keyconcept\n",
    "            chs = index.get(keyconcept, [])\n",
    "            # then update the list of chapters\n",
    "            # if we haven't seen the chapter\n",
    "            if chapter not in chs:\n",
    "                chs.append(chapter)\n",
    "            # and update the index to map the keyconcept to the updated list of assoc. chapters\n",
    "            index.update({keyconcept: chs})\n",
    "index"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What dictionary concepts do you recognize?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The indexing pattern\n",
    "\n",
    "Here's the generic structure of an indexing pattern"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create an empty dictionary to hold the index\n",
    "\n",
    "# for every item in a list of things you want to index\n",
    "\n",
    "    # (optional: parse out the keys and values you want to index from the item)\n",
    "    \n",
    "    # get the current value associated with the key in the index\n",
    "    \n",
    "    # update the value\n",
    "    \n",
    "    # update the index with the key and its updated value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's look at a super simple example: making a **word count index**. \n",
    "\n",
    "We'll take in a list of words, and produce an index that maps words as `keys` to counts of occurrences as `values`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'she': 1,\n",
       " 'sells': 1,\n",
       " 'sea': 6,\n",
       " 'shells': 2,\n",
       " 'by': 1,\n",
       " 'the': 4,\n",
       " 'shore': 1,\n",
       " 'in': 1,\n",
       " 'and': 2}"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# the thing we want to index\n",
    "word_list = ['she', 'sells', 'sea', 'shells', 'by', 'the', 'sea', 'shore', 'in', 'the', 'sea', 'and', 'the', 'shells', 'and', 'the', 'sea', 'sea', 'sea']\n",
    "\n",
    "# create an empty dictionary to hold the index\n",
    "word_counts = {}\n",
    "\n",
    "# for every item in a list of things you want to index\n",
    "for word in word_list:\n",
    "\n",
    "    # (optional: parse out the keys and values you want to index from the item)\n",
    "    # we don't need this step\n",
    "    \n",
    "    # get the current value associated with the key in the index\n",
    "    # here, we use .get(), and have a default count of 0 if the key isn't yet in the index\n",
    "    count = word_counts.get(word, 0)\n",
    "    \n",
    "    # update the value\n",
    "    count += 1\n",
    "    \n",
    "    # update the index with the key and its updated value\n",
    "    word_counts.update({word: count})\n",
    "    \n",
    "word_counts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Practice: index grade counts\n",
    "\n",
    "Practice! Test your understanding by adapting the above code to count how many times each grade was earned in a course."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "grades_counts = {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Practice: which words are n characters long?\n",
    "\n",
    "Now let's extend this a bit. We'll modify the first program to index word lengths: we want an index that can tell us \"what words in the list were 2 characters long, or 5 characters long?\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the thing we want to index\n",
    "word_list = ['she', 'sells', 'sea', 'shells', 'by', 'the', 'sea', 'shore', 'in', 'the', 'sea', 'and', 'the', 'shells', 'and', 'the', 'sea', 'sea', 'sea']\n",
    "\n",
    "# your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Practice: counts of email addresses from email records\n",
    "\n",
    "Let's index how many times we got emails from which email addresses!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "email_records = ['From stephen.marquard@uct.ac.za Sat Jan  5 09:14:16 2008',\n",
    " 'From louis@media.berkeley.edu Fri Jan  4 18:10:48 2008',\n",
    " 'From zqian@umich.edu Fri Jan  4 16:10:39 2008',\n",
    " 'From rjlowe@iupui.edu Fri Jan  4 15:46:24 2008',\n",
    " 'From zqian@umich.edu Fri Jan  4 15:03:18 2008',\n",
    " 'From rjlowe@iupui.edu Fri Jan  4 14:50:18 2008',\n",
    " 'From cwen@iupui.edu Fri Jan  4 11:37:30 2008',\n",
    " 'From cwen@iupui.edu Fri Jan  4 11:35:08 2008',\n",
    " 'From gsilver@umich.edu Fri Jan  4 11:12:37 2008',\n",
    " 'From gsilver@umich.edu Fri Jan  4 11:11:52 2008',\n",
    " 'From zqian@umich.edu Fri Jan  4 11:11:03 2008',\n",
    " 'From gsilver@umich.edu Fri Jan  4 11:10:22 2008',\n",
    " 'From wagnermr@iupui.edu Fri Jan  4 10:38:42 2008',\n",
    " 'From zqian@umich.edu Fri Jan  4 10:17:43 2008',\n",
    " 'From antranig@caret.cam.ac.uk Fri Jan  4 10:04:14 2008',\n",
    " 'From gopal.ramasammycook@gmail.com Fri Jan  4 09:05:31 2008',\n",
    " 'From david.horwitz@uct.ac.za Fri Jan  4 07:02:32 2008',\n",
    " 'From david.horwitz@uct.ac.za Fri Jan  4 06:08:27 2008',\n",
    " 'From david.horwitz@uct.ac.za Fri Jan  4 04:49:08 2008',\n",
    " 'From david.horwitz@uct.ac.za Fri Jan  4 04:33:44 2008',\n",
    " 'From stephen.marquard@uct.ac.za Fri Jan  4 04:07:34 2008',\n",
    " 'From louis@media.berkeley.edu Thu Jan  3 19:51:21 2008',\n",
    " 'From louis@media.berkeley.edu Thu Jan  3 17:18:23 2008',\n",
    " 'From ray@media.berkeley.edu Thu Jan  3 17:07:00 2008',\n",
    " 'From cwen@iupui.edu Thu Jan  3 16:34:40 2008',\n",
    " 'From cwen@iupui.edu Thu Jan  3 16:29:07 2008',\n",
    " 'From cwen@iupui.edu Thu Jan  3 16:23:48 2008']\n",
    "\n",
    "# your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Practice: map email addresses to email records\n",
    "\n",
    "Now modify the previous program to map email **records** (as values) to email addresses (as keys). We want to ask questions like \"can i see the emails I got from `cwen@iupui.edu`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "email_records = ['From stephen.marquard@uct.ac.za Sat Jan  5 09:14:16 2008',\n",
    " 'From louis@media.berkeley.edu Fri Jan  4 18:10:48 2008',\n",
    " 'From zqian@umich.edu Fri Jan  4 16:10:39 2008',\n",
    " 'From rjlowe@iupui.edu Fri Jan  4 15:46:24 2008',\n",
    " 'From zqian@umich.edu Fri Jan  4 15:03:18 2008',\n",
    " 'From rjlowe@iupui.edu Fri Jan  4 14:50:18 2008',\n",
    " 'From cwen@iupui.edu Fri Jan  4 11:37:30 2008',\n",
    " 'From cwen@iupui.edu Fri Jan  4 11:35:08 2008',\n",
    " 'From gsilver@umich.edu Fri Jan  4 11:12:37 2008',\n",
    " 'From gsilver@umich.edu Fri Jan  4 11:11:52 2008',\n",
    " 'From zqian@umich.edu Fri Jan  4 11:11:03 2008',\n",
    " 'From gsilver@umich.edu Fri Jan  4 11:10:22 2008',\n",
    " 'From wagnermr@iupui.edu Fri Jan  4 10:38:42 2008',\n",
    " 'From zqian@umich.edu Fri Jan  4 10:17:43 2008',\n",
    " 'From antranig@caret.cam.ac.uk Fri Jan  4 10:04:14 2008',\n",
    " 'From gopal.ramasammycook@gmail.com Fri Jan  4 09:05:31 2008',\n",
    " 'From david.horwitz@uct.ac.za Fri Jan  4 07:02:32 2008',\n",
    " 'From david.horwitz@uct.ac.za Fri Jan  4 06:08:27 2008',\n",
    " 'From david.horwitz@uct.ac.za Fri Jan  4 04:49:08 2008',\n",
    " 'From david.horwitz@uct.ac.za Fri Jan  4 04:33:44 2008',\n",
    " 'From stephen.marquard@uct.ac.za Fri Jan  4 04:07:34 2008',\n",
    " 'From louis@media.berkeley.edu Thu Jan  3 19:51:21 2008',\n",
    " 'From louis@media.berkeley.edu Thu Jan  3 17:18:23 2008',\n",
    " 'From ray@media.berkeley.edu Thu Jan  3 17:07:00 2008',\n",
    " 'From cwen@iupui.edu Thu Jan  3 16:34:40 2008',\n",
    " 'From cwen@iupui.edu Thu Jan  3 16:29:07 2008',\n",
    " 'From cwen@iupui.edu Thu Jan  3 16:23:48 2008']\n",
    "\n",
    "# your code here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['From david.horwitz@uct.ac.za Fri Jan  4 07:02:32 2008',\n",
       " 'From david.horwitz@uct.ac.za Fri Jan  4 06:08:27 2008',\n",
       " 'From david.horwitz@uct.ac.za Fri Jan  4 04:49:08 2008',\n",
       " 'From david.horwitz@uct.ac.za Fri Jan  4 04:33:44 2008']"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "email_occurrences.get(\"david.horwitz@uct.ac.za\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Investigate: integrate the book chapter indexing program into our generic structure\n",
    "\n",
    "What's the same? What needs to be modified?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Practice: flag important emails\n",
    "\n",
    "Let's say you have a list of 'starred contacts', and you want a separate index where you can ask the question \"give me all the emails i got from this starred contact\". You can imagine this being sort of a rudimentary back-end of your \"important\" tab in Gmail. \n",
    "\n",
    "How might we modify our email indexing program to do this?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "email_records = ['From stephen.marquard@uct.ac.za Sat Jan  5 09:14:16 2008',\n",
    " 'From louis@media.berkeley.edu Fri Jan  4 18:10:48 2008',\n",
    " 'From zqian@umich.edu Fri Jan  4 16:10:39 2008',\n",
    " 'From rjlowe@iupui.edu Fri Jan  4 15:46:24 2008',\n",
    " 'From zqian@umich.edu Fri Jan  4 15:03:18 2008',\n",
    " 'From rjlowe@iupui.edu Fri Jan  4 14:50:18 2008',\n",
    " 'From cwen@iupui.edu Fri Jan  4 11:37:30 2008',\n",
    " 'From cwen@iupui.edu Fri Jan  4 11:35:08 2008',\n",
    " 'From gsilver@umich.edu Fri Jan  4 11:12:37 2008',\n",
    " 'From gsilver@umich.edu Fri Jan  4 11:11:52 2008',\n",
    " 'From zqian@umich.edu Fri Jan  4 11:11:03 2008',\n",
    " 'From gsilver@umich.edu Fri Jan  4 11:10:22 2008',\n",
    " 'From wagnermr@iupui.edu Fri Jan  4 10:38:42 2008',\n",
    " 'From zqian@umich.edu Fri Jan  4 10:17:43 2008',\n",
    " 'From antranig@caret.cam.ac.uk Fri Jan  4 10:04:14 2008',\n",
    " 'From gopal.ramasammycook@gmail.com Fri Jan  4 09:05:31 2008',\n",
    " 'From david.horwitz@uct.ac.za Fri Jan  4 07:02:32 2008',\n",
    " 'From david.horwitz@uct.ac.za Fri Jan  4 06:08:27 2008',\n",
    " 'From david.horwitz@uct.ac.za Fri Jan  4 04:49:08 2008',\n",
    " 'From david.horwitz@uct.ac.za Fri Jan  4 04:33:44 2008',\n",
    " 'From stephen.marquard@uct.ac.za Fri Jan  4 04:07:34 2008',\n",
    " 'From louis@media.berkeley.edu Thu Jan  3 19:51:21 2008',\n",
    " 'From louis@media.berkeley.edu Thu Jan  3 17:18:23 2008',\n",
    " 'From ray@media.berkeley.edu Thu Jan  3 17:07:00 2008',\n",
    " 'From cwen@iupui.edu Thu Jan  3 16:34:40 2008',\n",
    " 'From cwen@iupui.edu Thu Jan  3 16:29:07 2008',\n",
    " 'From cwen@iupui.edu Thu Jan  3 16:23:48 2008']\n",
    "\n",
    "# your code here"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "INST126_SP21_Week11_Dictionaries_post-class.ipynb",
   "provenance": [],
   "toc_visible": true
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}