U_CSCI2011_L05_Data_Structures_2_SG_V3.0.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b><center>UNCLASSIFIED</center></b>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"./GRAPHICS/Banner.png\" width=\"110%\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lesson 5: Unordered Data Structures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Table of Contents\n",
    "\n",
    "5.1. [Objectives](#Objectives)<br>\n",
    "5.2. [Overview](#Overview)<br>\n",
    "5.3. [Review](#Review)<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;5.3.1. [Lists](#lists)<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;5.3.2. [Tuples](#tuples)<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;5.3.3. [Boolean Expressions](#bool)<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;5.3.4. [If Statements](#if)<br>\n",
    "5.4. [Lesson: Data Structures](#Lesson)<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;5.4.1. [Unordered Collections](#Unordered)<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;5.4.2. [Sets](#sets)<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;5.4.3. [Dictionaries](#dict)<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;5.4.4. [Common Operations Across Data Structures](#Common)<br>\n",
    "5.5. [Guided Exercise: Analyzing Crime Data](#Guided-Exercise)<br>\n",
    "5.6. [Practical Exercises](#Practical-Exercises)<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;5.6.1. [Practical Exercise 1: Knowledge Check: Sets](#PE1)<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;5.6.2. [Practical Exercise 2: Practice Sets](#PE2)<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;5.6.3. [Practical Exercise 3: Knowledge Check: Dictionaries](#PE3)<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;5.6.4. [Practical Exercise 4: Practice Dictionaries](#PE4)<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;5.6.5. [Practical Exercise 5: Deduplicated List](#PE5)<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;5.6.6. [Practical Exercise 6: Employee Availability](#PE6)<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;5.6.7. [Practical Exercise 7: Symmetric Difference](#PE7)<br>\n",
    "5.7. [Appendix](#appendix)<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr> \n",
    "\n",
    "<a id='Objectives'></a>\n",
    "## 5.1 Objectives\n",
    "\n",
    "* Examine the implications of using computation to solve a problem\n",
    "    * Discuss best practices for using computation to solve a problem\n",
    "    * Suggest types of problems that can be solved through computation\n",
    "    * Show how computation can solve a problem\n",
    "<br><br>    \n",
    "* Recognize key computer science concepts\n",
    "    * Identify data types used in Python scripting\n",
    "    * Identify data structures used in Python scripting\n",
    "    * Define variables and strings\n",
    "    * Recognize how queries operate\n",
    "<br><br>    \n",
    "* Demonstrate the ability to build basic scripts using Python scripting language\n",
    "    * Use various data types and structures in Python scripting\n",
    "    * Collect data using Python scripting\n",
    "    * Extract data using Python scripting\n",
    "    * Develop advanced data structures using Python scripting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "<a id='Overview'></a>\n",
    "## 5.2. Overview\n",
    "\n",
    "The following material is divided into the following parts:\n",
    "* Lesson\n",
    "* Guided Exercise\n",
    "* Practical Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "<a id=\"Review\"></a>\n",
    "## 5.3. Review\n",
    "\n",
    "<hr>\n",
    "\n",
    "<a id='lists'></a>\n",
    "### 5.3.1. Lists\n",
    "\n",
    "**Exercise:** Create a list of at least 5 elements, then print the last three elements using slicing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR CODE GOES HERE ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Describe the difference between the `.append()` and `.extend()` list functions. Then write some code to show how they each work using an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR CODE GOES HERE ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Overwrite the second element, fourth element, and last element of the list you created in the first part of this exercise. You may overwrite the second, fourth, and last elements with whatever data value or data structure you want.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR CODE GOES HERE ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr><a id='tuples'></a>\n",
    "\n",
    "### 5.3.2. Tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** The tuple below has some misspelled objects. You can’t overwrite them individually because tuples are immutable, but you can overwrite the entire structure. Create a new tuple with the correct spellings and save it to the same variable as the one below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_tuple = ('Monday', 'Tuesay', 'Wednesda', 'Thrsday', 'Friyay')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR CODE GOES HERE ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** What are some examples of data that would be good to store in a tuple? No code is required for this exercise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR ANSWER GOES HERE ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr><a id='bool'></a>\n",
    "\n",
    "### 5.3.3. Boolean Expressions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Write a boolean condition that evaluates to `True` and uses a mix of conditional, membership, and logical operators.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR CODE GOES HERE ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Write a boolean condition that evaluates to `False` and uses a mix of conditional, membership, and logical operators.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR CODE GOES HERE ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr><a id='if'></a>\n",
    "\n",
    "### 5.3.4. If Statements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Run the cell below and debug the output. Is the answer what you expected? What could be wrong with the syntax of the boolean expression?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "coord = '357682W'\n",
    "if 'N' or 'S' in coord:\n",
    "    print('There IS an \"N\" or \"S\" in the coordinate:', coord)\n",
    "else:\n",
    "    print('There IS NOT an \"N\" or \"S\" in the coordinate:', coord)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR ANSWER GOES HERE -- NO CODE NECESSARY ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Create an `if` block that uses the `if`, `elif`, and `else` keywords. <br>\n",
    "\n",
    "**Bonus:** Use multiple  different operators (membership, conditional, logical)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR CODE GOES HERE ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Create an `if` block that checks the weight of your luggage, and if it is greater than 50 pounds tells you to remove something. For this example, your \"luggage\" will be represented by the list of weights below.<br>\n",
    "\n",
    "HINT: the total weight of your \"luggage\" is the `sum()` of all of the individual weights."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "luggage = [5, 1.2, 2.5, 7, 3, 2.5, 9.3, 1, 2, 6.1, 5.9, 1.3, 4.2, 8.1, 6.7, 1.5, 0.8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR CODE GOES HERE ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "<a id='Lesson'></a>\n",
    "## 5.4. Lesson: Data Structures\n",
    "\n",
    "<hr>\n",
    "\n",
    "<a id='Unordered'></a>\n",
    "### 5.4.1. Unordered Collections\n",
    "\n",
    "Sequences are like pill boxes.  They contain pieces of data in a given order, where each item is given a numeric index.\n",
    "\n",
    "<img src=\"./GRAPHICS/list_pillbox.png\" width=\"33%\">\n",
    "\n",
    "Unordered collections, on the other hand, are like pill bottles.  While they also contain data elements, there is not an inherent order or addressing system.\n",
    "\n",
    "<img src=\"./GRAPHICS/list_pillbottle.png\" width=\"15%\"> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr> \n",
    "\n",
    "<a id='sets'></a>\n",
    "### 5.4.2. Sets\n",
    "\n",
    "#### References:\n",
    "* [Python: Sets](https://docs.python.org/3.4/tutorial/datastructures.html#sets)\n",
    "\n",
    "Sets are mutable, unordered collections of unique elements. Like all unordered collections, sets are not considered sequences and do not support indexing or slicing. Sets also support mathematical operations like union, intersection, difference, and symmetric difference. Basic uses of sets include membership testing and deduplication. Sets are always wrapped in curly braces: `{}`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.4.2.1. Creating Sets\n",
    "\n",
    "There's only one way to create an empty set, and that is to call the `set()` function with no arguments. To create a set with elements in it, wrap multiple elements in curly braces."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_set = set()                      \n",
    "my_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_set = {1, 'a', 3.1415}\n",
    "my_set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One special feature of sets is that they automatically drop duplicate values. All values in a set must be unique, so Python strips out unneeded duplicates. Elements of a set must also be immutable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_set = {1, 1, 1, 3, 4, 5}\n",
    "my_set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A common way to create a set is to cast a different type of collection. Remember, this deduplicates the collection automatically."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = [14, 7, 12, 8, 12, 5, 7, 12, 5, 13, 13, 11, 14, 12, 9]\n",
    "\n",
    "my_set = set(my_list)\n",
    "my_set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Create a set with the names of your favorite TV shows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR CODE GOES HERE ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Create a set using casting and store it in a variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR CODE GOES HERE ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.4.2.2. Set Methods and Operations\n",
    "\n",
    "To add elements to a set, use the `.add()` method. To remove individual elements from a set, use the `.remove()` method.\n",
    "\n",
    "| Syntax               | Description                               |\n",
    "|:----------------------:|-------------------------------------------|\n",
    "|`set_variable.add(x)`  | Adds `x` to the set |\n",
    "|`set_variable.remove(x)`| Removes `x` from the set |\n",
    "|`set_variable.pop()`| Removes and returns a random item from the set |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_set.add(297)\n",
    "my_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_set.remove(297)\n",
    "my_set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calling `.pop()` on a set will return an item at random. Because sets don't have an index, you can't use an argument to tell Python which item to get."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "item = my_set.pop()\n",
    "print(item, my_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can test for membership with the `in` keyword."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "297 in my_set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Add another TV show to the set of favorite TV shows and delete another one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR CODE GOES HERE ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sets in Python support set-specific mathematical operations. You may be familiar with set arithmetic from working with Venn diagrams in math class. We sometimes refer to set operations as _cross referencing_.\n",
    "\n",
    "<img src=\"./GRAPHICS/FoodExample.png\" width=\"50%\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| Code| Mathematical Operation  | Description                       | Graphical Representation   |\n",
    "|:----------------------:|:-----:|:------------------------------:|:----------------------------:|\n",
    "| `a.intersection(b)`|Intersection | Returns elements that appear in both set `a` and set `b`| <img src=\"./GRAPHICS/intersection2.png\" width=\"40%\">|\n",
    "| `a.union(b)`|Union| Returns elements in either set `a` or set `b` |<img src=\"./GRAPHICS/union2.png\" width=\"40%\">|\n",
    "|`a.difference(b)` |Left Set Difference|Returns elements from set `a` that are not in set `b`|<img src=\"./GRAPHICS/diff1.png\" width=\"40%\"> |\n",
    "|`b.difference(a)`|Right Set Difference|Returns elements from set `b` that are not in set `a`|<img src=\"./GRAPHICS/diff2.png\" width=\"40%\"> |\n",
    "| `a.symmetric_difference(b)`|Symmetric Set Difference| Returns elements in set `a` or set `b`, but not in both|<img src=\"./GRAPHICS/symmetricdiff.png\" width=\"40%\">|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As an example, let's look at two sets of employee names. Who still needs to complete mandatory training? To find out, we could take the set difference."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "team_members = {'Smith', 'Daniels', 'Robertson', 'Chen', 'Winters', 'Baker', 'Johnson', 'Blake'}                    \n",
    "\n",
    "completed_mandatory_training = {'Winters', 'Robertson', 'Smith'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "team_members.difference(completed_mandatory_training)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Talk to your neighbor, discuss how sets can be useful in the work that you do. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR ANSWER GOES HERE -- NO CODE NECESSARY ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Create a set of your neighbors favorite TV shows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR CODE GOES HERE ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Check if you have any TV shows in common with your neighbor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR CODE GOES HERE ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Make a set of recommendations for your instructors by creating a combined set of all the items in your and your neighbor's favorite shows set. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR CODE GOES HERE ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Take the set of the recommendations and convert it into a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR CODE GOES HERE ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr> \n",
    "\n",
    "<a id='dict'></a>\n",
    "### 5.4.3. Dictionaries\n",
    "\n",
    "#### References:\n",
    "* [Python: Dictionaries](https://docs.python.org/3.4/tutorial/datastructures.html#dictionaries)\n",
    "\n",
    "Dictionaries are unordered collections of key-value pairs. Unlike sequences, which are indexed, dictionaries are accessible by their keys, which can be of any immutable type. Strings, numbers, and tuples can all serve as keys in a dictionary.\n",
    "\n",
    "Dictionaries share many properties with sets:\n",
    "* Both sets and dictionaries are unordered\n",
    "* Both sets and dictionaries are wrapped in curly braces\n",
    "* Sets must have unique entries, dictionaries must have unique keys\n",
    "\n",
    "A driver's license is a great example of a common object in our daily lives that uses key-value pairs. Each data point is linked to a key that describes what it is. \n",
    "\n",
    "<img src=\"./GRAPHICS/DriversLicense.png\" width=\"35%\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.4.3.1. Creating Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like sets, dictionaries use curly braces as wrappers. However, a set of empty curly braces gets interpreted as an empty dictionary, not a set. We can also set up a dictionary that's populated with entries. Note that each entry in the dictionary below is a pair of values separated by a colon (`:`). To the left of the colon is the entry's _key_, and to the right is the _value_. Dictionary entries are always structured like this: `key: value`, with commas separating each `key: value` pair."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "empty_dictionary = {}\n",
    "empty_dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "english_french_dictionary = {'hello': 'bonjour',\n",
    "                             'world': 'monde',\n",
    "                             'thank you': 'merci'}\n",
    "english_french_dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Create a dictionary and store it in a variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR CODE GOES HERE ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Create an empty dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR CODE GOES HERE ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.4.3.2. Dict Methods and Operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "To access a value inside a dictionary, we use bracket notation as we would for a list, tuple, or string. But instead of putting a numeric index inside the brackets, we put a key. Dictionaries are mutable, so we can change individual values without overwriting the entire data structure.\n",
    "\n",
    "| Syntax                 | Description                               |\n",
    "|:----------------------:|-------------------------------------------|\n",
    "| `dict_variable[key]` |Accesses the item at key `[key]` |\n",
    "| `dict_variable[key] = x` |Sets the item at key `[key]` to  `x` |\n",
    "\n",
    "> NOTE: Dictionary keys can be any immutable data type."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below, we access the value stored at the key `'hello'` in our `english_french_dictionary`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "english_french_dictionary['hello']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below, we add an entry to our dictionary using bracket notation and assignment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "english_french_dictionary['good bye'] = 'au revoir'\n",
    "english_french_dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also overwrite an existing value in a dictionary using the same syntax as above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "english_french_dictionary['hello'] = ['bonjour', 'salut']\n",
    "english_french_dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Deleting a key-value pair from a dictionary requires the `del` keyword. Be careful, as deletions using `del` permanently wipe the entry from memory.\n",
    "\n",
    "| Syntax                 | Description                               |\n",
    "|:----------------------:|-------------------------------------------|\n",
    "| `del dict_variable[n]` |Delete the entry at key `[n]` |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "del english_french_dictionary['good bye']\n",
    "\n",
    "english_french_dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can quickly glance through all of the keys in a dictionary using the `.keys()` method.  Additionally, we can look at the values in a dictionary using the `.values()` method. These methods return list-like objects.\n",
    "\n",
    "| Syntax                 | Description                               |\n",
    "|:----------------------:|-------------------------------------------|\n",
    "| `dict_variable.keys()` |Return a list-like object containing all keys |\n",
    "| `dict_variable.values()` |Return a list-like object containing all values |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "english_french_dictionary.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "english_french_dictionary.values()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Access the value at the key `'thank you'` in `english_french_dictionary`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR CODE GOES HERE ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Add the following entry to `english_french_dictionary`: `{'learn': 'apprendre'}`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR CODE GOES HERE ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Delete a key-value pair from the dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR CODE GOES HERE ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "<a id='Common'></a>\n",
    "### 5.4.4. Common Operations Across Data Structures\n",
    "\n",
    "The functions in the table below also apply to sets and dictionaries. When called on dictionaries, these functions consider only the keys. Because of this, calling `max()` on a dictionary would give you its largest (highest value) key. Keep in mind also that `sorted()` will always return a list, even if you call it on a set or dictionary.\n",
    "\n",
    "| Syntax               | Description                               |\n",
    "|:----------------------:|-------------------------------------------|\n",
    "|`max(collection)`    | Returns the maximum value contained in the collection |\n",
    "|`min(collection)`    | Returns the minimum value contained in the collection |\n",
    "|`sum(collection)`    | Returns the sum of the collection's elements (only works if all items are numeric) |\n",
    "|`len(collection)`    | Returns the number of elements in the collection |\n",
    "|`sorted(collection)` | Returns a sorted list of the collections elements |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_set = {'F15', 'P17', 'T18', 'E14', 'A18', 'D13', 'D19', 'Z16', 'K17', 'X16', 'V13', 'U13'}\n",
    "\n",
    "max(my_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_set = {'F15', 'P17', 'T18', 'E14', 'A18', 'D13', 'D19', 'Z16', 'K17', 'X16', 'V13', 'U13'}\n",
    "\n",
    "min(my_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = [45, 42, 57, 55, 46, 60, 50, 44, 40, 43, 52, 54]\n",
    "\n",
    "sum(my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_dict = {'A': 0, 'B': 1, 'C': 2, 'D': 3, 'E': 4, 'F': 5, 'G': 6, 'H': 7, 'I': 8, 'J': 9}\n",
    "\n",
    "len(my_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_dict = {'A': 0, 'B': 1, 'C': 2, 'D': 3, 'E': 4, 'F': 5, 'G': 6, 'H': 7, 'I': 8, 'J': 9}\n",
    "\n",
    "sorted(my_dict, reverse=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Find the sum of all the values in `my_dict`. HINT: You need to pull out the values before calling the `sum()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR CODE GOES HERE ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "<a id='Guided-Exercise'></a>\n",
    "## 5.5. Guided Exercise: Analyzing Crime Data\n",
    "\n",
    "We've received some data about criminal activity, and have been tasked with doing some analysis of the data. The dataset is rather small, but we expect to be receiving similar reports on a recurring basis and will always want to perform the same analysis. This is a perfect case to write some Python code to do our analysis for us. The data is in the code cell below, and we want to answer the following questions:\n",
    "\n",
    "1. What dates do we have data for?\n",
    "2. How many crimes were reported on the first and last dates in the data set?\n",
    "3. How many unique coordinates are there? Are there coordinates that appear more than once?\n",
    "4. Did 11-10-2016 have more or less crimes than average for that day on record?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "crime_dates = {'11-07-2016': ['110716AT001', '110716AT010', '110716DN011', '110716DN014', '110716DN059', '110716DN071', '110716NA003', '110716NA023',\n",
    "                              '110716NA039', '110716NA049', '110716NA051', '110716NA054', '110716RB004', '110716RB008', '110716TF000', '110716TF019'],\n",
    "               '11-08-2016': ['110816AT003', '110816AT006', '110816AT014', '110816DN004', '110816DN029', '110816DN034', '110816DN037', '110816NA001',\n",
    "                              '110816NA028', '110816NA039', '110816NA040', '110816NA049', '110816RB010', '110816TF013', '110816TF015', '110816TF032', '110816TF038', '110816TF044'], \n",
    "               '11-09-2016': ['110916AT000', '110916DN009', '110916DN019', '110916DN021', '110916DN022', '110916DN029', '110916DN065', '110916DN069',\n",
    "                              '110916NA001', '110916NA036', '110916NA046', '110916RB004', '110916RB021', '110916TF000', '110916TF013', '110916TF017', '110916TF025', '110916TF037'],\n",
    "               '11-10-2016': ['111016DN013', '111016DN015', '111016DN022', '111016DN036', '111016DN049', '111016DN055', '111016DN058', '111016NA018',\n",
    "                              '111016NA029', '111016NA040', '111016RB010', '111016RB014', '111016RB017', '111016TF007', '111016TF015', '111016TF024', '111016TF025'],\n",
    "               '11-11-2016': ['111116AT004', '111116DN008', '111116DN015', '111116DN030', '111116DN033', '111116DN048', '111116NA001', '111116NA026',\n",
    "                              '111116NA031', '111116RB005', '111116RB012', '111116TF004', '111116TF010', '111116TF036', '111116TF048']\n",
    "              }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "crime_coords = {'110716AT001': (39.29, -76.65), '110716AT010': (39.29, -76.64), '110716DN011': (39.28, -76.65), '110716DN014': (39.29, -76.65), '110716DN059': (39.29, -76.65), '110716DN071': (39.28, -76.67),\n",
    "                '110716NA003': (39.29, -76.68), '110716NA023': (39.29, -76.68), '110716NA039': (39.29, -76.65), '110716NA049': (39.27, -76.65), '110716NA051': (39.28, -76.65), '110716NA054': (39.30, -76.66),\n",
    "                '110716RB004': (39.28, -76.65), '110716RB008': (39.30, -76.66), '110716TF000': (39.29, -76.64), '110716TF019': (39.30, -76.65), '110816AT003': (39.29, -76.65), '110816AT006': (39.29, -76.68),\n",
    "                '110816AT014': (39.29, -76.68), '110816DN004': (39.28, -76.64), '110816DN029': (39.28, -76.66), '110816DN034': (39.29, -76.65), '110816DN037': (39.30, -76.67), '110816NA001': (39.29, -76.67),\n",
    "                '110816NA028': (39.28, -76.65), '110816NA039': (39.29, -76.66), '110816NA040': (39.29, -76.66), '110816NA049': (39.30, -76.66), '110816RB010': (39.28, -76.65), '110816TF013': (39.29, -76.65),\n",
    "                '110816TF015': (39.29, -76.65), '110816TF032': (39.30, -76.67), '110816TF038': (39.28, -76.65), '110816TF044': (39.30, -76.66), '110916AT000': (39.29, -76.65), '110916DN009': (39.28, -76.65),\n",
    "                '110916DN019': (39.30, -76.64), '110916DN021': (39.30, -76.67), '110916DN022': (39.28, -76.66), '110916DN029': (39.28, -76.65), '110916DN065': (39.29, -76.68), '110916DN069': (39.30, -76.67),\n",
    "                '110916NA001': (39.30, -76.65), '110916NA036': (39.30, -76.65), '110916NA046': (39.28, -76.66), '110916RB004': (39.28, -76.66), '110916RB021': (39.30, -76.66), '110916TF000': (39.29, -76.65),\n",
    "                '110916TF013': (39.30, -76.64), '110916TF017': (39.29, -76.65), '110916TF025': (39.29, -76.65), '110916TF037': (39.29, -76.66), '111016DN013': (39.28, -76.66), '111016DN015': (39.28, -76.66),\n",
    "                '111016DN022': (39.29, -76.66), '111016DN036': (39.29, -76.64), '111016DN049': (39.29, -76.66), '111016DN055': (39.30, -76.65), '111016DN058': (39.29, -76.64), '111016NA018': (39.29, -76.65),\n",
    "                '111016NA029': (39.30, -76.65), '111016NA040': (39.28, -76.65), '111016RB010': (39.30, -76.65), '111016RB014': (39.28, -76.67), '111016RB017': (39.28, -76.66), '111016TF007': (39.30, -76.66),\n",
    "                '111016TF015': (39.30, -76.65), '111016TF024': (39.28, -76.64), '111016TF025': (39.29, -76.68), '111116AT004': (39.29, -76.66), '111116DN008': (39.29, -76.64), '111116DN015': (39.29, -76.66),\n",
    "                '111116DN030': (39.30, -76.65), '111116DN033': (39.28, -76.65), '111116DN048': (39.28, -76.65), '111116NA001': (39.28, -76.66), '111116NA026': (39.28, -76.64), '111116NA031': (39.29, -76.68),\n",
    "                '111116RB005': (39.28, -76.67), '111116RB012': (39.30, -76.67), '111116TF004': (39.30, -76.65), '111116TF010': (39.30, -76.67), '111116TF036': (39.29, -76.67), '111116TF048': (39.30, -76.66)\n",
    "               }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "historic_avg = {'11-07': 20, '11-08': 18, '11-09': 15, '11-10': 14, '11-11': 20}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 1:** What dates do we have data for?\n",
    "\n",
    "To answer this question, we simply need to access all the keys in `crime_dates`. The easiest way to do that is to use the `.keys()` method. Since dictionary keys are unordered and we always want to display dates in order, we can use `sorted()` to sort the dates from oldest to newest.\n",
    "\n",
    "**Pseudocode:**\n",
    "1. Access the keys in `crime_dates` (`.keys()`)\n",
    "2. Display dates as a sorted list (`sorted()`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dates = sorted(crime_dates.keys())\n",
    "dates"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 2:** How many crimes were reported on the first and last dates in the data set?\n",
    "\n",
    "To check how many incidents were reported on a given day, we can just check the length of the value associated with that day in `crime_dates`. To find the first and last dates, we can use indexing on our `dates` list.\n",
    "\n",
    "**Pseudocode:**\n",
    "1. Get the first and last dates from the list we created above\n",
    "2. Access the values in `crime_dates` for each date\n",
    "3. Find the length of the values for each date"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "first_date = dates[0]\n",
    "last_date = dates[-1]\n",
    "\n",
    "crimes_first = len(crime_dates[first_date])\n",
    "crimes_last = len(crime_dates[last_date])\n",
    "\n",
    "print('First date:', crimes_first)\n",
    "print('Last date:', crimes_last)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 3:** How many unique coordinates are there? Are there coordinates that appear more than once?\n",
    "\n",
    "To answer this, we need to look at `crime_coords` dictionary. We know we can isolate the coordinates with `.values()`, but how do we find how many unique coordinates there are? Remember that sets only hold unique items, so casting the values to a set and then finding the length will answer the first question. After finding how many unique coordinates we have, we can compare that to the total number of coordinates to determine if there are any duplicates.\n",
    "\n",
    "**Pseudocode:**\n",
    "1. Extract the coordinates from `crime_coords` (`.values()`)\n",
    "2. Cast the values to a set\n",
    "3. Find the length of the set\n",
    "4. Find the length of the entire list of coordinates, and compare"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "coords = crime_coords.values()\n",
    "\n",
    "unique_coords = set(coords)\n",
    "\n",
    "len(unique_coords)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(coords)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 4:** Did 11-10-2016 have more or less crimes than average for that day on record?\n",
    "\n",
    "For this question, we need to check how many crimes were reported on the date in question. Then, we need to compare that number to the average number of crimes reported for that date in `historic_avg`.\n",
    "\n",
    "**Pseudocode:**\n",
    "1. Save the date `11-10-2016` as a string to a variable\n",
    "2. Extract the month and year from the date (slicing)\n",
    "3. Find the number of crimes reported on `11-10-2016` (`len()` on `crime_dates` values)\n",
    "4. Find the average number of crimes reported on `11-10` in `historic_avg`\n",
    "5. Compare the two values from steps 3 and 4 (`if` block)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "date = '11-10-2016'\n",
    "\n",
    "date_no_year = date[:5]\n",
    "\n",
    "num_crimes = len(crime_dates[date])\n",
    "avg_crimes = historic_avg[date_no_year]\n",
    "\n",
    "if num_crimes < avg_crimes:\n",
    "    print(date, 'had fewer crimes than average')\n",
    "elif num_crimes > avg_crimes:\n",
    "    print(date, 'had more crimes than average')\n",
    "else: \n",
    "    print(date, 'had an average number of crimes')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "<a id='Practical-Exercises'></a>\n",
    "## 5.6. Practical Exercises "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "<a id = 'PE1'></a>\n",
    "### 5.6.1. Practical Exercise 1: Knowledge Check: Sets\n",
    "\n",
    "**Problem 1:** What are the differences between sets and lists? When would you use a set rather than a list?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR ANSWER GOES HERE -- NO CODE NECESSARY ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem 2:** Jot down all the actions that you can do using sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR ANSWER GOES HERE -- NO CODE NECESSARY ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "<a id = 'PE2'></a>\n",
    "### 5.6.2. Practical Exercise 2: Practice Sets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem 1:** Create an empty set and save it to a variable called `fruits`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR CODE GOES HERE ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem 2:** Add three different fruits to the fruits set using `.add()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR CODE GOES HERE ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem 3:** Create a set with everyday groceries and save it to a variable called `groceries`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR CODE GOES HERE ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem 4:** Find the length of the grocery list. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR CODE GOES HERE ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem 5:** Find all the items in your fruits set that are in the groceries set. That is, find the intersection of the two sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR CODE GOES HERE ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem 6:** Create the set of all the groceries that aren't in the fruits set. That is, find the difference between the groceries and the fruits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR CODE GOES HERE ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='PE3'></a>\n",
    "<hr>\n",
    "\n",
    "### 5.6.3 Practical Exercise 3: Knowledge Check: Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem 1:** In the broadest terms possible, what are dictionaries made up of? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR ANSWER GOES HERE -- NO CODE NECESSARY ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem 2:** In one dictionary, can we have multiple different keys with the same values? Why or why not?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR ANSWER GOES HERE -- NO CODE NECESSARY ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem 3:** In one dictionary, can there be duplicate keys linked to different values? Why or why not?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR ANSWER GOES HERE -- NO CODE NECESSARY ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem 4:** What kind of data types and data structures can be used as _values_ in a key-value pair?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR ANSWER GOES HERE -- NO CODE NECESSARY ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem 5:** When applying common functions on a dictionary (such as the `sum()` function), is the function applied to the dictionary's keys or values?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR ANSWER GOES HERE -- NO CODE NECESSARY ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "<a id  = 'PE4'></a>\n",
    "### 5.6.4. Practical Exercise 4: Practice Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem 1:** Create a dictionary with 6 people and their ages, where the age is the key and the name is the value. Account for a few people having the same age."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR CODE GOES HERE ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem 2:** Add the following key-value pair to your dictionary: `{43: 'Laura'}` </center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR CODE GOES HERE ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem 3:** Print the name of the youngest person (or people) in the dictionary.<br> \n",
    "\n",
    "HINT: Try using the `min()` function on the dictionary and see what that gives you."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR CODE GOES HERE ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem 4:** Print the name of the oldest person (or people) in the dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR CODE GOES HERE ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "<a id='PE5'></a>\n",
    "### 5.6.5. Practical Exercise 5: Deduplicated List\n",
    "\n",
    "Create a list of data, and be sure to include duplicates. Store your list in a variable. Then, write a script to create a list with all of the unique values from your list. <br>\n",
    "\n",
    "HINT: Cast to a set to remove duplicates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR CODE GOES HERE ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "<a id='PE6'></a>\n",
    "### 5.6.6. Practical Exercise 6: Employee Availability\n",
    "\n",
    "Your employees have provided you a list of days that they are available to work; you've complied this data into the dictionary seen in the code block below. \n",
    "\n",
    "**Problem 1:** Write a script that takes a name and a day as inputs, and outputs `True` if that employee can work on that day and `False` otherwise.\n",
    "\n",
    "| Example Input | Expected Output |\n",
    "|:-------|:-----------------:|\n",
    "| `name = 'Lucy'`<br>`day = 'Friday'` | `False` |\n",
    "| `name = 'Tom'`<br>`day = 'Monday'` | `True` |\n",
    "| `name = 'Sara'`<br>`day = 'Sunday'` | `False` |\n",
    "| `name = 'Alex'`<br>`day = 'Saturday'` | `True` |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "availability = {'Alex': ['Monday', 'Tuesday', 'Thursday', 'Saturday'],\n",
    "                'Apollo': ['Wednesday', 'Sunday'],\n",
    "                'Cait': ['Monday', 'Tuesday', 'Wednesday', 'Friday', 'Saturday', 'Sunday'],\n",
    "                'Giulia': ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'],\n",
    "                'Jelle': ['Wednesday', 'Friday', 'Sunday'],\n",
    "                'John': ['Tuesday', 'Wednesday', 'Friday', 'Sunday'],\n",
    "                'Lasse': ['Monday', 'Thursday', 'Friday', 'Saturday', 'Sunday'],\n",
    "                'Lucy': ['Monday', 'Tuesday'],\n",
    "                'Nico': ['Monday', 'Tuesday', 'Wednesday', 'Sunday'],\n",
    "                'Rachel': ['Monday', 'Wednesday', 'Thursday'],\n",
    "                'Sara': ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday'],\n",
    "                'Shawn': ['Tuesday', 'Wednesday', 'Sunday'],\n",
    "                'Tara': ['Friday'],\n",
    "                'Tom': ['Monday', 'Thursday', 'Friday', 'Saturday', 'Sunday'],\n",
    "                'Zack': ['Monday', 'Tuesday', 'Friday', 'Saturday']}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR CODE GOES HERE ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem 2:** One of your employees calls in sick on Wednesday and you need to find an employee that is available to come in as soon as possible. Your order of preference is Tara, Lucy, Tom, Alex, Rachel, Sara, Zach, then after that no preference. Who is the most preferred employee available? Hint: Use your code from above, set the day equal to ‘Wednesday’.  Enter the names above in your name variable until you find someone who can work on Wednesdays. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR CODE GOES HERE ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "<a id='PE7'></a>\n",
    "### 5.6.7. [Challenge] Practical Exercise 7: Symmetric Difference\n",
    "\n",
    "Write a script that does the same thing as `.symmetric_difference()` using only the other set methods from this lesson: `.union()`, `.intersection()`, and `.difference()`. HINT: The symmetric difference is equal to the difference between the union and the intersection, or union of the differences between each set and the other."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR CODE GOES HERE ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr> \n",
    "\n",
    "<a id='appendix'></a>\n",
    "## 5.7. Appendix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center><b>Indexing and Slicing Any Sequence</b></center>\n",
    "\n",
    "| Syntax               | Description                               |\n",
    "|:----------------------:|-----------------------------------|\n",
    "|`sequence[i]`   | Returns the element at index `i` |\n",
    "|`sequence[start:stop]`| Returns the elements from `start` up to but not including `stop`|\n",
    "\n",
    "<br><center>**Set Methods and Operations**</center>\n",
    "\n",
    "| Syntax               | Description                               |\n",
    "|:----------------------:|-------------------------------------------|\n",
    "|`set_variable.add(x)`  | Adds `x` to the set |\n",
    "|`set_variable.remove(x)`| Removes `x` from the set |\n",
    "|`set_variable.pop()`| Removes and returns a random item from the set |\n",
    "\n",
    "<br><center>**Set Math Operations**</center>\n",
    "\n",
    "| Code| Mathematical Operation  | Description                       | Graphical Representation   |\n",
    "|:----------------------:|:-----:|:------------------------------:|:----------------------------:|\n",
    "| `a.intersection(b)`|Intersection | Returns elements that appear in both set `a` and set `b`| <img src=\"./GRAPHICS/intersection2.png\" width=\"40%\">|\n",
    "| `a.union(b)`|Union| Returns elements in either set `a` or set `b` |<img src=\"./GRAPHICS/union2.png\" width=\"40%\">|\n",
    "|`a.difference(b)` |Left Set Difference|Returns elements from set `a` that are not in set `b`|<img src=\"./GRAPHICS/diff1.png\" width=\"40%\"> |\n",
    "|`b.difference(a)`|Right Set Difference|Returns elements from set `b` that are not in set `a`|<img src=\"./GRAPHICS/diff2.png\" width=\"40%\"> |\n",
    "| `a.symmetric_difference(b)`|Symmetric Set Difference| Returns elements in set `a` or set `b`, but not in both|<img src=\"./GRAPHICS/symmetricdiff.png\" width=\"40%\">|\n",
    "\n",
    "<br><center>**Dictionary Methods and Operations**</center>\n",
    "\n",
    "| Syntax                 | Description                               |\n",
    "|:----------------------:|-------------------------------------------|\n",
    "| `dict_variable[key]` |Accesses the item at key `[key]` |\n",
    "| `dict_variable[key] = x` |Sets the item at key `[key]` to  `x` |\n",
    "| `del dict_variable[n]` |Delete the entry at key `[n]` |\n",
    "| `dict_variable.keys()` |Return a list-like object containing all keys |\n",
    "| `dict_variable.values()` |Return a list-like object containing all values |\n",
    "\n",
    "<br><center>**Functions for Any Sequence**</center>\n",
    "\n",
    "| Syntax               | Description                               |\n",
    "|:----------------------:|-------------------------------------------|\n",
    "|`max(collection)`    | Returns the maximum value contained in the collection |\n",
    "|`min(collection)`    | Returns the minimum value contained in the collection |\n",
    "|`sum(collection)`    | Returns the sum of the collection's elements (only works if all items are numeric) |\n",
    "|`len(collection)`    | Returns the length of the collection as an integer |\n",
    "|`sorted(collection)` | Returns a sorted copy of the collection |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr> <b><center>UNCLASSIFIED</center></b>"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}