3_Lists_and_dictionaries.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true,
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Princeton-CDH/python4poets/blob/main/3_Lists_and_dictionaries.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 3. Data Types II: Putting Things Together -- or, on Lists and Dictionaries\n",
        "\n",
        "This lesson will describe a second kind of data types, grouped together here due to their ability to collect (and structure) individual data entries. Specifically, we will look in more detail at two kinds of data collections:\n",
        "\n",
        "*   Lists;\n",
        "*   and Dictionaries.\n",
        "\n",
        "\n",
        "There's also two more common data types which we will just briefly touch upon: \n",
        "\n",
        "*   Tuples;\n",
        "*   and Sets.\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "mzfDj55yepmo"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 3.1 Lists\n",
        "\n"
      ],
      "metadata": {
        "id": "MD4EZ3JOfpvA"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Lists (`list`) are among the data types that can be used to store collections of data. Specifically, lists differ from the other three data types introduced above in the following ways:\n",
        "\n",
        "*   lists are **ordered**;\n",
        "*   lists are **changeable**;\n",
        "*   and lists allow **duplicate values**.\n",
        "\n",
        "We'll go over these in more detail below.\n",
        "\n",
        "The general syntax for declaring lists is as follows:"
      ],
      "metadata": {
        "id": "VaBqJjfeo9PL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# declare a list\n",
        "list_1 = []"
      ],
      "metadata": {
        "id": "LJV_oh4i2lbH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "Pay attention to the use of square brackets `[]` to form the list. But the example above forms an *empty* list. Let's check the *contents* and the *type* of that list: "
      ],
      "metadata": {
        "id": "8Ud-QGaQ2iaB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(list_1)\n",
        "type(list_1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6l7gU4pb2teN",
        "outputId": "ff7927ca-e73c-48db-8345-8f79f1cd5729"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[]\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "list"
            ]
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "So yes, we formed a list that is... empty. Perhaps not too useful, but it's a start!\n",
        "\n",
        "To actually include something in a list, we'd have to add it, either when declaring the list, or later on:\n",
        "\n",
        "\n",
        "*   Declare a list with content like this:\n",
        "`list_2 = [\"item_1, \"item_2\"]` (Note that separate items in a list are separated by a comma `,`)\n",
        "\n",
        "*  Add new items to an existing list like this: `list_2.append(\"item_3\")` \n",
        "\n",
        "The latter is what we call a *method*. Essentially, it's \"[a function that 'belongs to' an object](https://docs.python.org/3/tutorial/classes.html#instance-objects).\" We'll learn more about functions later, but for now, note how the method `append` -- in `list_2.append(\"X\")` -- is itself *appended* to the object we'd like to manipulate. \n",
        "\n",
        "Let's try that process on `list_1` that we declared above:"
      ],
      "metadata": {
        "id": "FdXeDR362ryA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "list_1.append(\"This list used to be empty!\")\n",
        "print(list_1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "faFeioCH4BK4",
        "outputId": "35a3b91c-0538-4949-b9e0-4a2431486326"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['This list used to be empty!']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "∇  *What do you think happens if you execute the kernel above multiple times?*\n",
        "\n",
        "In other words, lists can be changed.\n",
        "\n"
      ],
      "metadata": {
        "id": "ItpRFrGI4X7F"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 3.1.1 Adding to Lists\n",
        "\n",
        "So far we've added only a `str` to our list. Let's add more, including other data types:"
      ],
      "metadata": {
        "id": "7LdpZTJfRKEK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# add a str\n",
        "list_1.append(\"clutter\")\n",
        "\n",
        "# add an int\n",
        "list_1.append(100)\n",
        "\n",
        "# add a float\n",
        "list_1.append(4.123)\n",
        "\n",
        "print(list_1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cNdh_AjCMy0r",
        "outputId": "754aa97f-25a6-402f-d26b-e7541ae2a1c7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['This list used to be empty!', 'clutter', 100, 4.123]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "You might have also notived that a `list` can contain different data types. `list_1`, our example list, contains items that are `str`, `int`, and `float`. Note that the **order** of the added items remains the same. We could even add another list as an item to a list, or any other data type:\n"
      ],
      "metadata": {
        "id": "ui4fqgaOH3ZR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# add a list to a list\n",
        "list_within_list = [\"This\", \"is\", \"a\", \"list\"]\n",
        "list_1.append(list_within_list)\n",
        "\n",
        "print(list_1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZobUnCPvJtms",
        "outputId": "9dce3334-f7c1-43e5-fe13-b4808b764685"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['This list used to be empty!', 'clutter', 100, 4.123, ['This', 'is', 'a', 'list']]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 3.1.2 Removing from Lists\n",
        "\n",
        "Maybe we overdid it now... so let's remove the last item -- the `list` within the `list` -- again. You can remove items from a list in the same way that you append items, specifically through a method. This time we're using the following syntax:"
      ],
      "metadata": {
        "id": "_rU8bRxsJrWB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "list_1.remove(list_within_list)\n",
        "\n",
        "print(list_1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4hCE6v25KhOA",
        "outputId": "c2a4e7ac-0ea3-4c7a-e2b8-10c656eef394"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['This list used to be empty!', 'clutter', 100, 4.123]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "∇  *What do you think happens if you execute the kernel above a second time?*\n",
        "\n"
      ],
      "metadata": {
        "id": "SkDu0A6LMjg4"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "###3.1.3 Use Case & List Index\n",
        "\n",
        "Now, let's move on from our initial list and form a list of some of Langston Hughes' poems: "
      ],
      "metadata": {
        "id": "GP4neuKqRclr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "poems_selection = [\"50-50\", \"Black Maria\", \"Blues in Stereo\", \"Blues on a Box\", \"Catch\", \"Crossing Jordan\", \"Dreams\", \"Motto\", \"Seashore through Dark Glasses\", \"Snail\", \"Winter Moon\", \"You and your whole race.\"]"
      ],
      "metadata": {
        "id": "IlJ8CwaTKtay"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "You may notice that that's a rather long list and not really legible anymore. To provide better readability, one way you can format your lists is as follows:"
      ],
      "metadata": {
        "id": "gHVt5NCkLqLh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "poems_selection_2 = [\n",
        "                   \"Boogie: 1 A.M.\",\n",
        "                   \"Brass Spittoons\", \n",
        "                   \"Cross\",\n",
        "                   \"Crowing Hen Blues\",\n",
        "                   \"Daybreak in Alabama\",\n",
        "                   \"Dream Boogie\",\n",
        "                   \"Dying Beast\",\n",
        "                   \"Harlem Sweeties\",\n",
        "                   \"I, Too\",\n",
        "                   \"Lincoln Theatre\",\n",
        "                   \"Out of Work\",\n",
        "                   \"Sailor\",\n",
        "                   \"Snail\",\n",
        "                   \"Sylvester’s Dying Bed\",\n",
        "                   \"Theme for English B\", \n",
        "                   \"The Weary Blues\",\n",
        "                   \"Yesterday and Today\"\n",
        "                   ]"
      ],
      "metadata": {
        "id": "Sc5Lj9kNLqZ3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "If we wanted to attach the second list to the first, we could do this as follows:"
      ],
      "metadata": {
        "id": "EL0RezJhUFmg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "poems_selection.extend(poems_selection_2)\n",
        "\n",
        "print(poems_selection)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OJL6vdgiUSwz",
        "outputId": "416f76e2-6dd4-404e-f170-b386db752bac"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['50-50', 'Black Maria', 'Blues in Stereo', 'Blues on a Box', 'Catch', 'Crossing Jordan', 'Dreams', 'Motto', 'Seashore through Dark Glasses', 'Snail', 'Winter Moon', 'You and your whole race.', 'Boogie: 1 A.M.', 'Brass Spittoons', 'Cross', 'Crowing Hen Blues', 'Daybreak in Alabama', 'Dream Boogie', 'Dying Beast', 'Harlem Sweeties', 'I, Too', 'Lincoln Theatre', 'Out of Work', 'Sailor', 'Snail', 'Sylvester’s Dying Bed', 'Theme for English B', 'The Weary Blues', 'Yesterday and Today']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The code above highlights yet another list method, and you'll notice that we kept the order of the two lists and just connected them. So let's **sort** them alphabetically, through yet another list method:\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "FLU-uKk_UinF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "poems_selection.sort()\n",
        "\n",
        "print(poems_selection)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pAd1YKRfU7kw",
        "outputId": "fc8652c4-982d-46dd-ab56-de906570684f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['50-50', 'Black Maria', 'Blues in Stereo', 'Blues on a Box', 'Boogie: 1 A.M.', 'Brass Spittoons', 'Catch', 'Cross', 'Crossing Jordan', 'Crowing Hen Blues', 'Daybreak in Alabama', 'Dream Boogie', 'Dreams', 'Dying Beast', 'Harlem Sweeties', 'I, Too', 'Lincoln Theatre', 'Motto', 'Out of Work', 'Sailor', 'Seashore through Dark Glasses', 'Snail', 'Snail', 'Sylvester’s Dying Bed', 'The Weary Blues', 'Theme for English B', 'Winter Moon', 'Yesterday and Today', 'You and your whole race.']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Ok, so far so good. We created two lists, combined them, and changed the order. But if you'll look closely through the output, you'll notice that we have one item in there twice, because both lists contained it: specifically, we now list the poem [*Snail*](https://www.poetryfoundation.org/poems/150988/snail-5d73bf7842530) twice. Let's double-check that:\n",
        "\n"
      ],
      "metadata": {
        "id": "CryFrT1uKsfL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "poems_selection.count(\"Snail\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "d91YYzXSW1Yc",
        "outputId": "05ad7749-e1b8-46c9-c475-65420bb93397"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {},
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can check where the *first* occurrence of this item happens through the **index**, which functions the same way as in a string (remember, Python starts counting at `0`). We can call the index of the *first* occurrence of `\"Snail\"` in our list as follows:"
      ],
      "metadata": {
        "id": "_yaFQRZeYNZp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "poems_selection.index(\"Snail\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ulzK4Md8Y03y",
        "outputId": "d4c28b79-0932-493d-829a-433cdd415c6d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "21"
            ]
          },
          "metadata": {},
          "execution_count": 35
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Given that our list is now sorted alphabetically, the two occurrences are at index `21` and `22`. We can **slice** the list (again like a `str`) to show the two `\"Snail\"`s:"
      ],
      "metadata": {
        "id": "d7k0-hRaY5MU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "poems_selection[21:23]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fL_suawRZYac",
        "outputId": "6f6cce0c-7d5f-47c0-defa-820310bcce99"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Snail', 'Snail']"
            ]
          },
          "metadata": {},
          "execution_count": 36
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "∇  *Why did we specify* `23`*?*\n",
        "\n",
        "If we're bothered by the fact that we now have that the title of this poem twice in our list, we could remove one of these occurrences. You already learned the `list.remove(item)` method, so write it out in the kernel below and print the list, so you can check manually: "
      ],
      "metadata": {
        "id": "yx8Jf3vzXFC-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# remove the str \"Snail\"\n",
        "\n",
        "# print list\n"
      ],
      "metadata": {
        "id": "r3qMi3JKXWul"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Another thing you can do with slices is to include **steps**, which means that \"jump\" through the list and list every n-th item. The basic syntax of slicing is therefore as follows:\n",
        "\n",
        "`list[start:stop:step]`\n",
        "\n",
        "You don't have to actually fill in every part of the above syntax, and you could just specifiy the last part as follows:"
      ],
      "metadata": {
        "id": "xaj6X-cthKyf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "poems_selection[::12]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_hQ2gcMJhSfl",
        "outputId": "50b04292-93ea-44c3-fdf2-b3a22d1d1db4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['50-50', 'Dreams', 'The Weary Blues']"
            ]
          },
          "metadata": {},
          "execution_count": 38
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "In other words, we start with index `0` until the end of the list, listing every `12`th item of the list. \n",
        "\n",
        "Let's store a list -- starting at index `2`, with step `10`, as a new list for now:"
      ],
      "metadata": {
        "id": "qgBgXu_Ai4kD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "poems_short_list = poems_selection[6::6]\n",
        "print(poems_short_list)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NdU6X7F0jMB9",
        "outputId": "d745a02d-c6d3-4128-b0e1-a58b275f41e5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['Catch', 'Dreams', 'Out of Work', 'The Weary Blues']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 3.2 Dictionaries\n",
        "\n"
      ],
      "metadata": {
        "id": "0XTSUFV-gu16"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Dictionaries (`dict`) go one step further than lists in that they assign *values* to corresponding *keys*. Dictionaries are declared as follows:\n",
        "\n",
        "`dict = {\"key_1\": \"value_1\", \"key_2\": \"value_2\"}`\n",
        "\n",
        "\n",
        "Note the use of curly braces `{}` and the internal **key:value** structure that are needed to form a dictionary. Overall, the following features are noteworthy about dictionaries:\n",
        "\n",
        "*   they are ordered;\n",
        "*   they are changeable;\n",
        "*   and they cannot have duplicate keys.\n",
        "\n",
        "In other words, you can store data in dictionary pairs and call *values* by their corresponding *keys*. While keys must be immutable data types (which includes `int`, `float`, `str`, or `bool`), values do not have this constraint. In other words, you can store any other data type as a value of a dictionary, including more comprehensive types such as a `list` or yet another `dict`.\n",
        "\n",
        "> Dictionaries are *ordered* as of Python version 3.7; before that, dictionaries were *unordered*. Ordered means that a sequence has a set order, and that we can refer to items by an index. \n",
        "> \n",
        "> *As a side note, it's generally a good idea to pay attention to the topic of versions.*\n",
        "\n",
        "In sum, dictionaries can be really useful. But let's revisit the basic structure:"
      ],
      "metadata": {
        "id": "vjImCATmo5Bj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "Wintersession_students = {\n",
        "    \"Python for Poets\": 46,\n",
        "    \"Introdcution to Machine Learning\": 152,\n",
        "    \"Put Census data into R to make maps\": 42\n",
        "}"
      ],
      "metadata": {
        "id": "pda5OshpLhoc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "∇  *What does the dictionary in the kernel above mean?*\n",
        "\n"
      ],
      "metadata": {
        "id": "8IEWsqdEKd0P"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "###3.2.1 Use Case 1: Bibliographic Entry\n",
        "\n",
        "Compare also the following bibliographic entry, formatted as a dictionary:"
      ],
      "metadata": {
        "id": "jxHJQK1nR6bE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "bibliographic_entry_1 = {\n",
        "    \"Author\": \"Michel Foucault\",\n",
        "    \"Title\": \"The Order of Things: an Archaeology of the Human Sciences\",\n",
        "    \"Publication Place\": \"London\",\n",
        "    \"Publisher\": \"Routledge\", \n",
        "    \"Year\": 2002\n",
        "}"
      ],
      "metadata": {
        "id": "euPaTCdAJyiQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "While this dictionary is still manually readable, imagine a much longer dictionary -- how would you get data out of this format again? Fortunately, dictionary methods can help with that -- to *get* the value of a specified key, just type the following:"
      ],
      "metadata": {
        "id": "YhGc4c12Szgx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "bibliographic_entry_1.get(\"Author\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 37
        },
        "id": "k8yPwbxlSzA9",
        "outputId": "a0459aff-9ddc-40a6-9d79-0c226f6c2761"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Michel Foucault'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 42
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "But what if you don't even know the key? Well, another method allows you to call all the keys:"
      ],
      "metadata": {
        "id": "WlZZ7RRpTB74"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "bibliographic_entry_1.keys()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AIOEyQ4vTCQW",
        "outputId": "e19c87fd-ffff-426b-aca4-2a7c19477e6c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "dict_keys(['Author', 'Title', 'Publication Place', 'Publisher', 'Year'])"
            ]
          },
          "metadata": {},
          "execution_count": 43
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "There's also the corresponding method for all values:"
      ],
      "metadata": {
        "id": "5PhLFWdBTMGG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "bibliographic_entry_1.values()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uIg4yVqVTMda",
        "outputId": "cdda50bd-dbbb-4d65-f3a1-ba97d508680e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "dict_values(['Michel Foucault', 'The Order of Things: an Archaeology of the Human Sciences', 'London', 'Routledge', 2002])"
            ]
          },
          "metadata": {},
          "execution_count": 44
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The following method helps if you're interested in the dictionary items as pairs:"
      ],
      "metadata": {
        "id": "u-BmLWcvlnBr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "bibliographic_entry_1.items()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Qgip4QEKlvWm",
        "outputId": "030b7229-a872-43ad-c232-a5d49b80604a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "dict_items([('Author', 'Michel Foucault'), ('Title', 'The Order of Things: an Archaeology of the Human Sciences'), ('Publication Place', 'London'), ('Publisher', 'Routledge'), ('Year', 2002)])"
            ]
          },
          "metadata": {},
          "execution_count": 45
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "If you wanted to add another key:value pair to a given dictionary -- remember, dictionaries are *mutable* -- "
      ],
      "metadata": {
        "id": "fttLZbuGVkUv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "bibliographic_entry_1.update({\"My own Reading Notes\": \"Really insightful but pretty dense (usual for this author!)\"})\n",
        "\n",
        "print(bibliographic_entry_1.get(\"My own Reading Notes\"))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VR28-TeG_vZH",
        "outputId": "baee445b-89df-44c7-9686-b3ff09a80f93"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Really insightful but pretty dense (usual for this author!)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 3.2.2 Use Case 2: Longer Bibliography \n",
        "\n",
        "So far so good -- but a single entry might not be too helpful, so let's put that into a longer format:\n"
      ],
      "metadata": {
        "id": "kgcL0MF5AH4c"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "bibliography = [\n",
        "    {\n",
        "        \"Author\": \"Michel Foucault\",\n",
        "        \"Title\": \"The Order of Things: an Archaeology of the Human Sciences\",\n",
        "        \"Publication Place\": \"London\",\n",
        "        \"Publisher\": \"Routledge\", \n",
        "        \"Year\": 2002\n",
        "    },\n",
        "    {\n",
        "        \"Author\": \"郑张尚芳\",\n",
        "        \"Title\": \"温州方言志\",\n",
        "        \"Publication Place\": \"Beijing\",\n",
        "        \"Publisher\": \"中华书局\",\n",
        "        \"Year\": 2008\n",
        "    },\n",
        "    {\n",
        "        \"Author\": \"中村祐司\",\n",
        "        \"Title\": \"2020年東京オリンピックとは何だったのか：欺瞞の祭典が残したもの\",\n",
        "        \"Publication Place\": \"Tokyo\",\n",
        "        \"Publisher\": \"成文堂\",\n",
        "        \"Year\": 2022\n",
        "    }\n",
        "]"
      ],
      "metadata": {
        "id": "Qh2ZiWs4OCP9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "∇  *Can you describe the structure of the above example?*\n",
        "\n",
        "As you can see, Python does not (really) have an issue with handling different scripts, as the bibliography above includes also works in Chinese and Japanese. Depending on the writing system you are working on, there might be some adjustments you might have to make (for example, right-to-left scripts require some additional adjustments).\n"
      ],
      "metadata": {
        "id": "1kCNhb64mJ6s"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 3.2.3 Use Case 3: Poems?\n",
        "\n",
        "Of course, you can also dictionaries for other forms of data. We could even store poems, such as in the following example ([*Dreams*](https://www.poetryfoundation.org/poems/150995/dreams-5d767850da976) by Langston Hughes):"
      ],
      "metadata": {
        "id": "JR7bIYzKW02V"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "poems_dict = {\n",
        "    \"Catch\": [\n",
        "        \"Big Boy came\",\n",
        "        \"Carrying a mermaid\",\n",
        "        \"On his shoulders\",\n",
        "        \"And the mermaid\", \n",
        "        \"Had her tail\",\n",
        "        \"Curved\",\n",
        "        \"Beneath his arm.\",\n",
        "        \"\\n\",\n",
        "        \"Being a fisher boy,\",\n",
        "        \"He’d found a fish\",\n",
        "        \"To carry—\",\n",
        "        \"Half fish,\",  \n",
        "        \"Half girl\", \n",
        "        \"To marry.\"],\n",
        "    \"Dreams\": [\n",
        "        \"Hold fast to dreams\",\n",
        "        \"For if dreams die\",\n",
        "        \"Life is a broken-winged bird\",\n",
        "        \"That cannot fly.\",\n",
        "        \"\\n\",\n",
        "        \"Hold fast to dreams\",\n",
        "        \"For when dreams go\",\n",
        "        \"Life is a barren field\",\n",
        "        \"Frozen with snow.\"]\n",
        "        }"
      ],
      "metadata": {
        "id": "t_pDgI5Hf9Eq"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "∇  *What do you think will be the output of the kernel below?*\n"
      ],
      "metadata": {
        "id": "bt00CmFMwG8_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(poems_dict.get(\"Dreams\")[:4])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oxDrdp3YgQDw",
        "outputId": "c4a1db01-30a1-4704-9e44-5d15f9cb48b6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['Hold fast to dreams', 'For if dreams die', 'Life is a broken-winged bird', 'That cannot fly.']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "As you can see, lists and dictionaries can get relatively long. Often, you would want to store this sort of data in a separate file. These files store data in other formats, which can be imported to and adapted to Python data types. While you might think of a spreadsheet such as an Excel file, that format entails a [few more steps](https://www.geeksforgeeks.org/reading-excel-file-using-python/) to adapt to native Python. Easier -- and just as common -- are examples such as [CSV](https://en.wikipedia.org/wiki/Comma-separated_values) files or [JSON](https://www.json.org/json-en.html) files. To process those formats, you'd need to import a Python module, something we'll introduce in a later module."
      ],
      "metadata": {
        "id": "oq_XXSfFWFhi"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 3.3 Tuples and Sets in a Nutshell\n"
      ],
      "metadata": {
        "id": "-AJNamEiaCNT"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "There's two more sequential data types that we'll briefly touch upon: tuples and sets.\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "9trilq13o28Q"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 3.3.1 Tuples\n",
        "\n",
        "The first one, `tuple`, consists of an ordered, unchangeable object. It allows for duplicate items therein. You form a tuple as follows:\n",
        "\n",
        "`genre = (\"poetry\", \"prose\")`\n",
        "\n",
        "Note the use of round brackets `()` to form a tuple. Some of us may always use lists over tuples; that's ok. Tuples usually come in handy when you're thinking about code efficiency (as they are unchangeable). So that's nothing you have to worry about yet!\n",
        "\n"
      ],
      "metadata": {
        "id": "vz9MpQTPSq52"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 3.3.2 Sets\n",
        "\n",
        "The second one, `set`, consists of an unordered, unchangeable object (you can change items in a set, but you *cannot* add or remove items). They are therefore unindexed. Additionally, and crucially, a set consists of *unique* values. You form a set as follows:\n",
        "\n",
        "`books_read_for_generals = {\"book C\", \"book A\", \"book B\"}`\n",
        "\n",
        "Note the use of curly braces `{}` to form a set. Since a set does not care about element order, it's also more memory efficient than a `list`. That being said, you may at first also not find yourself using sets nearly as much as a list.\n"
      ],
      "metadata": {
        "id": "fMwijb7rSmmS"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 3.3.3 General Overview & Summary\n",
        "So, in summary...\n",
        "\n",
        "...use a **dictionary** when:\n",
        "- ...you need a key:value pair and the logical association they provide;\n",
        "- ...you need to lookup your data based on a custom key;\n",
        "- ...you need to modify your data; dictionaries are mutable, after all.\n",
        "\n",
        "...use a **list** when:\n",
        "- ...you have a collection of data that needs a set order; \n",
        "- ...you need to modify an iterable collection frequently.\n",
        "\n",
        "...use a **tuple** when:\n",
        "- ...your data is immutable, and therefore cannot change.\n",
        "\n",
        "...use a **set** when:\n",
        "- ...you need the elements to be unique. "
      ],
      "metadata": {
        "id": "EgnMjvZvSd_K"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 3.4 Loops\n",
        "\n"
      ],
      "metadata": {
        "id": "Vj9_ljW2aXP6"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Loops are used to iterate over a sequence. That means you can loop over a list, a dictionary, a tuple, a set -- or even a string. More specifically, loops are used to repeat a given section of code, either a certain number of times or until a particular condition is met. Expressed differently: with a loop, you're \"looking\" through each individual entry that you provide.\n",
        "\n",
        "There's two loops you need to know about:\n",
        "\n",
        "*   a *while loops* repeats a statement while a condition is `True`;\n",
        "*   a *for loop* executes a statement for each instance in a sequence.\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "8MXm54SJZxV-"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "###3.4.1 *For* Loops\n",
        "\n",
        "Let's look at the *for loop* first. Essentially, a simple for loop consists of two lines of code:\n",
        "1.   a line that begins with the word `for`, followed by a new variable for each item in the sequence, the word `in`, the name of the sequence, and a colon `:` \n",
        "2.   a line that specifies what should be done.\n",
        "\n",
        "A `for` loop executes the *second* part *for each instance* in a sentence.\n",
        "\n",
        "So let's try that out on a list:"
      ],
      "metadata": {
        "id": "Vf2XVqKJSw1a"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# declaring a new list\n",
        "existential_list = [True, False, True, False, False, True]\n",
        "\n",
        "# loop in two lines:\n",
        "for boolean in existential_list:\n",
        "  print(\"To be, or not to be, that is the question\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AZRwFKJvE2Cv",
        "outputId": "59141160-90dc-4ba2-a46a-8d4382b6cb61"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "To be, or not to be, that is the question\n",
            "To be, or not to be, that is the question\n",
            "To be, or not to be, that is the question\n",
            "To be, or not to be, that is the question\n",
            "To be, or not to be, that is the question\n",
            "To be, or not to be, that is the question\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "∇  *Can you describe in your own words what happened above?*\n",
        "\n",
        "Also: Note that *indendation matters* (we'll return to that).\n",
        "\n",
        "As mentioned at the beginning of this section, you can also loop over strings. Compare the following example:"
      ],
      "metadata": {
        "id": "R09Ie5LsE3j9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# declare a new string:\n",
        "example_string = \"गते गते पारगते पारसंगते बोधि स्वाहा\"\n",
        " \n",
        "# iterate over the string:\n",
        "character_count = 0\n",
        "for character in example_string:\n",
        "  character_count+=1\n",
        "\n",
        "print(character_count)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zJNr-B6chkcm",
        "outputId": "d872e22c-2b22-4ae1-dfd6-e5f58f26f4e7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "35\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "∇  *Can you explain what the loop above does?*\n",
        "\n",
        "Of course, Python has a built-in function -- `len(str)` -- to achieve the same result in a single line. Whenever possible, try to express yourself in a more concise way:"
      ],
      "metadata": {
        "id": "Bnpct1HOFGko"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "len(example_string)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "U6Rc8otrFI79",
        "outputId": "974876ee-e462-4731-f0fb-56d6f6acdc18"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "35"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "###3.4.2 *While* Loops\n",
        "\n",
        "Returning to loops -- `while` loops execute code as long as a certain condition is met. \n",
        "\n",
        "These loops contain -- minimally -- the following elements:\n",
        "\n",
        "1.   a line that begins with the word `while`, folled by the condition that you intend to be met at first, folled by a colon `:`\n",
        "2.   a line that will be executed.\n",
        "\n",
        "The second part will be executed *while* the specified condition is `True`."
      ],
      "metadata": {
        "id": "jJ_1uXwnXjAn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "text = \"Write me!\"\n",
        "counter = 0\n",
        "\n",
        "while counter < 5:\n",
        "  print(text)\n",
        "  counter += 1"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eqOvPlF_coem",
        "outputId": "bf0b7865-28b9-485e-d45a-028bccac7101"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Write me!\n",
            "Write me!\n",
            "Write me!\n",
            "Write me!\n",
            "Write me!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "∇  *Can you explain what the loop above does?*\n",
        "\n",
        "Again, *indentation matters.* Compare what happens in the following kernel:\n",
        "\n"
      ],
      "metadata": {
        "id": "5LDy9GwzbAQP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "text = \"Write me!\"\n",
        "counter = 0\n",
        "\n",
        "while counter < 5:\n",
        "  print(text)\n",
        "counter += 1"
      ],
      "metadata": {
        "id": "g2HXL0SDbOb-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "∇  *Yikes, what happened here?*\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "UXMWJJxBbW1F"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "###3.4.3 Loop Use Case \n",
        "\n",
        "You can also loop through a dictionary, but for this data type, you need to pay attention to the keys:values pairing. In the following example, we are printing *each line* in *each poem* in the dictionary `poems_dict` that we declared earlier."
      ],
      "metadata": {
        "id": "6KZKBaPzcpH5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# print \n",
        "for poem in poems_dict.values():\n",
        "  for line in poem:\n",
        "    print(line)\n",
        "  print(\"\\n---------\\n\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tbaio5BEbXDG",
        "outputId": "ebe8fd66-5a33-483c-cec5-623e0e11f477"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Big Boy came\n",
            "Carrying a mermaid\n",
            "On his shoulders\n",
            "And the mermaid\n",
            "Had her tail\n",
            "Curved\n",
            "Beneath his arm.\n",
            "\n",
            "\n",
            "Being a fisher boy,\n",
            "He’d found a fish\n",
            "To carry—\n",
            "Half fish,\n",
            "Half girl\n",
            "To marry.\n",
            "\n",
            "---------\n",
            "\n",
            "Hold fast to dreams\n",
            "For if dreams die\n",
            "Life is a broken-winged bird\n",
            "That cannot fly.\n",
            "\n",
            "\n",
            "Hold fast to dreams\n",
            "For when dreams go\n",
            "Life is a barren field\n",
            "Frozen with snow.\n",
            "\n",
            "---------\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "∇  *Let's read the code above carefully and really understand what's going on. Can you read it against the background of the dictionary* `poems_dict` *itself?*\n",
        "\n",
        "(to make that a bit easier, print that dictionary below:)"
      ],
      "metadata": {
        "id": "bnYaVAqgdvOx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(poems_dict)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bxqQzMm8eQhm",
        "outputId": "05b3f07b-8ec1-4bc9-f5c4-60d262c2caa3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'Catch': ['Big Boy came', 'Carrying a mermaid', 'On his shoulders', 'And the mermaid', 'Had her tail', 'Curved', 'Beneath his arm.', '\\n', 'Being a fisher boy,', 'He’d found a fish', 'To carry—', 'Half fish,', 'Half girl', 'To marry.'], 'Dreams': ['Hold fast to dreams', 'For if dreams die', 'Life is a broken-winged bird', 'That cannot fly.', '\\n', 'Hold fast to dreams', 'For when dreams go', 'Life is a barren field', 'Frozen with snow.']}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "If you wanted to iterate over *both* keys and values in a given dictionary, an extra step is necessary, as [described here](https://stackoverflow.com/questions/3294889/iterating-over-dictionaries-using-for-loops)."
      ],
      "metadata": {
        "id": "izJxk1YKkp7V"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "###3.4.4 Looping to Infinity and Beyond"
      ],
      "metadata": {
        "id": "kQXThvdb5PCx"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "One possible problem you may encounter with loops is the following scenario: your loop never ends. This happens when an infinite loop never encounters a `False` statement. Sure, there may be uses for such loops, but for now, you'll mostly want to avoid those.\n",
        "\n",
        "(And when such an infinite loop occurs, you'll have to interrupt it, because otherwise, the code will literally be executed infinitely [but rest assured though that your machine is still much more likely to be interrupted]).\n",
        "\n",
        "So compare the following `while` loop. Nothing to stop this loop from continuing, right? (Before you try it out, note that you can interrupt a kernel the same way that you execute it.)"
      ],
      "metadata": {
        "id": "v5FZjeHp608s"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "text = \"Write me!\"\n",
        "counter = 0\n",
        "\n",
        "while counter > -1:\n",
        "  print(text)\n",
        "  counter += 1"
      ],
      "metadata": {
        "id": "q5-xHgCIFHvG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "One way to stop a loop is to include a `break` statement. For example, we could include the following clause in the loop above:"
      ],
      "metadata": {
        "id": "4RuiBtz2FMFE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "text = \"Write me!\"\n",
        "counter = 0\n",
        "\n",
        "while counter > -1:\n",
        "  print(text)\n",
        "  counter += 1\n",
        "  if counter == 10:\n",
        "    break"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xnovvoPv9YCf",
        "outputId": "6253c42d-4d69-4347-cdc3-5be7c96a2435"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Write me!\n",
            "Write me!\n",
            "Write me!\n",
            "Write me!\n",
            "Write me!\n",
            "Write me!\n",
            "Write me!\n",
            "Write me!\n",
            "Write me!\n",
            "Write me!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "In a nested loop (a loop within a loop), the `break` statement just exits the innermost loops (the loop `break` is in), and returns to the outer loop."
      ],
      "metadata": {
        "id": "lBSMKKr59rrf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "for poem in poems_dict.values():\n",
        "  for line in poem:\n",
        "    print(line)\n",
        "    if line == \"Curved\":\n",
        "      break\n",
        "  print(\"\\n---------\\n\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BoPjkXW49sH0",
        "outputId": "cc8b27f7-7185-4f2b-bc95-7750f5ce30ec"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Big Boy came\n",
            "Carrying a mermaid\n",
            "On his shoulders\n",
            "And the mermaid\n",
            "Had her tail\n",
            "Curved\n",
            "\n",
            "---------\n",
            "\n",
            "Hold fast to dreams\n",
            "For if dreams die\n",
            "Life is a broken-winged bird\n",
            "That cannot fly.\n",
            "\n",
            "\n",
            "Hold fast to dreams\n",
            "For when dreams go\n",
            "Life is a barren field\n",
            "Frozen with snow.\n",
            "\n",
            "---------\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "∇  *Can you explain what happened above?* \n"
      ],
      "metadata": {
        "id": "4H9Ywcy0-w4v"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Practice Section\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "aG8Tu0iAb_UV"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "\n",
        "1. In the kernel below, you should get the following output: `list`"
      ],
      "metadata": {
        "id": "84u3Fu0CeOPd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "this_list = {1, 2, 3, 4}\n",
        "\n",
        "type(this_list)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KgML4DO2eIWW",
        "outputId": "d60e1652-a1ca-4e8c-8401-204f1d676c55"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "set"
            ]
          },
          "metadata": {},
          "execution_count": 54
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "2. You should get the following output: `set`"
      ],
      "metadata": {
        "id": "f2qiWR8geii0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "this_set = (\"Alpha\", \"Beta\", \"Gamma\")\n",
        "\n",
        "type(this_set)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zHsw257relTi",
        "outputId": "6377e293-9f95-44d0-fc83-81228e6dae42"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tuple"
            ]
          },
          "metadata": {},
          "execution_count": 55
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "In the following section, let's use some of the lists and dictionaries we built. Make sure that you executed the relevant kernels above!\n",
        "\n",
        "3. You should get the following output: `['Blues on a Box', 'Boogie: 1 A.M.']`"
      ],
      "metadata": {
        "id": "0A7gQpAIe1tK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "poems_selection"
      ],
      "metadata": {
        "id": "OYLQpsWefAB0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "4. You should get the following output: `['Brass Spittoons', 'Dream Boogie']`"
      ],
      "metadata": {
        "id": "EfgCTZb2fN0D"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "poems_selection[5:]"
      ],
      "metadata": {
        "id": "a0XRmMFSfZC2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "5. You should get the following output: `dict`"
      ],
      "metadata": {
        "id": "bGmLpfZxfpxk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "this_dict = (\"First Name\": \"Toni\", \"Last Name\": \"Morrison\")\n",
        "type(this_dict)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8CHWoyPpfs7U",
        "outputId": "57dcb54d-24a4-49a0-ad41-bd85aa45787b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "dict"
            ]
          },
          "metadata": {},
          "execution_count": 64
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "6. You should get the following output: `dict_keys(['Author', 'Title', 'Publication Place', 'Publisher', 'Year'])`"
      ],
      "metadata": {
        "id": "pzXaJXXfhmUj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "bibliography.keys()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 164
        },
        "id": "Mg_SvcBDhpYQ",
        "outputId": "66d51f40-7db8-41a0-b38f-f80326437286"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "AttributeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-74-e05712e34610>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mbibliography\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mkeys\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m: 'list' object has no attribute 'keys'"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "7. You should get the following output: `中村祐司`"
      ],
      "metadata": {
        "id": "HZyZqo8igKPR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "bibliography[0].values(\"Author\")"
      ],
      "metadata": {
        "id": "DHDuhb6rgM6k"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "8. Fix the following loop (make sure you print different titles):\n"
      ],
      "metadata": {
        "id": "fTJ-O7t4h8CS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "for book in bibliography:\n",
        "  print(\"The book '\" + bibliography[0].get(\"Title\") + \"' is in my bibliography\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4Ojj4CKah-Iq",
        "outputId": "c0db3ad8-640b-41c5-8d8c-7f8ba8816426"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The book 'The Order of Things: an Archaeology of the Human Sciences' is in my bibliography\n",
            "The book 'The Order of Things: an Archaeology of the Human Sciences' is in my bibliography\n",
            "The book 'The Order of Things: an Archaeology of the Human Sciences' is in my bibliography\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "9. Fix the following loop:"
      ],
      "metadata": {
        "id": "tFrYV7o6cEBx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "counter = 0\n",
        "\n",
        "while poem in poems_selection()\n",
        "  counter + 1\n",
        "  \n",
        "print(\"There are \" + str(counter) + \" poems in this list\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 198
        },
        "id": "zY-SMgqUfxK6",
        "outputId": "cfd56c27-610c-431d-de2a-150b9d1d2f6e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-53-807aeb41bb6a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      4\u001b[0m   \u001b[0mcounter\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"There are \"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mcounter\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\" poems in this list\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "10: Fix the loop below:"
      ],
      "metadata": {
        "id": "507ARzaFeFWq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "for books in bibliography:\n",
        "  print(book.get(\"Author\") + \" is the author of \" + book.get(\"Title\"))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bCeEnod8a5iV",
        "outputId": "4c928fcc-ea6d-4f1c-e3d8-f87e1783872a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Michel Foucault is the author of The Order of Things: an Archaeology of the Human Sciences\n",
            "郑张尚芳 is the author of 温州方言志\n",
            "中村祐司 is the author of 2020年東京オリンピックとは何だったのか：欺瞞の祭典が残したもの\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "11. Fix the following loop. You should get the following output `Catch Dreams`:"
      ],
      "metadata": {
        "id": "NajAXUp-jGwi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "for k in poems_dict.values():\n",
        "  print(k)"
      ],
      "metadata": {
        "id": "trCK4JutjJ4K",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9e96122e-c67a-4512-ebe2-c4efc38c81ad"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['Big Boy came', 'Carrying a mermaid', 'On his shoulders', 'And the mermaid', 'Had her tail', 'Curved', 'Beneath his arm.', '\\n', 'Being a fisher boy,', 'He’d found a fish', 'To carry—', 'Half fish,', 'Half girl', 'To marry.']\n",
            "['Hold fast to dreams', 'For if dreams die', 'Life is a broken-winged bird', 'That cannot fly.', '\\n', 'Hold fast to dreams', 'For when dreams go', 'Life is a barren field', 'Frozen with snow.']\n"
          ]
        }
      ]
    }
  ]
}