intro-to-python/07_dictionaries.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "07_dictionaries.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Ada-Developers-Academy/ada-build/blob/master/intro-to-python/07_dictionaries.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WuHUIsra76PZ",
        "colab_type": "text"
      },
      "source": [
        "**Dictionaries**\n",
        "\n",
        "_Ada Build - Intro to Python - Lesson 7_"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n3LcT44w8CCo",
        "colab_type": "text"
      },
      "source": [
        "# Learning Goals\n",
        "\n",
        "By the end of this lesson we will be able to:\n",
        "\n",
        "\n",
        "\n",
        "*   Understand the following vocabulary terms:\n",
        "  * Data structure\n",
        "  * Dictionary\n",
        "  * Key-value pair\n",
        "*   Understand how to use a dictionary including:\n",
        "  * Accessing data\n",
        "  * Adding data\n",
        "  * Iterating through a dictionary\n",
        "* Explain the differences between a list and a dictionary.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w14h_rm9OrsU",
        "colab_type": "text"
      },
      "source": [
        "# Notes"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0EhQyTHWAY2G",
        "colab_type": "text"
      },
      "source": [
        "## Copy to Drive\n",
        "\n",
        "Before you get started, remember to copy this Colab notebook to your Google Drive so that you can save your work."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lSi8dC4j8-Us",
        "colab_type": "text"
      },
      "source": [
        "## Overview\n",
        "\n",
        "A [Dictionary](https://docs.python.org/3/tutorial/datastructures.html#dictionaries) is another common Python collection type, with many similarities to a list. But while lists only let us store and retrieve values using integer indices, dictionaries allow us to use a wider variety of data types as their keys.\n",
        "\n",
        "We will explore what this means in more detail as we continue through this lesson, but basically, a Dictionary is useful when we need to organize data in a way that makes it easy to look up by a certain key, such as a person's name, or maybe a product code.\n",
        "\n",
        "Let's look at an example of a Dictionary with two keys, and a value associated with each of those two keys."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "X_AODEf7LlFr",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "{\n",
        "    \"key1\": \"key1AssociatedValue\",\n",
        "    \"key2\": \"key2AssociatedValue\",\n",
        "}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lorJaCmlL3qI",
        "colab_type": "text"
      },
      "source": [
        "## Creating Dictionaries\n",
        "\n",
        "We can assign a Dictionary to a variable in a similar way to other types of data.\n",
        "\n",
        "### Empty Dictionary\n",
        "\n",
        "We can initialize an empty `Dictionary` by using braces `{}` as shown below:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CxzTTSrrMMiE",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Create a dictionary\n",
        "my_dictionary = {}\n",
        "\n",
        "# Print statement so you can run and see the result\n",
        "print(my_dictionary)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dYBMQImKMRDF",
        "colab_type": "text"
      },
      "source": [
        "We know that this dictionary is empty because the Dictionary definition starts with a left brace `{`, ends with a right brace `}`, and there is nothing between those two symbols.\n",
        "\n",
        "We can also create a new instance of an empty Dictionary using the `dict` function in the Python standard library."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1x6J7GoQVeuN",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Create a dictionary\n",
        "my_dictionary = dict()\n",
        "\n",
        "# Print statement so you can run and see the result\n",
        "print(my_dictionary)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f8JCb1lpV0i3",
        "colab_type": "text"
      },
      "source": [
        "### Creating Dictionaries With Data\n",
        "\n",
        "The data in a dictionary consists of _key-value pairs_. Each key-value pair in a dictionary could be referred to as an _item_. The order of the key-value pairs is not guaranteed and hence, a dictionary is a collection of a unordered items.\n",
        "\n",
        "We can create a new dictionary populated with key-value pairs as follows:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ldL475GqWczG",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Create a dictionary called `my_cat` with values\n",
        "my_cat = {\n",
        "    \"name\": \"Samson\",\n",
        "    \"breed\": \"Alley-cat\",\n",
        "    \"age\": 8,\n",
        "}\n",
        "\n",
        "# Print statement so you can run and see the result\n",
        "print(my_cat)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "C4uiwJcBW1Xc",
        "colab_type": "text"
      },
      "source": [
        "We stored our new dictionary in a variable called `my_cat`. It has three key-value pairs. All the keys are string objects. The values associated with `\"name\"` and `\"breed\"` are also strings, `\"Samson\"` and `\"Alley-cat\"` respectively. The remaining key, `\"age\"` has a value of `8`, which is of type integer. In general, the value may be a more complex data structure, and may be of any data type.\n",
        "\n",
        "For each key-value pair, notice that we used a colon to separate the key from the value, and that we separated each pair with a comma. The trailing comma after the last key-value pair is optional."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vr8__M2B6HZ5",
        "colab_type": "text"
      },
      "source": [
        "### Exercise: Create a Dictionary\n",
        "\n",
        "Create a dictionary where the keys are each of the options in the _Rock, Paper, Scissors_ game and the values are the option it defeats.  For example with the key `\"rock\"` the value should be `\"scissors\"`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fASPnlE88K54",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# You create dictionary here\n",
        "rock_paper_scissors_defeats = {\n",
        "    \n",
        "}\n",
        "\n",
        "# Code to test the result\n",
        "assert rock_paper_scissors_defeats.get(\"rock\") == \"scissors\", \"rock should defeat scissors\"\n",
        "assert rock_paper_scissors_defeats.get(\"scissors\") == \"paper\", \"scissors should defeat paper\"\n",
        "assert rock_paper_scissors_defeats.get(\"paper\") == \"rock\", \"paper should defeat rock\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9_EzD8ySYciU",
        "colab_type": "text"
      },
      "source": [
        "## Accessing Values\n",
        "\n",
        "Once we have created a dictionary, we can access a value in that dictionary by using square brackets `[]` to specify a key. We can also use square brackets with a key to store a new value for that key.\n",
        "\n",
        "Let's take a look at some sample code to see how this works."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-0qT4Xa6YrSL",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "my_cat = {\n",
        "    \"name\": \"Samson\",\n",
        "    \"breed\": \"Alley-cat\",\n",
        "    \"age\": 8,\n",
        "}\n",
        "\n",
        "print(my_cat[\"name\"])  # \"Samson\"\n",
        "print(my_cat[\"age\"])   # 8\n",
        "print(f\"My cat is named {my_cat['name']} and is an {my_cat['breed']} and is {my_cat['age']} years old\")\n",
        "\n",
        "# Reassign breed to \"Maine Coon\"\n",
        "my_cat[\"breed\"] = \"Maine Coon\"\n",
        "print(my_cat[\"breed\"]) # Maine Coon\n",
        "print(f\"My cat now is named {my_cat['name']} and is an {my_cat['breed']} and is {my_cat['age']} years old\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o6J7ehgI9BRa",
        "colab_type": "text"
      },
      "source": [
        "### Exercise: Access Name of Student\n",
        "\n",
        "In the following code segment, print the grade of the student by accessing the value from the dictionary stored in the `student` variable."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "en2UjTg59V3I",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "student = {\n",
        "    \"name\": \"Ada Lovelace\",\n",
        "    \"id\": 12345,\n",
        "    \"age\": 147,\n",
        "    \"grade\": 11,\n",
        "}\n",
        "\n",
        "# Your code here\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ub1vCNp3eeZQ",
        "colab_type": "text"
      },
      "source": [
        "## What can be used as keys?\n",
        "\n",
        "Any type of object, can be used as a value but dictionaries can only use immutable types as keys. That means you can use an _int_, or _string_, as a key, but not a _list_, or other _dictionary_.\n",
        "\n",
        "The following is OK:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zA4KGnOIexj1",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Dictionary with an integer as a key\n",
        "my_dict = {1: 1}\n",
        "\n",
        "# Dictionary with an integer as a key and a list as a value\n",
        "my_dict2 = {1: []}\n",
        "\n",
        "# Dictionary with a string as a key and a string as a value\n",
        "my_dict3 = {\"name\": \"Ada Lovelace\"}\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5hCRfVzhfdYG",
        "colab_type": "text"
      },
      "source": [
        "But these are *NOT OK*. Uncomment each line and run the code to observe the resulting error."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fhXrhRArfjmN",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# broken_dict = { {1: 1}: \"value\"} # won't work - Gives a TypeError\n",
        "\n",
        "# broken_dict2 = { [1, 2, 3, 4, 5]: \"value\"} # won't work - Gives a TypeError\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4C1RRY2mgDgF",
        "colab_type": "text"
      },
      "source": [
        "For keys, you can use values which are immutable (cannot change), but you cannot use types which can mutate or change over the life of the program.  \n",
        "\n",
        "For example you can never change the value of `1` in a program, so it makes a good key, but a list or dictionary can have new values added or key-value pairs change over time."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "T3Tl6AfAbTW6",
        "colab_type": "text"
      },
      "source": [
        "## Using Built-In Methods and Functions\n",
        "\n",
        "Dictionaries are represented by the built-in Python type `dict`. Let's take a look at some of the important methods the `dict` type provides, as well as the use of an old friend in a new way."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NEH6wqf3mz3u",
        "colab_type": "text"
      },
      "source": [
        "### `.get(arguments)`\n",
        "\n",
        "When we give it a single argument, the `.get` method behaves similarly to the square bracket `[]` syntax for retrieving the value of a specified key."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uXjGqIlom_3r",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "my_cat = {\n",
        "    \"name\": \"Samson\",\n",
        "    \"breed\": \"Alley-cat\",\n",
        "    \"age\": 8,\n",
        "}\n",
        "\n",
        "print(my_cat.get(\"name\")) # Samson\n",
        "print(my_cat.get(\"age\"))  # 8\n",
        "print(my_cat.get(\"invalid-key\")) # None"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZTiulw4KnVyJ",
        "colab_type": "text"
      },
      "source": [
        "*Hmm... So should we use `.get` or square brackets `[]`?*\n",
        "\n",
        "The advantage of the `.get` method is that if the key does not exist, Python will return `None` as the default value, while with square brackets `[]`, Python will raise an error.\n",
        "\n",
        "We can also provide a second argument to `.get` if we need some value other than `None` as the default."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-0loep5JvjB3",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "my_cat = {\n",
        "    \"name\": \"Samson\",\n",
        "    \"breed\": \"Alley-cat\",\n",
        "    \"age\": 8,\n",
        "}\n",
        "\n",
        "print(my_cat.get(\"lives\", 9)) # Unless told otherwise we will assume 9 lives."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oU2TnPktJZOO",
        "colab_type": "text"
      },
      "source": [
        "### Exercise \n",
        "\n",
        "Uncomment the two lines below one by one to see the results."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wLbCApTqqOFn",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "my_cat = {\n",
        "    \"name\": \"Samson\",\n",
        "    \"breed\": \"Alley-cat\",\n",
        "    \"age\": 8,\n",
        "}\n",
        "\n",
        "print(my_cat.get(\"name\")) # \"Samson\"\n",
        "print(my_cat[\"name\"]) # \"Samson\"\n",
        "\n",
        "# print(my_cat.get(\"has_shots\")) # None\n",
        "# print(my_cat[\"has_shots\"]) # Raises a KeyError\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L1UACaBcmyiT",
        "colab_type": "text"
      },
      "source": [
        "### `.keys()`\n",
        "\n",
        "The `.keys` method returns a view object that can be used to iterate over the keys of the dictionary."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iXvZePawg0NN",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "my_cat = {\n",
        "    \"name\": \"Samson\",\n",
        "    \"breed\": \"Alley-cat\",\n",
        "    \"age\": 8,\n",
        "}\n",
        "\n",
        "my_cat_keys = my_cat.keys()\n",
        "\n",
        "print(my_cat_keys) # dict_keys(['name', 'breed', 'age'])\n",
        "\n",
        "my_cat[\"has_shots\"] = True\n",
        "print(my_cat_keys) # dict_keys(['name', 'breed', 'age', 'has_shots'])\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ea0iX8NGiZXj",
        "colab_type": "text"
      },
      "source": [
        "Notice that the variable `my_cat_keys ` updated automatically when we added `\"has_shots\"` to the dictionary. As previously stated, `.keys` returns a view of the dictionary's keys, not a list of them.\n",
        "\n",
        "```python\n",
        "print(my_cat_keys)\n",
        "# dict_keys(['name', 'breed', 'age']), NOT ['name', 'breed', 'age']\n",
        "```\n",
        "\n",
        "We can't access individual elements like a list.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mhysRbLWk6CO",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "my_cat = {\n",
        "    \"name\": \"Samson\",\n",
        "    \"breed\": \"Alley-cat\",\n",
        "    \"age\": 8,\n",
        "}\n",
        "\n",
        "my_cat_keys = my_cat.keys()\n",
        "# my_cat_keys[1] # Will cause a TypeError"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EN_NgQKUyb5k",
        "colab_type": "text"
      },
      "source": [
        "We can, however, iterate through the keys with a `for` loop."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "r2-1XKboybbB",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "my_cat = {\n",
        "    \"name\": \"Samson\",\n",
        "    \"breed\": \"Alley-cat\",\n",
        "    \"age\": 8,\n",
        "}\n",
        "\n",
        "my_cat_keys = my_cat.keys()\n",
        "for key in my_cat_keys:\n",
        "  print(key)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GiQdE_beyvQb",
        "colab_type": "text"
      },
      "source": [
        "Or convert the keys into a list using `list`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Cm6llbdCyyxx",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "my_cat = {\n",
        "    \"name\": \"Samson\",\n",
        "    \"breed\": \"Alley-cat\",\n",
        "    \"age\": 8,\n",
        "}\n",
        "\n",
        "my_cat_keys = my_cat.keys()\n",
        "list(my_cat_keys)[0]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wcC_jjPaz120",
        "colab_type": "text"
      },
      "source": [
        "Note that once we convert the view to a list, it will no longer be connected to the original dictionary."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JQ5k9B6Vz8E8",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "my_cat = {\n",
        "    \"name\": \"Samson\",\n",
        "    \"breed\": \"Alley-cat\",\n",
        "    \"age\": 8,\n",
        "}\n",
        "\n",
        "my_cat_keys = my_cat.keys()\n",
        "my_cat_keys_list = list(my_cat_keys)\n",
        "\n",
        "print(my_cat_keys) # dict_keys(['name', 'breed', 'age'])\n",
        "print(my_cat_keys_list) # ['name', 'breed', 'age']\n",
        "\n",
        "my_cat[\"has_shots\"] = True\n",
        "print(my_cat_keys) # dict_keys(['name', 'breed', 'age', 'has_shots'])\n",
        "print(my_cat_keys_list) # ['name', 'breed', 'age']"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qDTvZ0fNmCQg",
        "colab_type": "text"
      },
      "source": [
        "### `.values()`\n",
        "\n",
        "Similar in use to the `.keys` method, we can use the `.values` method to get a view object with which we can iterate over the values of the dictionary."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RqSnoV5JmYC_",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "my_cat = {\n",
        "    \"name\": \"Samson\",\n",
        "    \"breed\": \"Alley-cat\",\n",
        "    \"age\": 8,\n",
        "}\n",
        "\n",
        "my_cat_values = my_cat.values()\n",
        "\n",
        "print(my_cat_values) # dict_values(['Samson', 'Alley-cat', 8])\n",
        "\n",
        "my_cat[\"has_shots\"] = True\n",
        "print(my_cat_values) # dict_values(['Samson', 'Alley-cat', 8, True])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SpZBO8am1h3X",
        "colab_type": "text"
      },
      "source": [
        "### `len` function\n",
        "\n",
        "It's our old friend `len`. In addition to strings and lists, we can call `len` on dictionaries, where it returns the number of items in the dictionary."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eF-vT6Os1qcs",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "my_cat = {\n",
        "    \"name\": \"Samson\",\n",
        "    \"breed\": \"Alley-cat\",\n",
        "    \"age\": 8,\n",
        "}\n",
        "\n",
        "length = len(my_cat)\n",
        "\n",
        "print(length) # 3"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Vrfgav-sxUhb",
        "colab_type": "text"
      },
      "source": [
        "## Looping Over a Dictionary\n",
        "\n",
        "We can use a `for` loop to [iterate over a dictionary](https://docs.python.org/3/tutorial/datastructures.html?highlight=lists#looping-techniques), similarly to how we iterate over a list. But while list iteration updates the loop control variable with the list values, dictionary iteration will give us the keys.\n",
        "\n",
        "However unlike a list, a dictionary is not guarenteed to maintain the items in order. You might get lucky once in a while (especially for small dictionaries, and in [Python 3.7](https://docs.python.org/3/library/stdtypes.html#dict)) but don't rely on it!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fMhzT1igxhmW",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "my_cat = {\n",
        "    \"name\": \"Samson\",\n",
        "    \"breed\": \"Alley-cat\",\n",
        "    \"age\": 8,\n",
        "}\n",
        "\n",
        "for key in my_cat:\n",
        "    print(f\"The key is {key} and the value is {my_cat[key]}\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5R5_u8_TyWdO",
        "colab_type": "text"
      },
      "source": [
        "In the code above, the iterator variable `key` gets `\"name\"`, then `\"breed\"`, and lastly `\"age\"`. We can then use the updated `key` variable to access each corresponding value.\n",
        "\n",
        "It's common when iterating over a dictionary that we'll want both the key and the value at the same time. Python does provide ways to accomplish this, though we won't discuss them here. The link in the previous section has an example that the curious can review."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rmEfJLKj-PWS",
        "colab_type": "text"
      },
      "source": [
        "#### Exercise: Printing out a dictionary\n",
        "\n",
        "The following code block provides a dictionary associating each rock-paper-scissors throw with the choice it defeats. Let's use a loop to print out the game rules with the output looking something like:\n",
        "\n",
        "```python\n",
        "rock defeats scissors\n",
        "scissors defeats paper\n",
        "paper defeats rock\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "j6dM1DUz-zqD",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "rock_paper_scissors_defeats = {\n",
        "    \"rock\": \"scissors\",\n",
        "    \"scissors\": \"paper\",\n",
        "    \"paper\": \"rock\",\n",
        "}\n",
        "\n",
        "# Your code here"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0pdTXOl0yzW8",
        "colab_type": "text"
      },
      "source": [
        "## Removing Values From A Dictionary\n",
        "\n",
        "We can remove a key-value pair from a dictionary using the `.pop` method.\n",
        "\n",
        "The `.pop` dictionary method is also able to remove a dictionary key, and returns the value that was stored at that key prior to its removal.\n",
        "\n",
        "The code block below shows how to use each approach."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lpCl_O_L03SE",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 87
        },
        "outputId": "f95d5ada-8b56-4652-de90-9eb05f2d5fc7"
      },
      "source": [
        "my_cat = {\n",
        "    \"name\": \"Samson\",\n",
        "    \"breed\": \"Alley-cat\",\n",
        "    \"age\": 8,\n",
        "}\n",
        "\n",
        "breed = my_cat.pop(\"breed\") # remove the breed, return the value.\n",
        "print(my_cat)       # {'age': 8}\n",
        "print(breed)        # Alley-cat"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'name': 'Samson', 'breed': 'Alley-cat', 'age': 8}\n",
            "{'breed': 'Alley-cat', 'age': 8}\n",
            "{'age': 8}\n",
            "Alley-cat\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j9wpoTGVjufa",
        "colab_type": "text"
      },
      "source": [
        "## Dictionaries vs Lists\n",
        "\n",
        "Python dictionaries and lists both:\n",
        "\n",
        "* Store collections of data.\n",
        "* Allow access to individual elements via a key or index.\n",
        "* Allow the collection to be iterated through.\n",
        "\n",
        "On the other hand, lists differ in that they:\n",
        "\n",
        "* Maintain elements in ordinal iteration order, while dictionaries do not.\n",
        "* Use integer indices to access specific elements, while a dictionary can use any immutable data as a key.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y3KFYJyYkkoG",
        "colab_type": "text"
      },
      "source": [
        "## Vocabulary\n",
        "\n",
        "*Data Structure*\n",
        "\n",
        "- A data structure is a collection of data organized according to some principles, along with the operations that can be applied to that data such that the organizational principles are preserved.\n",
        "\n",
        "*Key-value pair*\n",
        "\n",
        "- A set of two linked data items. In a dictionary, the key is used to retrieve its linked value, similar to how a word in an English dictionary can be used to look up a definition.\n",
        "\n",
        "*Dictionary*\n",
        "\n",
        "- A data structure which stores a collection of key-value pairs, with each key-value pair mapping the key to its associated value."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bZnXDXIw2iX7",
        "colab_type": "text"
      },
      "source": [
        "## Nested Dictionaries\n",
        "\n",
        "We can store dictionaries inside lists, or even inside other dictionaries, in order to represent more complex relationships within our data. We refer to dictionaries stored inside another data structure as nested dictionaries."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EnG4Z86K5DJ_",
        "colab_type": "text"
      },
      "source": [
        "### List of dictionaries\n",
        "\n",
        "Lists are collections of elements of any data type, so it follows that we can make a list that is a collection of dictionaries."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gIotOXsd4ZJk",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# List of Dictionaries\n",
        "pet_list = [\n",
        "    {\n",
        "        \"name\": \"Samson\",\n",
        "        \"breed\": \"Alley-cat\",\n",
        "        \"age\": 8,\n",
        "    },\n",
        "    {\n",
        "        \"name\": \"Kylo\",\n",
        "        \"breed\": \"Siamese\",\n",
        "        \"age\": 12,\n",
        "    },\n",
        "    {\n",
        "        \"name\": \"Fix\",\n",
        "        \"breed\": \"Munchkin\",\n",
        "        \"age\": 2,\n",
        "    },\n",
        "]\n",
        "\n",
        "print(pet_list)\n",
        "print(pet_list[2])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "etwQZCKJ5NRK",
        "colab_type": "text"
      },
      "source": [
        "### Dictionary of Dictionaries\n",
        "\n",
        "We can make a dictionary where the values in the key-value pairs are themselves dictionaries. Remember that the keys cannot be dictionaries, since they are not immutable types."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SQeVYpmP5ZBy",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "pet_dict = {\n",
        "    \"Simon\": {\n",
        "        \"name\": \"Samson\",\n",
        "        \"breed\": \"Alley-cat\",\n",
        "        \"age\": 8,     \n",
        "    },\n",
        "    \"Devin\": {\n",
        "        \"name\": \"Peter\",\n",
        "        \"breed\": \"Sphynx\",\n",
        "        \"age\": 12,        \n",
        "    },            \n",
        "}\n",
        "\n",
        "\n",
        "print(pet_dict[\"Simon\"])\n",
        "\n",
        "# print the name of Simon's pet\n",
        "print(pet_dict[\"Simon\"][\"name\"])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "liOxySakOyHu",
        "colab_type": "text"
      },
      "source": [
        "# Practice Problems\n",
        "\n",
        "Read the code in each section, then write exactly what the code prints out. Check your answers in the code cell below.\n",
        "\n",
        "Each problem stands alone. Variables from previous problems do not exist.\n",
        "\n",
        "\n",
        "```python\n",
        "# example\n",
        "x = 5\n",
        "y = 6\n",
        "print(x+y)\n",
        "# => 11\n",
        "```\n",
        "\n",
        "```python\n",
        "# problem 1\n",
        "person = {\n",
        "    \"first_name\": \"ada\",\n",
        "    \"last_name\": \"lovelace\",\n",
        "    \"nickname\": \"adie\"\n",
        "}\n",
        "\n",
        "print(len(person))\n",
        "print(person[\"last_name\"])\n",
        "```\n",
        "\n",
        "```python\n",
        "# problem 2\n",
        "animals = {\n",
        "    \"dog\": \"canine\",\n",
        "    \"cat\": \"feline\"\n",
        "}\n",
        "\n",
        "animals[\"cat\"] = \"feline\"\n",
        "print(animals[\"dog\"])\n",
        "print(animals[\"donkey\"])\n",
        "```\n",
        "\n",
        "\n",
        "```python\n",
        "# problem 3\n",
        "workout_summary = {\n",
        "    \"squats\": 99,\n",
        "    \"lunges\": 98,\n",
        "    \"yoga\": True\n",
        "}\n",
        "\n",
        "workout_summary[\"lunges\"] = 101\n",
        "print(workout_summary[\"lunges\"])\n",
        "```\n",
        "\n",
        "```python\n",
        "# problem 4\n",
        "menu = {}\n",
        "menu[\"ramen\"] = \"garlic tonkotsu\"\n",
        "menu[\"burger\"] = \"bleu sun\"\n",
        "menu[\"tea\"] = \"green\"\n",
        "print(len(menu))\n",
        "print(menu[\"burger\"])\n",
        "print(menu[\"tater_tots\"])\n",
        "```\n",
        "\n",
        "\n",
        "```python\n",
        "# problem 5\n",
        "human_being = {\n",
        "    \"species\": \"Sapiens\",\n",
        "    \"genus\": \"Homo\",\n",
        "    \"tribe\": \"Hominini\",\n",
        "    \"meaning\": \"wise man\"\n",
        "}\n",
        "\n",
        "print(len(human_being))\n",
        "print(f'The only living species of genus {human_being[\"genus\"]} are {human_being[\"species\"]}.')\n",
        "print(len(human_being[\"meaning\"]))\n",
        "```\n",
        "\n",
        "```python\n",
        "# problem 6\n",
        "oatmeal_raisin = {\n",
        "    \"gluten_free\": False,\n",
        "    \"dairy_free\": True,\n",
        "    \"non_gmo\": True,\n",
        "    \"vegan\": True,\n",
        "    \"allergens\": \"nuts\"\n",
        "}\n",
        "\n",
        "print(len(oatmeal_raisin))\n",
        "\n",
        "if oatmeal_raisin[\"dairy_free\"]:\n",
        "    print(\"Oatmeal raisin cookies are dairy free.\")\n",
        "\n",
        "oatmeal_raisin[\"allergens\"] += \", soy\"\n",
        "print(oatmeal_raisin[\"allergens\"])\n",
        "\n",
        "if(not(oatmeal_raisin[\"gluten_free\"]) or not(oatmeal_raisin[\"vegan\"])):\n",
        "    print(\"The oatmeal raisin cookie is either not gluten free or not vegan.\")\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VBLhw6Y3Klgd",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HyAwh9tBPTgj",
        "colab_type": "text"
      },
      "source": [
        "# Project - Account Generator - v2\n",
        "\n",
        "Now that we know about dictionaries, let's modify our student account generator code to utilize lists with nested dictionaries. Since each student has three pieces of data (names, id numbers, and email_addresses), we will use a dictionary to store these three pieces of data for each student.\n",
        "\n",
        "This is a better solution because it keeps each student record together instead of having three separate lists with the student data. When a new student record is created, only one dictionary needs to be added to the list rather than three pieces of data to individual lists."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hJX70aLqcOSx",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "student_data = [\n",
        "    {\n",
        "        \"name\": \"Mary Jane\",\n",
        "        \"ID\": 1000000,\n",
        "        \"email\": \"mjane@adadevelopersacademy.org\"\n",
        "    },\n",
        "    {\n",
        "        \"name\": \"Jones Smith\",\n",
        "        \"ID\": 1000001,\n",
        "        \"email\": \"jsmith@adadevelopersacademy.org\"\n",
        "    }\n",
        "]\n",
        "\n",
        "# Retrieve the data from the list of dictionaries\n",
        "student_data[0][\"name\"]\n",
        "# => \"Mary Jane\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S7JPtxjKc9O5",
        "colab_type": "text"
      },
      "source": [
        "## Complete the following steps:\n",
        "\n",
        "- Utilize a single list variable to store all student information, instead of three individual lists.\n",
        "- This list will contain many dictionaries.\n",
        "- Utilize a single loop to drive the dictionary population (you may have nested loops inside this loop for other functionality):\n",
        "- Read each student's name from a separate list or by prompting the user for input.\n",
        "- Generate a random student ID.\n",
        "- Generate the student's email address from their name and student ID.\n",
        "- Update the printing functionality to utilize this new dictionary variable to print out the student roster."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qFfG11yDiHbz",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# your code goes here"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LtHunXiLiH_6",
        "colab_type": "text"
      },
      "source": [
        "[A solution is linked here](https://repl.it/join/ynlsprrs-beccaelenzil)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eqKhoYH98biy",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "\n",
        "## MadLib Assignment\n",
        "\n",
        "- Write a MadLib program.\n",
        "- First play a few on [eduplace](https://www.eduplace.com/tales/) to become familiar with the game.\n",
        "- Create a MadLib program that accepts input from the user and outputs a completed MadLib.\n",
        "- Use up to ten different parts of speech in order to fill in your MadLib.\n",
        "- Output should consist of a paragraph that has the user’s input substituted into the MadLib. We have provided an example run, but your MadLib program should be unique to you.\n",
        "\n",
        "```\n",
        "Welcome to my MadLib program. Please enter some information below:\n",
        "\n",
        "name: Starr\n",
        "adjective: huge\n",
        "noun: tablecloth\n",
        "adjective: dry\n",
        "food (plural): tacos\n",
        "noun (plural): packs\n",
        "verb ending in -ed: ended\n",
        "noun: jellyfish\n",
        "\n",
        "HERE'S YOUR MADLIB.......\n",
        "\n",
        "Come on over to Starr’s Pizza Parlor where you can enjoy your favorite huge-dish pizza`s.\n",
        "You can try our famous tablecloth-lovers pizza,\n",
        "or select from our list of dry toppings,\n",
        "including delicious tacos, packs, and many more.\n",
        "Our crusts are hand-ended and basted in jellyfish to make\n",
        "them seem more Hand-made.\n",
        "```\n",
        "\n",
        "- Your code should use comments throughout to explain your implementation.\n",
        "- Reuse at least one word, and ask for at least 1 number.\n",
        "- You can use a list and/or dictionary to store the parts of speech and user input.\n",
        "- Explore Python's built in methods for [string](https://docs.python.org/3/library/string.html?highlight=strings) like `capitalize`, `upper`, and `lower`.\n",
        "- Recall from the functions lesson that we prompt the user for input with the built-in [input](https://docs.python.org/3/library/functions.html#input) function.\n",
        "\n",
        "<small>MAD LIBS&reg; is a registered trademark of Penguin Group (USA) Inc.</small>\n",
        "\n",
        "[Our implementation is linked here](https://repl.it/join/sdlpgwoa-beccaelenzil)\n",
        "Show less"
      ]
    }
  ]
}