DS109-Python/DS109-L4-Dictionaries.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "50e6ddbb-52d3-4a02-9b69-100a4181e3b0",
   "metadata": {},
   "source": [
    "# DS109 Python : Lesson Four Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1bd4bfc-9b15-4b80-87b4-b8b60eb56371",
   "metadata": {},
   "source": [
    "### Table of Contents <a class=\"anchor\" id=\"DS109L4_toc\"></a>\n",
    "\n",
    "* [Table of Contents](#DS109L4_toc)\n",
    "    * [Page 1 - Overview of this Module](#DS109L4_page_1)\n",
    "    * [Page 2 - Setup](#DS109L4_page_2)\n",
    "    * [Page 3 - Creating a Dictionary](#DS109L4_page_3)\n",
    "    * [Page 4 - Dictionary Activity Part 1](#DS109L4_page_4)\n",
    "    * [Page 5 - Accessing Dictionary Data](#DS109L4_page_5)\n",
    "    * [Page 6 - Modifying a Dictionary](#DS109L4_page_6)\n",
    "    * [Page 7 - Dictionary Activity Part II](#DS109L4_page_7)\n",
    "    * [Page 8 - Iterating Over a Dictionary](#DS109L4_page_8)\n",
    "    * [Page 9 - Iterating the Keys](#DS109L4_page_9)\n",
    "    * [Page 10 - Iterating the Values](#DS109L4_page_10)\n",
    "    * [Page 11 - Nested Dictionaries](#DS109L4_page_11)\n",
    "    * [Page 12 - Dictionary Activity Part III](#DS109L4_page_12)\n",
    "    * [Page 13 - Key Terms](#DS109L4_page_13)\n",
    "    * [Page 14 - Lesson 4 Hands-On](#DS109L4_page_14)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef5a8c65-ed48-4354-a257-e01b0fd733d4",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 1 - Overview of this Module<a class=\"anchor\" id=\"DS109L4_page_1\"></a>\n",
    "\n",
    "[Back to Top](#DS109L4_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "39ddf9fd-0f09-4f1b-8eb4-cf1289490a8c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"720\"\n",
       "            height=\"480\"\n",
       "            src=\"https://player.vimeo.com/video/238447818\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.VimeoVideo at 0x7fbc28221d00>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import VimeoVideo\n",
    "# Tutorial Video Name: Dictionaries\n",
    "VimeoVideo('238447818', width=720, height=480)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b6ad526-95fa-43c4-bc43-1fe807708ed3",
   "metadata": {},
   "source": [
    "In this lesson, you will learn about Python `dictionaries`. A dictionary is a collection of _key-value pairs_, where each key is connected to a value. Using the `key`, you can access the value that is associated with it. Dictionaries are similar to lists, except that instead of each item having a numeric index that can change as items are inserted and deleted, string keys are used that will not change as you add or remove other items.\n",
    "\n",
    "Consider an address book that stores addresses, phone numbers, and other personal information for people you know. Generally, you would locate them by their name. The person's name would serve as a key in an address book dictionary.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7990ac7a-5a2f-4744-af14-1b7e385ea484",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 2 - Setup<a class=\"anchor\" id=\"DS109L4_page_2\"></a>\n",
    "\n",
    "[Back to Top](#DS109L4_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "612429df-e4ef-4d85-8460-5bc8914079c3",
   "metadata": {},
   "source": [
    "## Setup\n",
    "\n",
    "1. First, open up your command prompt (Windows) or your terminal (Mac/Linux)\n",
    "    - For Windows, navigate to your search bar in the bottom left hand corner. Type in `Command Prompt` and it should pop up. Click on `Command Prompt` and a separate window should appear on your screen.\n",
    "    - For Mac, press `command` and the space bar at the same time. Type in `terminal` and press `enter`. A separate Terminal window will pop up.\n",
    "2. Now that you are in your Command Prompt/Terminal, run the following command:\n",
    "    ```text\n",
    "    cd desktop\n",
    "    ```\n",
    "3. Next, move your command prompt/terminal's location to the new `python_course` you just created by running the following:\n",
    "    ```text\n",
    "    cd python_course\n",
    "    ```\n",
    "4. Create a _new_ directory within the `python_course` directory. This new folder is the project you will be working in for this lesson. Run the following:\n",
    "    ```text\n",
    "    mkdir lesson_four\n",
    "    ```\n",
    "5. Open up a new window in VSCode.\n",
    "6. The first thing you should see a Welcome page. You can close this window.\n",
    "7. Now, its time to open the `lesson_four` directory. Click on the \"Explorer\" button on the left-hand side of the VSCode window.\n",
    "8. You will now see a button that says `Open Folder`, as shown below. Click this button.\n",
    "9. A new window will open that will allow you to search for files and folders. Locate the `python_course` folder you just created on your Desktop. Click on that folder and then locate the `lesson_four` folder. Select the `lesson_four` directory and click the `Open` button.\n",
    "10. Create a new file named `main.py` by one of the following three ways:\n",
    "    - To the right of __LESSON_FOUR__ in the EXPLORER is a button that looks like a piece of paper with a plus symbol in its top-left corner. If you hover your mouse over this button for a moment, a popup will appear indicating that this button will create a new file.\n",
    "    - Choose `File > New File` from the app's menu.\n",
    "    - Press `Control + N` in Windows or `Command + N` on a Mac (the plus means \"and at the same time\").\n",
    "\n",
    "Once the `main.py` file is created, you are ready to go! As you work through this lesson, add the code examples into your project so you can see the output yourself. Remember, to see the output within the VSCode terminal, right-click within your file and choose \"Run Python File in Terminal\".\n",
    "\n",
    "The creation of this new project is for you to practice your new skills. It is highly recommended that you add the code from this lesson into your `lesson_four` project as you learn it. As you are going through this lesson and adding code to your project, you may find it helpful to include `comments` with a brief sentence explaining what is going on in the code. That way, you will have an easy reference to the topics explained in this lesson. Happy coding!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "832358fd-55fa-420a-8aa2-46fbf2097986",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 3 - Creating a Dictionary<a class=\"anchor\" id=\"DS109L4_page_3\"></a>\n",
    "\n",
    "[Back to Top](#DS109L4_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f564e3e7-3a7f-4936-b3a3-2e0a9ab78512",
   "metadata": {},
   "source": [
    "# Key Value Pairs\n",
    "\n",
    "Just like in NoSQL, Python can store information in key value pairs.  The *key* is the overarching bucket (think variable), which holds a *value* or an instance of something.  In Python, the data storage type that uses key value pairs is called a *dictionary*. The values associated with a key can be a number, string, list, or even another dictionary. You can use any object that you can create in Python as a value in your dictionary. However, the keys are unique.  This means that keys must be an immutable, or unchangeable, data type such as a string, number, or tuple. \n",
    "\n",
    "---\n",
    "\n",
    "## Format of a Dictionary\n",
    "\n",
    "In Python, a dictionary is wrapped in curly braces `{}` and contains a series of key-value pairs inside of the curly braces. Each key is separated from its value by a colon `:`, and each key-value pair is separated by commas. Below is a generic example to show you how dictionaries are structured:\n",
    "\n",
    "```python\n",
    "dictionary = { key1 : value1, key2 : value2 }\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "## Creating an Empty Dictionary\n",
    "\n",
    "Just like when there are times that you need empty lists, sometimes you may need an empty dictionary as well.  You can create an empty dictionary by using two curly braces `{}`, as shown below:\n",
    "\n",
    "```python\n",
    "empty_dictionary = {}\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "## Dictionary Examples\n",
    "\n",
    "Below, a dictionary is created to represent an employee:\n",
    "\n",
    "```python\n",
    "employee = {'name': 'Andrew', 'age': 29, 'position': 'Engineer'}\n",
    "```\n",
    "\n",
    "What about an address?\n",
    "\n",
    "```python\n",
    "address = {'city': 'Scottsdale', 'state': 'AZ', 'zip': '85258'}\n",
    "```\n",
    "\n",
    "In the above examples, `employee` and `address` are the variables that will contain the dictionary values (the curly braces and everything in between).\n",
    "\n",
    "The dictionaries contain keys and their associated values. In the first example, there are three keys: `name`, `age`, and `position`. Two of the values associated with the keys are strings, while one is a number. Each key-value pair is specified as <b>&lt;key&gt;: &lt;value&gt;</b>, and the collection of key-value pairs are separated with commas.\n",
    "\n",
    "There is no limit (beyond computer memory) to how many key-value pairs you can store in a dictionary. You can even add key-value pairs where the value is empty!\n",
    "\n",
    "---\n",
    "\n",
    "## dict() Function\n",
    "\n",
    "Another mechanism for creating a dictionary involves using the `dict()` function. When using the `dict()` command, the format of the input is different, as you can see in the example below:\n",
    "\n",
    "```python\n",
    "new_dict = dict(name='john', age=19, hometown='Phoenix')\n",
    "print(new_dict)\n",
    "```\n",
    "\n",
    "**OUTPUT:**\n",
    "\n",
    "```python\n",
    "{'name': 'john', 'age': 19, 'hometown': 'Phoenix'}\n",
    "```\n",
    "\n",
    "In the example above, you can see that Python automatically formatted the input to the `dict()` command into a dictionary. The key-value pairs were not written as <b>&lt;key&gt;: &lt;value&gt;</b> like you saw earlier; instead, they were done as assignments <b>&lt;key&gt;= &lt;value&gt;</b>. Further, did you notice how the keys have no quotes around them, even though they are strings?\n",
    "\n",
    "Here is one more example of the `dict()` function being used.\n",
    "\n",
    "```python\n",
    "dictionary = dict([(1, 'John'), (2, 'Andrew')])\n",
    "print(dictionary)\n",
    "```\n",
    "\n",
    "**OUTPUT:**\n",
    "\n",
    "```python\n",
    "{1: 'John', 2: 'Andrew'}\n",
    "```\n",
    "\n",
    "Again, Python reads the dict function and formats the dictionary appropriately. This time, the keys that were used were integers.\n",
    "\n",
    "<div class=\"panel panel-warning\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <h3 class=\"panel-title\">Try It Yourself!</h3>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "        <p>Go ahead and write three dictionaries of your own. They can be anything, just make sure they have key-value pairs!</p>\n",
    "    </div>\n",
    "</div>\n",
    "\n",
    "---\n",
    "## Best Practice Dictionary Formatting\n",
    "\n",
    "You may often see dictionaries formatted to write each key value pair on its own line.  This is a best practice in formatting to make your code more readable for other programmers/people. Here's an example:\n",
    "\n",
    "```python\n",
    "contact = {\n",
    "    'first_name': 'Henry',\n",
    "    'last_name': 'Poldark',\n",
    "    'phone_number': '(123)-456-7890',\n",
    "    'street': 'N 90th St',\n",
    "    'city': 'Scottsdale',\n",
    "    'state': 'Arizona',\n",
    "    'zip_code': '85258'\n",
    "}\n",
    "```\n",
    "\n",
    "Above, since the key-value pairs are enclosed within curly braces `{}`, the indentation of each line is not critical. However, it is a good practice to line things up so that they are easier to read.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "3a8516b3-c99d-4b0a-935c-10af9393b811",
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    from DS_Students import MultipleChoice  \n",
    "except:\n",
    "    !pip install DS_Students\n",
    "    from DS_Students import MultipleChoice\n",
    "from ipynb.fs.full.DS109Questions import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "e93fa077-2d5b-45c1-9282-b886df0b63ef",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a87d110b2e604d4cb545af66a728460e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '1. When a dictionary is created, what set of charac…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "91548e23a6b24355ad34675ebcb8258a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '2. A dictionary cannot store other lists or diction…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "try:\n",
    "    display(L4P3Q1, L4P3Q2)\n",
    "except:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb1aade2-59af-4cbc-b5ed-da31e39f266d",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 4 - Dictionary Activity Part 1<a class=\"anchor\" id=\"DS109L4_page_4\"></a>\n",
    "\n",
    "[Back to Top](#DS109L4_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eba2ed6e-98dd-43f7-8761-6ecc9a13af08",
   "metadata": {},
   "source": [
    "Create a dictionary named `student` with the following key-value pairs:\n",
    "\n",
    "- `name` should have the value `\"Ace Ventura\"`\n",
    "- `age` should have the value `22`\n",
    "- `status` should have the value `junior`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "a277f0fa-5133-4fbc-b830-15b36b811263",
   "metadata": {},
   "outputs": [],
   "source": [
    "student = {\n",
    "    'name': 'Ace Ventura',\n",
    "    'age': 22,\n",
    "    'status': 'junior'\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "d4b2adbc-ee0d-4c01-8ec7-5c1ff715f2b3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'Ace Ventura', 'age': 22, 'status': 'junior'}\n"
     ]
    }
   ],
   "source": [
    "print(student)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ead4ad3c-2fe6-457e-8924-1410e951bebd",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 5 - Accessing Dictionary Data<a class=\"anchor\" id=\"DS109L4_page_5\"></a>\n",
    "\n",
    "[Back to Top](#DS109L4_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bbbc06a2-e702-47a1-942f-cbcbe31221a7",
   "metadata": {},
   "source": [
    "# Accessing Dictionary Data\n",
    "\n",
    "Accessing the data of a dictionary is virtually identical to accessing data in a list. The only difference is that, instead of providing an index, the __key__ is used to identify which item. Take a look at the example below:\n",
    "\n",
    "```python\n",
    "person = {'name': 'Andrew', 'age': 29, 'city': 'Scottsdale', 'state': 'AZ'}\n",
    "print(person['name'])\n",
    "print(person['age'])\n",
    "```\n",
    "\n",
    "**OUTPUT:**\n",
    "\n",
    "```python\n",
    "Andrew\n",
    "29\n",
    "```\n",
    "\n",
    "By adding a set of square brackets `[]` with the key inside of them, you can access the value of the specified key. \n",
    "\n",
    "---\n",
    "\n",
    "## Built-in Dictionary Functions\n",
    "\n",
    "In addition to using the key to access the values, you can also work with a few built-in functions.\n",
    "\n",
    "* **`.keys()`** - Isolates keys\n",
    "* **`.values()`** - Isolates values\n",
    "* **`.items()`** - Returns items in a list format of (key, value) tuple pairs.\n",
    "* **`.get()`** - This method returns a value for the given key. If the key is not available, it returns a default value of `None` (which is a value like True and False).\n",
    "\n",
    "Below you'll find examples of using each of the above.\n",
    "\n",
    "---\n",
    "\n",
    "### .keys()\n",
    "\n",
    "The `.keys()` command of a dictionary returns _only_ its keys. It does _not_ return any values. Remember that keys are the first part of the key-value pair!\n",
    "\n",
    "```python\n",
    "student = {'name': 'Andrew', 'program': 'Software Development', 'id': 110272}\n",
    "the_keys = student.keys()\n",
    "print(the_keys)\n",
    "```\n",
    "\n",
    "**OUTPUT:**\n",
    "\n",
    "```python\n",
    "dict_keys(['name', 'program', 'id'])\n",
    "```\n",
    "\n",
    "Above, the variable `the_keys` is assigned to the value returned by calling the `.keys()` operation of the dictionary. When printed out, you can see that it doesn't quite print out like a list &mdash; the actual list of keys is contained within `dict_keys()`. Note that it only contains the portion of the dictionary that are the keys; it does not include the value that comes after the colon.\n",
    "\n",
    "---\n",
    "\n",
    "### .values()\n",
    "\n",
    "The `.values()` command of a dictionary returns only its values. It does not return any keys.\n",
    "\n",
    "```python\n",
    "student = {'name': 'Andrew', 'program': 'Software Development', 'id': 110272}\n",
    "values = student.values()\n",
    "print(values)\n",
    "```\n",
    "\n",
    "**OUTPUT:**\n",
    "\n",
    "```python\n",
    "dict_values(['Andrew', 'Software Development', 110272])\n",
    "```\n",
    "\n",
    "With the `.values()` function, Python returns every value in the dictionary. \n",
    "\n",
    "---\n",
    "\n",
    "### .items()\n",
    "\n",
    "The `items()` command of a dictionary returns all of the key-value pairs as a list of tuples, where the first item of the tuple is the key, and the second item is the associated value.\n",
    "\n",
    "```python\n",
    "student = {'name': 'Andrew', 'program': 'Software Development', 'id': 110272}\n",
    "print(student.items())\n",
    "```\n",
    "\n",
    "**OUTPUT:**\n",
    "\n",
    "```python\n",
    "dict_items([('name', 'Andrew'), ('program', 'Software Development'), ('id', 110272)]\n",
    "```\n",
    "\n",
    "Using the `.items()` function has returned a list of key-value pairs in a tuple format.\n",
    "\n",
    "---\n",
    "\n",
    "### .get()\n",
    "\n",
    "To utilize the `.get()` operation of a dictionary, use the following syntax:\n",
    "\n",
    "`dict.get(key, default=None)`\n",
    "\n",
    "Above, the `key` parameter specifies from which key-value pair you want. You can optionally provide the `default` parameter to indicate the value you want if the key does not exist. If you exclude this parameter, by default it will return `None` as the value in the key cannot be found. However, you can also specify the default value that you want.\n",
    "\n",
    "Take a look at some examples:\n",
    "\n",
    "```python\n",
    "contact = {'name': 'Andrew', 'occupation': 'Software Engineer'}\n",
    "\n",
    "print(\"Name : \", contact.get('name'))\n",
    "print(\"Occupation : \", contact.get('occupation'))\n",
    "print(\"Salary : \", contact.get('salary'))\n",
    "print(\"Address : \", contact.get('address', \"I live in a box\"))\n",
    "```\n",
    "\n",
    "**OUTPUT:**\n",
    "\n",
    "```\n",
    "Name : Andrew\n",
    "Occupation : Software Engineer\n",
    "Salary : None\n",
    "Address : I live in a box\n",
    "```\n",
    "\n",
    "As you can see above, both the `name` and `occupation` keys exist so they are printed. However, both `salary` and `address` do not exist in the dictionary. For `salary`, no default value was specified, so it returns `None` as the value. For `address`, the default value was specified as \"__I live in a box__\" if the key is not found.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd9e3b8a-9224-447f-8cf7-5035cae86421",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 6 - Modifying a Dictionary<a class=\"anchor\" id=\"DS109L4_page_6\"></a>\n",
    "\n",
    "[Back to Top](#DS109L4_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a81e2098-28ef-4ff5-a155-afe824de4323",
   "metadata": {},
   "source": [
    "# Modifying a Dictionary\n",
    "\n",
    "Dictionaries are dynamic data structures and you can add new key-value pairs at any time as well as modify existing ones.\n",
    "\n",
    "---\n",
    "\n",
    "## Adding a New Key-Value Pair\n",
    "\n",
    "New key-value pairs can be added to a dictionary without using any special commands or keywords. The syntax for adding a new key-value pair is as follows:\n",
    "\n",
    "```python\n",
    "dictionary_name[key] = value\n",
    "```\n",
    "\n",
    "Above, `dictionary_name` is the variable representing the dictionary. By adding a key enclosed in square brackets `[]` and assigning a value, a new key-value pair is added.\n",
    "\n",
    "The example below adds a street key-value pair to the `address` dictionary:\n",
    "\n",
    "```python\n",
    "address = {'state': 'AZ', 'city': 'Scottsdale'}\n",
    "\n",
    "address['street'] = 'N 90th St'\n",
    "```\n",
    "\n",
    "**OUTPUT:**\n",
    "\n",
    "```python\n",
    "{'state': 'AZ', 'city': 'Scottsdale', 'street': 'N 90th St'}\n",
    "```\n",
    "\n",
    "Great! Now the address dictionary has the missing street! But wait, you want to use the full name of the state instead of the abbreviation. That requires modifying an existing item.\n",
    "\n",
    "----\n",
    "\n",
    "## Modifying an Existing Key-Value Pair\n",
    "\n",
    "Using the same syntax as above for adding a new key-value pair, if the key exists, it will change the value of the key-value pair:\n",
    "\n",
    "```python\n",
    "address = {'state': 'AZ', 'city': 'Scottsdale', 'street': 'N 90th St'}\n",
    "\n",
    "address['state'] = 'Arizona'\n",
    "```\n",
    "\n",
    "**OUTPUT:**\n",
    "\n",
    "```python\n",
    "{'state': 'Arizona', 'city': 'Scottsdale', 'street': 'N 90th'}\n",
    "```\n",
    "\n",
    "Above, since `state` already existed as a key, and dictionary keys _must_ be unique, the existing value was changed.\n",
    "\n",
    "---\n",
    "\n",
    "## Deleting an Existing Key-Value Pair\n",
    "\n",
    "Now that you know how to create and modify a dictionary, you'll also need to learn how to delete an item from a dictionary. Like with a `list`, deleting an item in a dictionary involves the use of the command `del`. Take a look at the example below where the `phone_number` key-value pair is deleted from the `contact` dictionary:\n",
    "\n",
    "```python\n",
    "# the contact dictionary\n",
    "contact = {\n",
    "    'first_name': 'Andrew',\n",
    "    'last_name': 'Stefanik',\n",
    "    'phone_number': '(123)-456-7890',\n",
    "    'street': 'N 90th St',\n",
    "    'city': 'Scottsdale',\n",
    "    'state': 'Arizona',\n",
    "    'zip_code': '85258'\n",
    "}\n",
    "\n",
    "# remove the `phone_number` from `contact`\n",
    "del contact['phone_number']\n",
    "\n",
    "print(contact)\n",
    "```\n",
    "\n",
    "**OUTPUT:**\n",
    "\n",
    "```python\n",
    "{'first_name': 'Andrew', 'last_name': 'Stefanik', 'street': 'N 90th St', 'city': 'Scottsdale', 'state': 'Arizona', 'zip_code': '85258'}\n",
    "```\n",
    "\n",
    "The `phone_number` key-value pair has been removed from the dictionary.\n",
    "\n",
    "<div class=\"panel panel-danger\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <h3 class=\"panel-title\">Caution!</h3>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "        <p>Be aware that the deleted key-value pair is removed permanently!</p>\n",
    "    </div>\n",
    "</div>\n",
    "\n",
    "If you do not specify the key when using the `del` command on a dictionary, it will delete the __entire__ dictionary:\n",
    "\n",
    "```python\n",
    "contact = {\n",
    "    'first_name': 'Andrew',\n",
    "    'last_name': 'Stefanik',\n",
    "}\n",
    "\n",
    "# deletes the entire dictionary\n",
    "del contact\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42cb7d8a-aced-42e5-ac24-32acf8c95473",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 7 - Dictionary Activity Part II<a class=\"anchor\" id=\"DS109L4_page_7\"></a>\n",
    "\n",
    "[Back to Top](#DS109L4_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf0debaf-5fae-4035-8e7d-ae62e62456cb",
   "metadata": {},
   "source": [
    "Given the `person` dictionary below:\n",
    "\n",
    "- Change the `city` from `Phoenix` to `Scottsdale`.\n",
    "\n",
    "- Add the missing `state` key-value pair. The value should be `AZ`.\n",
    "\n",
    "Do not change the definition of the `person` dictionary. Instead, modify the key-value pairs.\n",
    "\n",
    "```python\n",
    "person = {\n",
    "    'name': 'Donetta Jones',\n",
    "    'age': 25,\n",
    "    'city': 'Phoenix'\n",
    "}\n",
    "```\n",
    "\n",
    "\n",
    "person = {\n",
    "    'name': 'Donetta Jones',\n",
    "    'age': 25,\n",
    "    'city': 'Phoenix'\n",
    "}\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "8efd62b6-410e-4147-88f0-95fa3cbc7297",
   "metadata": {},
   "outputs": [],
   "source": [
    "person = {\n",
    "    'name': 'Donetta Jones',\n",
    "    'age': 25,\n",
    "    'city': 'Phoenix'\n",
    "}\n",
    "person['city'] = 'Scottsdale'\n",
    "person['state'] = 'AZ'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "dc3d4d07-a441-4365-96f1-f2120dce6e1b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'name': 'Donetta Jones', 'age': 25, 'city': 'Scottsdale', 'state': 'AZ'}"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "person"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7b3f800-0a14-4d13-8c32-390965c537ca",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 8 - Iterating Over a Dictionary<a class=\"anchor\" id=\"DS109L4_page_8\"></a>\n",
    "\n",
    "[Back to Top](#DS109L4_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4597e4b4-ce22-448d-843e-eab5ba74a9c4",
   "metadata": {},
   "source": [
    "# Iterating Over a Dictionary\n",
    "\n",
    "Like lists, you can iterate a dictionary. Remember, iteration is the act of repeating a process to generate a sequence of outcomes with the aim of approaching a desired goal, target, or result.\n",
    "\n",
    "You can iterate a dictionary with a `for` loop using the keys (`.keys()`), the values `.values()`, or the key-value pairs (`.items()`).\n",
    "\n",
    "---\n",
    "## Iterating the Key-Value Pairs\n",
    "\n",
    "Take a look at the example below that iterates the key-value pairs of the dictionary, printing out both the key and associated value of each:\n",
    "\n",
    "```python\n",
    "user = {'name': 'Andrew', 'email': 'andrew@email.com', 'username': 'andrewUser'}\n",
    "\n",
    "for key, value in user.items():\n",
    "    print(\"Key =\", key, \"\\tValue =\", value)\n",
    "```\n",
    "\n",
    "In the above code, take note of the `key, value` after the `for` keyword. Since the `items()` function returns the key-value __pairs__, the two variables separated by a comma represents both the key and the value of that particular item.\n",
    "\n",
    "Also, up to this point, you may not have seen `print()` used like it is above. Multiple items can be printed using one `print()` command by separating them with commas. The tab character `\\t` is being used to push the `\"Value = <value>\"` over to the right to line things up when printed to the console, as shown below:\n",
    "\n",
    "**OUTPUT:**\n",
    "\n",
    "```\n",
    "Key = name      Value = Andrew\n",
    "Key = email     Value = andrew@email.com\n",
    "Key = username  Value = andrewUser\n",
    "``"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36943bcd-7e16-4af1-97d3-c09e81ae5e99",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 9 - Iterating the Keys<a class=\"anchor\" id=\"DS109L4_page_9\"></a>\n",
    "\n",
    "[Back to Top](#DS109L4_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fdf2cdde-9447-49b5-8936-17d80f46b45e",
   "metadata": {},
   "source": [
    "# Iterating the Keys\n",
    "\n",
    "Take a look at the code below to see how you can iterate the dictionary's keys. As it loops through each key, it prints the key and its associated value (which must be accessed from the dictionary using the key):\n",
    "\n",
    "```python\n",
    "user = {'name': 'Andrew', 'email': 'andrew@email.com', 'username': 'andrewUser'}\n",
    "\n",
    "for key in user.keys():\n",
    "    print(\"Key =\", key, \"\\tValue =\", user[key])\n",
    "```\n",
    "\n",
    "**OUTPUT:**\n",
    "\n",
    "```\n",
    "Key = name      Value = Andrew\n",
    "Key = email     Value = andrew@email.com\n",
    "Key = username  Value = andrewUser\n",
    "```\n",
    "\n",
    "As you can see, you can iterate only the keys. This is actually the default behavior when using a `for` loop on a dictionary - iterating the keys. So, you can actually remove the `.keys()` portion and it will still work. Try it!\n",
    "\n",
    "```python\n",
    "for key in user:\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a0d02d5-04fa-4220-9637-d02c3b32dce5",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 10 - Iterating the Values<a class=\"anchor\" id=\"DS109L4_page_10\"></a>\n",
    "\n",
    "[Back to Top](#DS109L4_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "445b8ef7-8279-455e-a6eb-0159b96ae8dc",
   "metadata": {},
   "source": [
    "# Iterating the Values\n",
    "\n",
    "Finally, take a look at the example below that iterates over the values instead of the keys or key-value pairs:\n",
    "\n",
    "```python\n",
    "user = {'name': 'Andrew', 'email': 'andrew@email.com', 'username': 'andrewUser'}\n",
    "\n",
    "for value in user.values():\n",
    "    print(\"Value =\", value)\n",
    "```\n",
    "\n",
    "**OUTPUT:**\n",
    "\n",
    "```\n",
    "Value = Andrew\n",
    "Value = andrew@email.com\n",
    "Value = andrewUser\n",
    "```\n",
    "\n",
    "<div class=\"panel panel-danger\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <h3 class=\"panel-title\">Caution!</h3>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "        <p>When iterating the values, there is no simple way to get the _key_ associated with that value.</p>\n",
    "    </div>\n",
    "</div>\n",
    "\n",
    "Great! Now you've learned how to create and modify dictionaries in Python. So far, though, you've only seen dictionaries with key-value pairs whose values are strings and numbers. You can also set the value of a key-value pair to another dictionary!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "d999bc94-be3b-4a73-9f95-d1394083c73f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b14fad81f50740a99ce5a3a8be3c6b6e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': \"1. By default, iterating a dictionary loops over th…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "acd1692bcd594f70ac54786b6f0889ee",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '2. Creating an empty dictionary can be done utilizi…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "df0ecbe1dde34d2c8f950c62a1feb52a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '3. The only possible way to loop through the keys i…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8884c5dbb8fd4030a955540fffb54391",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': \"4. What is the proper syntax to print the value of …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "try:\n",
    "    display(L4P10Q1, L4P10Q2, L4P10Q3, L4P10Q4)\n",
    "except:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de9bbddb-a7bd-49db-83c9-b93b363751d4",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 11 - Nested Dictionaries<a class=\"anchor\" id=\"DS109L4_page_11\"></a>\n",
    "\n",
    "[Back to Top](#DS109L4_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08d741e4-c33f-4eef-a924-aa9e5f19c281",
   "metadata": {},
   "source": [
    "# Nested Dictionaries\n",
    "\n",
    "Undoubtedly, you will encounter scenarios where you will need to store a dictionary within another dictionary or within a list. So, below you'll be walked through two examples of a nested dictionary.\n",
    "\n",
    "---\n",
    "\n",
    "## A List of Dictionaries\n",
    "\n",
    "Below, you will find three dictionaries, where each represents a given contact that you would like to add to an address book:\n",
    "\n",
    "```python\n",
    "contact_0 = {'name': 'Andrew', 'phone': '(123)-222-2325'}\n",
    "contact_1 = {'name': 'Mike', 'phone': '(113)-452-9825'}\n",
    "contact_2 = {'name': 'David', 'phone': '(323)-933-2054'}\n",
    "```\n",
    "\n",
    "With the three contacts defined above, the next step is to store them inside of the `address_book` list:\n",
    "\n",
    "```python\n",
    "address_book = [contact_0, contact_1, contact_2]\n",
    "```\n",
    "\n",
    "Now, if you then iterate the list `address_book`, you can print the individual contact dictionaries:\n",
    "\n",
    "```python\n",
    "for contact in address_book:\n",
    "    print(contact)\n",
    "```\n",
    "\n",
    "**OUTPUT:**\n",
    "\n",
    "```\n",
    "{'name': 'Andrew', 'phone': '(123)-222-2325'}\n",
    "{'name': 'Mike', 'phone': '(113)-452-9825'}\n",
    "{'name': 'David', 'phone': '(323)-933-2054'}\n",
    "```\n",
    "\n",
    "As the loop is executed, each contact is printed on its own line.\n",
    "\n",
    "Awesome! It really is that easy to store dictionaries within a list. So, what about within another dictionary?\n",
    "\n",
    "---\n",
    "\n",
    "## A Dictionary with Dictionaries\n",
    "\n",
    "Below, you'll find a dictionary of a `contact`:\n",
    "\n",
    "```python\n",
    "contact = {'name': 'Andrew', 'phone': '(123)-222-2325'}\n",
    "```\n",
    "\n",
    "This contact is missing address information, so it will be added:\n",
    "\n",
    "```python\n",
    "address = {'street': '123 Tuple St', 'city': 'Scottsdale', 'state': 'AZ'}\n",
    "\n",
    "# add `address` dictionary to `contact` dictionary\n",
    "# with key 'address'\n",
    "contact['address'] = address\n",
    "```\n",
    "\n",
    "Finally, if you now print out the `contact` dictionary:\n",
    "\n",
    "```python\n",
    "print(contact)\n",
    "```\n",
    "\n",
    "**OUTPUT**:\n",
    "\n",
    "```\n",
    "{'name': 'Andrew', 'phone': '(123)-222-2325', 'address': {'street': '123 Tuple St', 'city': 'Scottsdale', 'state': 'AZ'}}\n",
    "```\n",
    "\n",
    "As you can see above, the `address` dictionary is nested in the `contact` dictionary with the key `address`.\n",
    "\n",
    "And that's it! You've learned quite a bit about dictionaries now. You've also seen how similar lists and dictionaries are, as well as how lists and dictionaries can be stored within other lists and dictionaries like any other data type.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "4a587a42-00d7-4950-9245-cfcb53db3bdf",
   "metadata": {},
   "outputs": [],
   "source": [
    "people = {\n",
    "    'person1': {\n",
    "        'name': 'Sally Sue',\n",
    "        'city': 'Phoenix'\n",
    "    },\n",
    "    'person2': {\n",
    "        'name': 'Billy Bob',\n",
    "        'city': 'Scottsdale'\n",
    "    },\n",
    "    'person3': {\n",
    "        'name': 'Rover',\n",
    "        'city': 'Zappa'\n",
    "    }\n",
    "}\n",
    "greetings = []\n",
    "for person in people.values():\n",
    "    greeting = \"Hello \" + person['name'] + \" from \" + person['city']\n",
    "    greetings.append(greeting)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "701c1bc0-c5b8-43a1-ae77-36b1f210935b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Hello Sally Sue from Phoenix',\n",
       " 'Hello Billy Bob from Scottsdale',\n",
       " 'Hello Rover from Zappa']"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "greetings"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff0631e0-6995-432a-9bac-141afbef4d69",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 12 - Dictionary Activity Part III<a class=\"anchor\" id=\"DS109L4_page_12\"></a>\n",
    "\n",
    "[Back to Top](#DS109L4_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cfe5d6c3-7b21-46a6-8e2c-07f6ecb1346d",
   "metadata": {},
   "source": [
    "Given the `people` dictionary in the `activity.py` file, iterate over each person and create a welcome message for each.\n",
    "\n",
    "Each item of the `people` dictionary is another dictionary with key-value pairs for `name` and `city`.\n",
    "\n",
    "Create a list named `greetings` that contains a greeting for each person in the dictionary. The format of the greeting should be:\n",
    "\n",
    "> \"Hello {NAME} from {CITY}\"\n",
    "\n",
    "where `{NAME}` and `{CITY}` are replaced with each person's corresponding dictionary values.\n",
    "\n",
    "<div class=\"panel panel-danger\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <h3 class=\"panel-title\">Caution!</h3>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "        <p>Do <b>not</b> use the <code>print()</code> function in your code when submitting! You can use it for testing, but be sure to remove it prior to clicking the submit button; otherwise, it will fail even with a correct solution.</p>\n",
    "    </div>\n",
    "</div>\n",
    "\n",
    "\n",
    "\n",
    "people = {\n",
    "    'person1': {\n",
    "        'name': 'Sally Sue',\n",
    "        'city': 'Phoenix'\n",
    "    },\n",
    "    'person2': {\n",
    "        'name': 'Billy Bob',\n",
    "        'city': 'Scottsdale'\n",
    "    },\n",
    "    'person3': {\n",
    "        'name': 'Rover',\n",
    "        'city': 'Zappa'\n",
    "    }\n",
    "}\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4244ce70-c4e4-4c50-9486-42a9143e5144",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 13 - Key Terms<a class=\"anchor\" id=\"DS109L4_page_13\"></a>\n",
    "\n",
    "[Back to Top](#DS109L4_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15a37f7f-4044-4ebd-b990-3e76f709befd",
   "metadata": {},
   "source": [
    "# Key Terms\n",
    "\n",
    "Below is a list and short description of the important keywords learned in this lesson. Please read through and go back and review any concepts you do not fully understand. Great Work!\n",
    "\n",
    "<table class=\"table table-striped\">\n",
    "    <tr>\n",
    "        <th>Keyword</th>\n",
    "        <th>Description</th>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>Key</td>\n",
    "        <td>Variable or bucket within which data is held.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>Value</td>\n",
    "        <td>Data stored in a key.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>Dictionary</td>\n",
    "        <td>Data structure made up of key-value pairs.</td>\n",
    "    </tr>\n",
    "</table>\n",
    "\n",
    "---\n",
    "\n",
    "## Key Python Code\n",
    "\n",
    "<table class=\"table table-striped\">\n",
    "    <tr>\n",
    "        <th>Keyword</th>\n",
    "        <th>Description</th>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>dict()</td>\n",
    "        <td>Create a dictionary out of variables.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>.keys()</td>\n",
    "        <td>Returns only the keys from a dictionary.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>.values()</td>\n",
    "        <td>Returns only values from a dictionary.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>.items()</td>\n",
    "        <td>Returns key-value pairs in tuples from a dictionary.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>.get()</td>\n",
    "        <td>Returns a value for a given key in a dictionary.</td>\n",
    "    </tr>\n",
    "</table>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5120c3d9-a73f-4fa2-8073-af577270cad3",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 14 - Lesson 4 Hands-On<a class=\"anchor\" id=\"DS109L4_page_14\"></a>\n",
    "\n",
    "[Back to Top](#DS109L4_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9752edf-05fa-4dd5-adcd-d98a6a873a5c",
   "metadata": {},
   "source": [
    "For your Lesson 4 Hands-On, you will be practicing your new skills with Python dictionaries. For this project, you will be creating a new directory, so please follow the below setup instructions. This Hands-On **will** be graded, so be sure you complete all requirements.\n",
    "\n",
    "<div class=\"panel panel-success\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <h3 class=\"panel-title\">Additional Info!</h3>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "        <p>Before beginning this hands-on, you may want to watch this <a href=\"https://vimeo.com/426779811\"> recorded live workshop </a> that goes over a similar example. </p>\n",
    "    </div>\n",
    "</div>\n",
    "\n",
    "---\n",
    "\n",
    "## Setup\n",
    "\n",
    "1. First, open up your command prompt/terminal\n",
    "2. Within your command prompt/terminal, run the following command:\n",
    "    ```text\n",
    "    cd desktop\n",
    "    ```\n",
    "3. Next, run the following:\n",
    "    ```text\n",
    "    cd python_course\n",
    "    ```\n",
    "4. Run the following to create a new directory for this project:\n",
    "    ```text\n",
    "    mkdir lesson_four_handson\n",
    "    ```\n",
    "5. Open up a new window in VSCode.\n",
    "6. Click on the \"Explorer\" button on the left-hand side of the VSCode window.\n",
    "7. Click the `Open Folder` button.\n",
    "8. Select the `lesson_four_handson` directory within the `python_course` folder on your Desktop. Click the `Open` button.\n",
    "10. Create a new file named `main.py` by one of the following three ways:\n",
    "    - To the right of __LESSON_FOUR_HANDSON__ in the EXPLORER is a button that looks like a piece of paper with a plus symbol in its top-left corner. If you hover your mouse over this button for a moment, a popup will appear indicating that this button will create a new file.\n",
    "    - Choose `File > New File` from the app's menu.\n",
    "    - Press `Control + N` in Windows or `Command + N` on a Mac (the plus means \"and at the same time\").\n",
    "\n",
    "Now you are ready to get started on your Lesson 4 Hands-On!\n",
    "\n",
    "---\n",
    "\n",
    "## Requirements\n",
    "\n",
    "This hands-on is broken into three parts. Please complete each part within your `main.py` file.\n",
    "\n",
    "---\n",
    "## Part 1\n",
    "\n",
    "1. Create two dictionaries to represent information about two pets. Each dictionary should contain the following information (different for each pet):\n",
    "    * Pet's Name (This should be the name of your dictionary)\n",
    "    * Type of Pet\n",
    "    * Color\n",
    "    * Nickname\n",
    "    * Owner's Name\n",
    "\n",
    "2. Iterate over each dictionary, printing each key-value pair on one line. The output should be similar to the below:\n",
    "\n",
    "    ```text\n",
    "    Type: Cat\n",
    "    Color: White and Orange\n",
    "    Nickname: Birchy\n",
    "    Owner: Kurt\n",
    "    Type: Cat\n",
    "    Color: Tortoise Shell\n",
    "    Nickname: Palnut\n",
    "    Owner: Olivia\n",
    "    ```\n",
    "\n",
    "---\n",
    "## Part 2\n",
    "\n",
    "1. Add three new dictionaries to your program.\n",
    "    - Each dictionary should represent a city around the world.\n",
    "2. Add the below dictionaries to your `main.py` file:\n",
    "    ```python\n",
    "    england = {'Capital': 'London'}\n",
    "    france = {'Capital': 'Paris'}\n",
    "    belgium = {'Capital': 'Brussels'}\n",
    "3. Given the above dictionaries, add the following information to each dictionary:\n",
    "    - Population\n",
    "        - The population of England is 53.01 million\n",
    "        - The population of France is 66.9 million\n",
    "        - The population of Belgium is 11.35 million\n",
    "    - Interesting Fact\n",
    "    - Top Language Spoken by Locals\n",
    "4. Once you have added the necessary information into the dictionaries, loop through each one and print out all key-value pairs.\n",
    "\n",
    "---\n",
    "\n",
    "## Part 3\n",
    "\n",
    "1. Add a dictionary to your program that replicates a user's pizza order. Name this dictionary `pizza_order` and it should contain the following:\n",
    "    * Customer's Name\n",
    "    * What size pizza they have ordered\n",
    "    * What type of crust\n",
    "    * What toppings they would like.\n",
    "        - Toppings should include at least three separate toppings\n",
    "2. Next, print out the customer's order:\n",
    "    * Thank them for their order using their name\n",
    "    * Print out what they're ordering\n",
    "    * Print out the list of toppings (minimum 3)\n",
    "3. Your output should looks similar to the following:\n",
    "    ```\n",
    "    Thank you for your order, Andrew\n",
    "    You have ordered a small, thin-crust pizza with the following toppings:\n",
    "    extra cheese, sausage, bacon\n",
    "    ```\n",
    "    - Use the `print()` and `get()` functions\n",
    "\n",
    "\n",
    "<div class=\"panel panel-danger\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <h3 class=\"panel-title\">Caution!</h3>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "        <p>Be sure to zip and submit your entire directory when finished!</p>\n",
    "    </div>\n",
    "</div>"
   ]
  }
 ],
 "metadata": {
  "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.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}