09_Understanding_Dictionaries_in_Python_3.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Understanding Dictionaries in Python 3.ipynb",
      "provenance": [],
      "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/brainhack-uiowa/python-novice-inflammation-colab/blob/master/09_Understanding_Dictionaries_in_Python_3.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rzXji72GNG1F",
        "colab_type": "text"
      },
      "source": [
        "Original lesson at: https://www.digitalocean.com/community/tutorials/understanding-dictionaries-in-python-3"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "83D4cYLjLNZ5",
        "colab_type": "text"
      },
      "source": [
        "#Understanding Dictionaries in Python 3\n",
        "By Lisa Tagliaferri\n",
        "\n",
        "UpdatedNovember 21, 2017 236.5k views\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "07CXXIxDLghW",
        "colab_type": "text"
      },
      "source": [
        "## Introduction\n",
        "The **dictionary** is Python’s built-in **mapping** type. Dictionaries map **keys** to **values** and these key-value pairs provide a useful way to store data in Python.\n",
        "\n",
        "Typically used to hold data that are related, such as the information contained in an ID or a user profile, dictionaries are constructed with curly braces on either side { }.\n",
        "\n",
        "A dictionary looks like this:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "T9z6lbhzNPlC",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "sammy = {'username': 'sammy-shark', 'online': True, 'followers': 987}"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vW2PRWN9NRDi",
        "colab_type": "text"
      },
      "source": [
        "In addition to the curly braces, there are also colons (:) throughout the dictionary.\n",
        "\n",
        "The words to the left of the colons are the keys. Keys can be made up of any immutable data type. The keys in the dictionary above are:\n",
        "\n",
        "- `'username'`\n",
        "- `'online'`\n",
        "- `'followers'`\n",
        "\n",
        "Each of the keys in the above example are string values.\n",
        "\n",
        "The words to the right of the colons are the values. Values can be comprised of any data type. The values in the dictionary above are:\n",
        "\n",
        "- `'sammy-shark'`\n",
        "- `True`\n",
        "- `987`\n",
        "\n",
        "Each of these values is either a string, Boolean, or integer.\n",
        "\n",
        "Let’s print out the dictionary `sammy`:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fBDXGYegNz8Z",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "04154bc7-723f-41c2-8860-70106c958b6d"
      },
      "source": [
        "print(sammy)"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'username': 'sammy-shark', 'online': True, 'followers': 987}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0CVM-rhmNw2D",
        "colab_type": "text"
      },
      "source": [
        "Looking at the output, the order of the key-value pairs may have shifted. In Python version 3.5 and earlier, the dictionary data type is unordered. However, in Python version 3.6 and later, the dictionary data type remains ordered. Regardless of whether the dictionary is ordered or not, the key-value pairs will remain intact, enabling us to access data based on their relational meaning. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SDO31zWlcn9b",
        "colab_type": "text"
      },
      "source": [
        "##Accessing Dictionary Elements\n",
        "\n",
        "We can call the values of a dictionary by referencing the related keys.\n",
        "\n",
        "###Accessing Data Items with Keys\n",
        "\n",
        "Because dictionaries offer key-value pairs for storing data, they can be important elements in your Python program.\n",
        "\n",
        "If we want to isolate Sammy’s username, we can do so by calling `sammy['username']`. Let’s print that out:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wQ2s9WfZct7k",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "4be677b8-3142-413a-bb6f-8ae37569b653"
      },
      "source": [
        "print(sammy['username'])"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "sammy-shark\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a2iZ6VSUcz3k",
        "colab_type": "text"
      },
      "source": [
        "Dictionaries behave like a database in that instead of calling an integer to get a particular index value as you would with a list, you assign a value to a key and can call that key to get its related value.\n",
        "\n",
        "By invoking the key `'username'` we receive the value of that key, which is `'sammy-shark'`.\n",
        "\n",
        "The remaining values in the `sammy` dictionary can similarly be called using the same format:\n",
        "```\n",
        "sammy['followers']\n",
        "# Returns 987\n",
        "\n",
        "sammy['online']\n",
        "# Returns True\n",
        "```\n",
        "By making use of dictionaries’ key-value pairs, we can reference keys to retrieve values."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y9ZLVH0adBeK",
        "colab_type": "text"
      },
      "source": [
        "## Using Methods to Access Elements\n",
        "\n",
        "In addition to using keys to access values, we can also work with some built-in methods:\n",
        "\n",
        "- `dict.keys()` isolates keys\n",
        "- `dict.values()` isolates values\n",
        "- `dict.items()` returns items in a list format of (key, value) tuple pairs\n",
        "\n",
        "To return the keys, we would use the `dict.keys()` method. In our example, that would use the variable name and be `sammy.keys()`. Let’s pass that to a `print()` method and look at the output:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6l1TzrGMdS1z",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "79ccec16-ea5e-4195-cdf7-a881c20a9bfe"
      },
      "source": [
        "print(sammy.keys())"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "dict_keys(['username', 'online', 'followers'])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZbcMnENWdXsw",
        "colab_type": "text"
      },
      "source": [
        "We receive output that places the keys within an iterable view object of the `dict_keys` class. The keys are then printed within a list format.\n",
        "\n",
        "This method can be used to query across dictionaries. For example, we can take a look at the common keys shared between two dictionary data structures:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eaRGtEwYdcKu",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "cdc12007-cda6-4256-b73a-af3a3c202b88"
      },
      "source": [
        "sammy = {'username': 'sammy-shark', 'online': True, 'followers': 987}\n",
        "jesse = {'username': 'JOctopus', 'online': False, 'points': 723}\n",
        "\n",
        "for common_key in sammy.keys() & jesse.keys():\n",
        "    print(sammy[common_key], jesse[common_key])"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "sammy-shark JOctopus\n",
            "True False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RUFwQrqgdk7G",
        "colab_type": "text"
      },
      "source": [
        "The dictionary `sammy` and the dictionary `jesse` are each a user profile dictionary.\n",
        "\n",
        "Their profiles have different keys, however, because Sammy has a social profile with associated followers, and Jesse has a gaming profile with associated points. The 2 keys they have in common are username and online status, which we can find when we run this small program:\n",
        "\n",
        "```\n",
        "sammy-shark JOctopus\n",
        "True False\n",
        "```\n",
        "\n",
        "We could certainly improve on the program to make the output more user-readable, but this illustrates that `dict.keys()` can be used to check across various dictionaries to see what they share in common or not. This is especially useful for large dictionaries.\n",
        "\n",
        "Similarly, we can use the `dict.values()` method to query the values in the `sammy` dictionary, which would be constructed as `sammy.values()`. Let’s print those out:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VCYRA3z2d5iD",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "a95a6c3f-04b3-4df2-9374-41b0251f45e5"
      },
      "source": [
        "sammy = {'username': 'sammy-shark', 'online': True, 'followers': 987}\n",
        "\n",
        "print(sammy.values())"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "dict_values(['sammy-shark', True, 987])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a4nftC0_d8lj",
        "colab_type": "text"
      },
      "source": [
        "Both the methods `keys()` and `values()` return unsorted lists of the keys and values present in the `sammy` dictionary with the view objects of `dict_keys` and `dict_values` respectively.\n",
        "\n",
        "If we are interested in all of the items in a dictionary, we can access them with the `items()` method:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7tGeaNGPeD5F",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "c621dc1b-0eac-43c5-b7d1-1c7350b9b894"
      },
      "source": [
        "print(sammy.items())"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "dict_items([('username', 'sammy-shark'), ('online', True), ('followers', 987)])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I5L4EaKpeIR8",
        "colab_type": "text"
      },
      "source": [
        "The returned format of this is a list made up of `(key, value)` tuple pairs with the `dict_items` view object.\n",
        "\n",
        "We can iterate over the returned list format with a `for` loop. For example, we can print out each of the keys and values of a given dictionary, and then make it more human-readable by adding a string:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WN5dikBneTGG",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "6a443a9d-30fd-415f-9051-2dc1f5a4d2b3"
      },
      "source": [
        "for key, value in sammy.items():\n",
        "    print(key, 'is the key for the value', value)"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "username is the key for the value sammy-shark\n",
            "online is the key for the value True\n",
            "followers is the key for the value 987\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SyuIZcN8eZHH",
        "colab_type": "text"
      },
      "source": [
        "The `for` loop above iterated over the items within the `sammy` dictionary and printed out the keys and values line by line, with information to make it easier to understand by humans.\n",
        "\n",
        "We can use built-in methods to access items, values, and keys from dictionary data structures."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QfcjLx24eeuj",
        "colab_type": "text"
      },
      "source": [
        "## Modifying Dictionaries\n",
        "\n",
        "Dictionaries are a mutable data structure, so you are able to modify them. In this section, we’ll go over adding and deleting dictionary elements.\n",
        "\n",
        "### Adding and Changing Dictionary Elements\n",
        "\n",
        "Without using a method or function, you can add key-value pairs to dictionaries by using the following syntax:\n",
        "```\n",
        "dict[key] = value\n",
        "```\n",
        "\n",
        "We’ll look at how this works in practice by adding a key-value pair to a dictionary called `usernames`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UHTnxTuUevvD",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "c337bd15-c2b1-4c56-83e6-603aa1669201"
      },
      "source": [
        "usernames = {'Sammy': 'sammy-shark', 'Jamie': 'mantisshrimp54'}\n",
        "\n",
        "usernames['Drew'] = 'squidly'\n",
        "\n",
        "print(usernames)"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'Sammy': 'sammy-shark', 'Jamie': 'mantisshrimp54', 'Drew': 'squidly'}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cmmn6Awte9WK",
        "colab_type": "text"
      },
      "source": [
        "We see now that the dictionary has been updated with the `'Drew': 'squidly'` key-value pair. Because dictionaries may be unordered, this pair may occur anywhere in the dictionary output. If we use the `usernames` dictionary later in our program file, it will include the additional key-value pair.\n",
        "\n",
        "Additionally, this syntax can be used for modifying the value assigned to a key. In this case, we’ll reference an existing key and pass a different value to it.\n",
        "\n",
        "Let’s consider a dictionary `drew` that is one of the users on a given network. We’ll say that this user got a bump in `followers` today, so we need to update the integer value passed to the 'followers' key. We’ll use the `print()` function to check that the dictionary was modified."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "05JCtxstfLzH",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "fd63fea9-c64a-48f8-d4b3-731b0b55d86a"
      },
      "source": [
        "drew = {'username': 'squidly', 'online': True, 'followers': 305}\n",
        "\n",
        "drew['followers'] = 342\n",
        "\n",
        "print(drew)"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'username': 'squidly', 'online': True, 'followers': 342}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yUV4pRLp8Bq4",
        "colab_type": "text"
      },
      "source": [
        "In the output, we see that the number of followers jumped from the integer value of `305` to `342`.\n",
        "\n",
        "We can use this method for adding key-value pairs to dictionaries with user-input. Let’s write a quick program, `usernames.py` that runs on the command line and allows input from the user to add more names and associated usernames:\n",
        "\n",
        "**Note**: type \"exit\" to stop the program and move on with the lesson"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0t0UJ4EW8GF7",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 136
        },
        "outputId": "bee7cabe-0739-42f9-8111-05d095315244"
      },
      "source": [
        "# Define original dictionary\n",
        "usernames = {'Sammy': 'sammy-shark', 'Jamie': 'mantisshrimp54'}\n",
        "\n",
        "# Set up while loop to iterate\n",
        "while True:\n",
        "\n",
        "    # Request user to enter a name\n",
        "    print('Enter a name:')\n",
        "\n",
        "    # Assign to name variable\n",
        "    name = input()\n",
        "\n",
        "    # Check whether name is in the dictionary and print feedback\n",
        "    if name in usernames:\n",
        "        print(usernames[name] + ' is the username of ' + name)\n",
        "\n",
        "    # exit the infinite while loop to stop the program\n",
        "    elif name == \"exit\":\n",
        "      break\n",
        "\n",
        "    # If the name is not in the dictionary...\n",
        "    else:\n",
        "\n",
        "        # Provide feedback\n",
        "        print('I don\\'t have ' + name + '\\'s username, what is it?')\n",
        "\n",
        "        # Take in a new username for the associated name\n",
        "        username = input()\n",
        "\n",
        "        # Assign username value to name key\n",
        "        usernames[name] = username\n",
        "\n",
        "        # Print feedback that the data was updated\n",
        "        print('Data updated.')"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Enter a name:\n",
            "sammy\n",
            "I don't have sammy's username, what is it?\n",
            "sammy-shark\n",
            "Data updated.\n",
            "Enter a name:\n",
            "exit\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jqBo9N7_8RwI",
        "colab_type": "text"
      },
      "source": [
        "This shows how you can modify dictionaries interactively.\n",
        "\n",
        "We can also add and modify dictionaries by using the `dict.update()` method. This varies from the `append()` method available in lists.\n",
        "\n",
        "In the `jesse` dictionary below, let’s add the key `'followers'` and give it an integer value with `jesse.update()`. Following that, let’s `print()` the updated dictionary."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cTk6XW7089sp",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "3ecce670-fdbe-4606-d79c-fac798bd1363"
      },
      "source": [
        "jesse = {'username': 'JOctopus', 'online': False, 'points': 723}\n",
        "\n",
        "jesse.update({'followers': 481})\n",
        "\n",
        "print(jesse)"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'username': 'JOctopus', 'online': False, 'points': 723, 'followers': 481}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xImUgsEv85n9",
        "colab_type": "text"
      },
      "source": [
        "From the output, we can see that we successfully added the `'followers': 481` key-value pair to the dictionary `jesse`.\n",
        "\n",
        "We can also use the `dict.update()` method to modify an existing key-value pair by replacing a given value for a specific key.\n",
        "\n",
        "Let’s change the online status of Sammy from `True` to `False` in the `sammy` dictionary:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cU_R-NTg9wbk",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "144286e7-3bda-4c9e-fc4c-f5b053ab67fd"
      },
      "source": [
        "sammy = {'username': 'sammy-shark', 'online': True, 'followers': 987}\n",
        "\n",
        "sammy.update({'online': False})\n",
        "\n",
        "print(sammy)"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'username': 'sammy-shark', 'online': False, 'followers': 987}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HCxRDXhf91nj",
        "colab_type": "text"
      },
      "source": [
        "The line `sammy.update({'online': False})` references the existing key `'online'` and modifies its Boolean value from `True` to `False`. When we call to `print()` the dictionary, we see the update take place in the output.\n",
        "\n",
        "To add items to dictionaries or modify values, we can use wither the `dict[key] = value` syntax or the method `dict.update()`."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uOavzR4C-Ft1",
        "colab_type": "text"
      },
      "source": [
        "### Deleting Dictionary Elements\n",
        "\n",
        "Just as you can add key-value pairs and change values within the dictionary data type, you can also delete items within a dictionary.\n",
        "\n",
        "To remove a key-value pair from a dictionary, we’ll use the following syntax:\n",
        "```\n",
        "del dict[key]\n",
        "```\n",
        "Let’s take the `jesse` dictionary that represents one of the users. We’ll say that Jesse is no longer using the online platform for playing games, so we’ll remove the item associated with the `'points'` key. Then, we’ll print the dictionary out to confirm that the item was deleted:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OWt7fIBG-P9K",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "770cdb71-1863-42e1-c92a-eaa53e4c505e"
      },
      "source": [
        "jesse = {'username': 'JOctopus', 'online': False, 'points': 723, 'followers': 481}\n",
        "\n",
        "del jesse['points']\n",
        "\n",
        "print(jesse)"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'username': 'JOctopus', 'online': False, 'followers': 481}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OCKyxOx4-Shq",
        "colab_type": "text"
      },
      "source": [
        "The line `del jesse['points']` removes the key-value pair `'points': 723` from the `jesse` dictionary.\n",
        "\n",
        "If we would like to clear a dictionary of all of its values, we can do so with the `dict.clear()` method. This will keep a given dictionary in case we need to use it later in the program, but it will no longer contain any items.\n",
        "\n",
        "Let’s remove all the items within the `jesse` dictionary:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HgYhZnDB-akh",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "e456eb6f-9fee-4e96-e3aa-8957ef8a5e36"
      },
      "source": [
        "jesse = {'username': 'JOctopus', 'online': False, 'points': 723, 'followers': 481}\n",
        "\n",
        "jesse.clear()\n",
        "\n",
        "print(jesse)"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jsO6JG4U-dQH",
        "colab_type": "text"
      },
      "source": [
        "The output shows that we now have an empty dictionary devoid of key-value pairs.\n",
        "\n",
        "If we no longer need a specific dictionary, we can use `del` to get rid of it entirely:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Pt6DW-78-hfE",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 198
        },
        "outputId": "98b678dc-e2d8-4b02-e422-4332df21dbe5"
      },
      "source": [
        "del jesse\n",
        "\n",
        "print(jesse)"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-17-c44317992567>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdel\u001b[0m \u001b[0mjesse\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mjesse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m: name 'jesse' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RSaWR3PM-mDA",
        "colab_type": "text"
      },
      "source": [
        "When we run a call to `print()` after deleting the `jesse` dictionary, we’ll receive the following error:\n",
        "```\n",
        "Output\n",
        "...\n",
        "NameError: name 'jesse' is not defined\n",
        "```\n",
        "Because dictionaries are mutable data types, they can be added to, modified, and have items removed and cleared."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7IGmK7DL-rUd",
        "colab_type": "text"
      },
      "source": [
        "### Conclusion\n",
        "This tutorial went through the dictionary data structure in Python. Dictionaries are made up of key-value pairs and provide a way to store data without relying on indexing. This allows us to retrieve values based on their meaning and relation to other data types.\n",
        "\n",
        "You can see the dictionary data type used in programming projects such as web scraping with [Scrapy](https://scrapy.org/).\n"
      ]
    }
  ]
}