notebooks/02-collections_basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "3ab29d5f",
   "metadata": {},
   "source": [
    "# Collections (data structures) basics\n",
    "### Data 765 tutoring\n",
    "\n",
    "Collections, or data structures, are ways of storing data. Like real life, computers need to store data in different ways depending on how that data should be accessed.\n",
    "\n",
    "In our real lives we may store papers in a small folder if we need easy access and order doesn't matter. A binder with tabs could be used if we needed to divide papers by subject such as Math, Science, Literature, et cetera.\n",
    "\n",
    "A binder or a folder is unsuitable for some objects. Unless you're weird, you probably wouldn't try to store a frying pan in a folder.\n",
    "\n",
    "Data structures in computers are analogous to real life storage structures in that we use different structures depending on what we need to accomplish. For example, a dictionary a.k.a. hash map allows linking keys to values. A `list` (vector) allows efficient access to random elements as well as easy tail end insertion of elements.\n",
    "\n",
    "Each data structure has limitations depending on your workload. A dresser in real life has the benefit of easy storage of a lot of clothes. However, digging to the bottom of a dresser is harder than pulling out a specific article from the top. In terms of programming, some data structures may be great at random access (lists/vectors) but slow at middle insertions.\n",
    "\n",
    "Some of these concepts aren't too important for data 765, but having a working understanding of different data structures will exponentially improve your programming. As programmers, even discounting data science, all we do is manipulate data in some way.\n",
    "\n",
    "# Lists (vectors)\n",
    "\n",
    "Python `list`s store arbitrary types sequentially. In other words, a `list` may hold integers, floats, different classes, other `list`s, `dict`s, or any other type desired. A `list` may consist of only a single type as well.\n",
    "\n",
    "Stuff in `list`s are referred to as \"elements.\"\n",
    "\n",
    "Lists are created with brackets, `[]`, the `list()` function, or comprehensions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "75fc5807",
   "metadata": {},
   "outputs": [],
   "source": [
    "# All elements are strings\n",
    "animals = [\"cat\", \"giraffe\", \"bunny\", \"duck\", \"elephant\", \"dolphin\"]\n",
    "\n",
    "# Different types\n",
    "grabbag = [\"42\", 42, 42.0]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "886bc370",
   "metadata": {},
   "source": [
    "Here's a more complex `list` that stores other collections.\n",
    "\n",
    "Internally, Python `list`s store pointers to `PyObject`s which allows us to store any type. Don't worry if that doesn't make sense. The gist of it is that a `list` doesn't store the actual object but a value that refers to where the object is located in memory. An example is if we had a real life list of addresses to houses; we don't have the actual houses in our pockets (unless you're a giant I guess) but instead the location of the houses.\n",
    "\n",
    "This concept will be more important when your class reaches [NumPy](https://numpy.org/) and [ndarrays](https://numpy.org/doc/stable/reference/arrays.ndarray.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e4cde7fb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# RPG inventory\n",
    "bag_of_holding = [\n",
    "    Currency(10025),\n",
    "    {\"weapon\": GreatSword(), \"gems\": FireGem(2)},\n",
    "    {\"armor\": SilverArmor(), \"gems\": None},\n",
    "    {DungeonKey(\"Skull\"), DungeonKey(\"Dragon\")},\n",
    "    Potion(25),\n",
    "]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7e9338c",
   "metadata": {},
   "source": [
    "`bag_of_holding` stores disparate types and even other collections.\n",
    "\n",
    "(Get it? `list`s are like [hammerspace](https://en.wikipedia.org/wiki/Hammerspace)!)\n",
    "\n",
    "## Indexing\n",
    "\n",
    "Like most programming languages, Python's `list` are indexed starting from 0 not 1 because of how array types are represented and accessed in memory.\n",
    "\n",
    "Valid index ranges are in the interval $[0, n)$ or $[0, n-1]$ where n is the length of the `list`. In other words, the **last valid index is len(your_list) - 1**. The final element of `animals` is 5 because there are six elements. You know, math. 🤓😸"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "f0f1383e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cat\n",
      "giraffe\n"
     ]
    }
   ],
   "source": [
    "print(animals[0])\n",
    "print(animals[1])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a62d244f",
   "metadata": {},
   "source": [
    "Besides single element indexing, Python supports retrieving a range of elements through slicing. The [slice](https://docs.python.org/3/library/functions.html#slice) class is constructed with optional `start`, `stop`, and `step` conditions. We usually don't have to construct an object directly as Python has [syntactic sugar](https://en.wikipedia.org/wiki/Syntactic_sugar) for slices.\n",
    "\n",
    "The parameters' default arguments are:\n",
    "* `start`: 0\n",
    "* `stop`: to the end of the sliced object\n",
    "* `step`: step by one element\n",
    "\n",
    "Let's retrieve \"giraffe\", \"bunny\", and \"duck\" using slices:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "7d4a97de",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['giraffe', 'bunny', 'duck']\n"
     ]
    }
   ],
   "source": [
    "best_friend_fav = animals[1:4]\n",
    "print(best_friend_fav)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "080ead21",
   "metadata": {},
   "source": [
    "I skipped the optional `step` parameter because \"giraffe\", \"bunny\", and \"duck\" are contiguous within the `list`.\n",
    "\n",
    "The zeroth element is a reference to \"cat\" while \"giraffe\" is at index 1. The second number in the slice is where indexing should stop. The element at index 4 isn't included because of the open interval. We're left with the three elements we sought as a `list`.\n",
    "\n",
    "As I mentioned above, `start` is an optional parameter. We may preclude passing an argument for `start` by leaving out the first number of the slice. In fact, each of the three parameters take their defaults if we leave them out in the slice. You'll learn more about default arguments later when the class reaches functions (my blog also covers it!)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "cc32ab27",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['cat', 'giraffe', 'bunny', 'duck']"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "animals[:4]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e44bec3",
   "metadata": {},
   "source": [
    "By leaving out the first and last numbers we're effectively creating a slice like so: `animals[0:4:1]`.\n",
    "\n",
    "What if we don't pass in any arguments?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "e9dadf33",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['cat', 'giraffe', 'bunny', 'duck', 'elephant', 'dolphin']"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "animals[:]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94d940bd",
   "metadata": {},
   "source": [
    "The default arguments evaluate to slicing from the first to the last element without skipping any of them. In other words, slicing with only the default arguments is a shallow copy of the `list`.\n",
    "\n",
    "Indexing and slicing returns an element or elements. We can chain indexing for cleaner code if our `list` contains other indexable elements. Chained indices are read from left to right. We're peeling back the layers of the structure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "a1a4b532",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c\n",
      "a\n"
     ]
    }
   ],
   "source": [
    "# Retrieve one element then index that element\n",
    "print(animals[0][0])\n",
    "\n",
    "# Retrieve multiple elements then index into the new list\n",
    "# and finally index into the string\n",
    "\n",
    "print(animals[:4][1][3])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2415b2ed",
   "metadata": {},
   "source": [
    "`animals[0][0]` first indexes the `list` for the first element. The first element is a string, \"cat\", which in turn can be indexed. The first index of \"cat\" is 'c'.\n",
    "\n",
    "The second example looks more complex, but when you break it down it's similar to the first. `animals[:4]` retrieves the first four elements (0, 1, 2, and 3) as a `list`. The second index refers to the second element in that `list`, the string \"giraffe\". The final index pulls a character from that string which in this case is 'a'.\n",
    "\n",
    "**Understanding this concept is crucial for nested data structures!**\n",
    "\n",
    "Finally, let's look at the last argument for slice objects. The third number in slices is a skip value. For example, we can skip every other element by setting the third index to 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "f9d927f5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = list(range(26))\n",
    "\n",
    "a[::2]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50ae1b84",
   "metadata": {},
   "source": [
    "As an aside, [range](https://docs.python.org/3/library/functions.html#func-range) objects are constructed similarly to slices. `range(1, 15, 2)` creates a range object that spans from 1 through 14 while skipping by 2. `range` objects are _not_ `list`s. They're sequences that must be consumed into a collection or iterated over. The code above consumes `range(26)` by creating a `list`.\n",
    "\n",
    "## Mutating `list`s\n",
    "\n",
    "Python's `list` is mutable. We can modify our actual `list` by appending and removing elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "d293a3b7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['cat', 'giraffe', 'bunny', 'duck', 'elephant', 'dolphin', 'hamster']"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "animals.append(\"hamster\")\n",
    "\n",
    "animals\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "566ef0fc",
   "metadata": {},
   "source": [
    "`lists` implement a lot of useful methods which you [may find here](https://docs.python.org/3/tutorial/datastructures.html). You shouldn't try to explicitly memorize the names of functions. `list`s or vectors are common data structures which always support a common set of operations such as pushing (appending), popping (removing the last element), or inserting elements among others.\n",
    "\n",
    "**Question:** We have a `list`, `one_hundred` that only contains the numbers 1 through 50 because one of our colleagues totally screwed up. We want to extend that `list` with a second `list` that contains numbers 51 through 100. **Look at the link above to find which method allows us to easily accomplish this task.** "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "52386f12",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ahh, we're missing numbers!\n",
    "one_hundred = list(range(1, 51))\n",
    "fifty = list(range(FILL_IN, FILL_IN))\n",
    "\n",
    "one_hundred.____\n",
    "\n",
    "one_hundred[-10:]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ecce7e0",
   "metadata": {},
   "source": [
    "Notice that the `one_hundred` itself was modified which is different from string functions which return a new string as we saw last time. Strings are immutable but `list`s are mutable!\n",
    "\n",
    "## Nested `list`s\n",
    "Now let's look at nested `list`s or `list` of `list`s. Nested `list`s usually confuse newbie programmers whether they're learning arrays or vectors in another language or `list`s in Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "337adc32",
   "metadata": {},
   "outputs": [],
   "source": [
    "nested = [\n",
    "    [1, 2, 3],\n",
    "    [4, 5, 6],\n",
    "    [7, 8, 9],\n",
    "    [10, 11, 12],\n",
    "    [13, 14, 15],\n",
    "    [16, 17, 18],\n",
    "    [19, 20, 21],\n",
    "]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a73d36b",
   "metadata": {},
   "source": [
    "😵‍ <-- Accurate representation of newbies encountering nested vectors. The key to understanding nested data structures is to understand what you're selecting per index.\n",
    "\n",
    "For example, earlier I sliced the first four elements of the `animals` `list`. That returned a `list` which I indexed again for a string which was finally indexed for a single character.\n",
    "\n",
    "Look at `nested` above. What are the elements of the `list`?\n",
    "\n",
    "Each element of `nested` is a `list`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "a3edaa51",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[7, 8, 9]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nested[2]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "194481cf",
   "metadata": {},
   "source": [
    "Each `list` in `nested` contains an integer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "6b3b2f25",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nested[4][1]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71f3dac7",
   "metadata": {},
   "source": [
    "Multi-indexing selects dimensions until we reach the final layer. Another way to think of a 2D array or `list` is that they have x and y coordinates. A 3D array has an additional z axis.\n",
    "\n",
    "Indexing multidimensional structures peels back the dimensions starting from the outer layer. Look at the definition for `nested` again. `nested` is a single `list` that contains other `list`s; the outer later is thus just a `list`. The inner layer consists of the selected `list`. In other words, the inner layer is the selected `list` given by `nested[4]`.\n",
    "\n",
    "An array with three dimensions operates similarly except with the addition of an extra dimension.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ae7b165e",
   "metadata": {},
   "outputs": [],
   "source": [
    "third_dimension = [\n",
    "    [[1, 2, 3], [4, 5, 6]],\n",
    "    [[7, 8, 9], [10, 11, 12]],\n",
    "    [[14, 15, 16], [17, 18, 19]],\n",
    "]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11a302c1",
   "metadata": {},
   "source": [
    "`third_dimension` is a `list` of `list`s of `list`s of `int`s. The first index into `third_dimension` selects a `list` of `list`s like you saw with `nested`. However, unlike `nested`, each nested `list` contains another `list` rather than integers. Thus, the second index into `third_dimension` selects a `list` and the third selects an integer.\n",
    "\n",
    "Another way to interpret two dimensional nested arrays is to think of them as rows and columns. The first index into `nested` selects the x coordinate. You can see this in how I defined `nested`: selecting a `list` is selecting the \"row\" or x coordinate. The second index selects a number or the y coordinate.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "6709d804",
   "metadata": {},
   "outputs": [],
   "source": [
    "sales_data = [\n",
    "    [\"name\", \"last_visit\", \"last_spent_usd\", \"total_visits\"],\n",
    "    [\"Bob\", \"2020-08-27\", 52.0, 6],\n",
    "    [\"Alice\", \"2019-01-17\", 13.4, 2],\n",
    "    [\"Jeff\", \"2021-02-14\", 0.0, 1],\n",
    "]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "404c1fc8",
   "metadata": {},
   "source": [
    "Row 0 selects the column names while row 2 is Alice's row."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "0d552e2c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13.4"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sales_data[2][2]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "209fc3a1",
   "metadata": {},
   "source": [
    "The above selects row 2 (Alice) and column 2 (last spent) which is 13.4 for Alice.\n",
    "\n",
    "## Negative indexing\n",
    "\n",
    "Negative indices traverse backward. Unlike positive indexing, negative indexing doesn't have a 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "d20688ae",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ten = list(range(11))\n",
    "\n",
    "ten[-1]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "886b2edb",
   "metadata": {},
   "source": [
    "Negative indexes span from -1 to -`list` length because there isn't a zero."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "cec7471f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ten[-11]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0bd3b29e",
   "metadata": {},
   "source": [
    "# Dictionaries\n",
    "\n",
    "Dictionaries are commonly called hash maps in other programming languages. Both the terms \"dictionary\" as well as \"hash map\" are helpful in grokking `dict`s.\n",
    "\n",
    "Dictionaries **associate a key to a value.** Keys must be immutable whereas values can be either (more on that in a bit)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "d12e72da",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Espeon's Pokédex number is 196.\n",
      "Psyduck's Pokédex number is 54.\n"
     ]
    }
   ],
   "source": [
    "from pprint import pprint\n",
    "\n",
    "pokemon = {\"Espeon\": 196, \"Psyduck\": 54}\n",
    "\n",
    "print(f\"Espeon's Pokédex number is {pokemon['Espeon']}.\")\n",
    "print(f\"Psyduck's Pokédex number is {pokemon['Psyduck']}.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb5205a5",
   "metadata": {},
   "source": [
    "Dictionary values don't have to be immutable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "4b7536ff",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mudkip\n"
     ]
    }
   ],
   "source": [
    "# Not listing all of them :)\n",
    "poke_starters = {\n",
    "    \"grass\": [\"Bulbasaur\", \"Chikorita\", \"Treecko\"],\n",
    "    \"fire\": [\"Charmander\", \"Cyndaquil\", \"Torchic\"],\n",
    "    \"water\": [\"Squirtle\", \"Totodile\", \"Mudkip\"],\n",
    "    \"electric\": [\"Pikachu\"],\n",
    "    \"psychic\": [\"Espeon\"],\n",
    "}\n",
    "\n",
    "# My brother and I liked Mudkip before it was cool!\n",
    "print(poke_starters[\"water\"][-1])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "470cfef5",
   "metadata": {},
   "source": [
    "Another example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "440a5ac3",
   "metadata": {},
   "outputs": [],
   "source": [
    "poke_gen_starters = {\n",
    "    1: {\"grass\": \"Bulbasaur\", \"fire\": \"Charmander\", \"water\": \"Squirtle\"},\n",
    "    2: {\"grass\": \"Chikorita\", \"fire\": \"Cyndaquil\", \"water\": \"Totodile\"},\n",
    "    3: {\"grass\": \"Treecko\", \"fire\": \"Torchic\", \"water\": \"Mudkip\"},\n",
    "}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b44bb986",
   "metadata": {},
   "source": [
    "How would you select \"Mudkip\" from that dictionary? What about \"Charmander\"?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7954e9f8",
   "metadata": {},
   "outputs": [],
   "source": [
    "mudkip = ____\n",
    "print(mudkip)\n",
    "\n",
    "charmander = ____\n",
    "print(charmander)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ddb9091",
   "metadata": {},
   "source": [
    "The Pokémon dictionaries above show idiomatic uses of `dict`s. For example, `poke_gen_starters` naturally maps generations (the keys) to dictionaries that map type to Pokémon species. `poke_gen_starters` composes well with other Python structures."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "55cbc657",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Squirtle', 'Totodile', 'Mudkip']\n"
     ]
    }
   ],
   "source": [
    "water_starters = [starters[\"water\"] for starters in poke_gen_starters.values()]\n",
    "print(water_starters)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1ff8b33",
   "metadata": {},
   "source": [
    "## Dictionary keys and immutability\n",
    "\n",
    "Dictionary keys are hashed. Hash functions convert an input into a unique number barring collisions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "683a3330",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hash of 'Josh': 3763035858534824572\n",
      "Hash of 'Josh': 3763035858534824572\n",
      "Hash of 'Josh': 3763035858534824572\n",
      "Hash of 'josh': 7117055994279087597\n",
      "Hash of 'josh': 7117055994279087597\n",
      "Hash of 'josh': 7117055994279087597\n"
     ]
    }
   ],
   "source": [
    "print(f\"Hash of 'Josh': {hash('Josh')}\")\n",
    "print(f\"Hash of 'Josh': {hash('Josh')}\")\n",
    "print(f\"Hash of 'Josh': {hash('Josh')}\")\n",
    "\n",
    "print(f\"Hash of 'josh': {hash('josh')}\")\n",
    "print(f\"Hash of 'josh': {hash('josh')}\")\n",
    "print(f\"Hash of 'josh': {hash('josh')}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fcfbfea3",
   "metadata": {},
   "source": [
    "Keys are hashed to efficiently allow mapping keys to values. Hashes must be unique. Imagine if \"Josh\" and \"cat\" returned the same hash. A dictionary that included both \"Josh\" and \"cat\" would return the same value.\n",
    "\n",
    "Hashes are only valid on immutable types because a mutable type would cause the hash to change. For example, if strings were mutable and we changed \"Josh\" to \"josh\" then the hash would change as well.\n",
    "\n",
    "Dictionaries themselves are mutable, so we can add new keys and values as we wish."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "f30eec41",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Drampa': 780, 'Espeon': 196, 'Psyduck': 54}\n"
     ]
    }
   ],
   "source": [
    "pokemon[\"Drampa\"] = 780\n",
    "pprint(pokemon)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09547526",
   "metadata": {},
   "source": [
    "Nested dictionaries require retrieving the value and then updating that value. So, for example, let's add to the water starters in the second dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "db900d17",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'electric': ['Pikachu'],\n",
      " 'fire': ['Charmander', 'Cyndaquil', 'Torchic'],\n",
      " 'grass': ['Bulbasaur', 'Chikorita', 'Treecko'],\n",
      " 'psychic': ['Espeon'],\n",
      " 'water': ['Squirtle', 'Totodile', 'Mudkip', 'Piplup']}\n"
     ]
    }
   ],
   "source": [
    "poke_starters[\"water\"].append(\"Piplup\")\n",
    "pprint(poke_starters)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "009b458d",
   "metadata": {},
   "source": [
    "`poke_starters[\"water\"]` retrieves the `list` of water starters on which I called the `append()` method."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a863af3",
   "metadata": {},
   "source": [
    "# Tuples\n",
    "\n",
    "Tuples are immutable sequences. We usually encounter them via functions that return multiple objects that we can unpack into separate variables. Tuples will be more useful later, but for now recognizing them as well as recognizing unpacking is enough. Tuples are also hashable if they contain all immutable types which means they can be used as dictionary keys as well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "486059e8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Psyduck(#54) is a Water type Pokémon.\n"
     ]
    }
   ],
   "source": [
    "# A tuple\n",
    "psyduck = (\"Psyduck\", \"Water\", 54)\n",
    "\n",
    "# Unpacking the tuple\n",
    "poke_name, poke_type, poke_num = psyduck\n",
    "\n",
    "print(f\"{poke_name}(#{poke_num}) is a {poke_type} type Pokémon.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5288f12c",
   "metadata": {},
   "source": [
    "Tuples can't be extended nor may we remove elements like we would with a `list`. Instead,`tuple`s in variables need to be replaced wholesale."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "64bfbdf6",
   "metadata": {},
   "outputs": [],
   "source": [
    "psyduck = (\"Psyduck\", \"Water\", 54, 33)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d183a1c7",
   "metadata": {},
   "source": [
    "I forgot to add the level at which Psyduck evolves into Golduck! Solving this problem with a `tuple` is unlike how we'd approach a `list` or `dict` where I could simply edit the value at the old collection. Instead, the value in `psyduck` has to be replaced. Thus, `psyduck` now contains an entirely new `tuple`.\n",
    "\n",
    "Tuples are essentially small, anonymous composite types. [Named tuples](https://docs.python.org/3/library/collections.html#collections.namedtuple) is a type in that spirit. Psyduck is a Pokémon, but the `tuple`'s fields are unnamed which leaves programmers to guess their meaning. The numbers 54 and 33 mean little out of context.\n",
    "\n",
    "Named tuples reduce some of the anonymity associated with `tuples` by allowing identifying fields."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "310d3d85",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pokemon(species='Psyduck', type='Water', pokedex=54, evolve_lvl=33)\n"
     ]
    }
   ],
   "source": [
    "from collections import namedtuple\n",
    "\n",
    "# Yeah, this is simplistic.\n",
    "# And yeah, Pokémon may have more than one type.\n",
    "pokemon = namedtuple(\"Pokemon\", [\"species\", \"type\", \"pokedex\", \"evolve_lvl\"])\n",
    "\n",
    "psyduck = pokemon(\"Psyduck\", \"Water\", 54, 33)\n",
    "print(psyduck)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7b265a5",
   "metadata": {},
   "source": [
    "# Sets\n",
    "\n",
    "A `set` is a data type comparable to mathematical sets. Sets contain unique elements and preclude duplicates.\n",
    "\n",
    "For example, the set of integers wouldn't contain two of the same number such as two 1s. The set of Pokémon species names wouldn't contain two Espeons. Likewise, the set of our class wouldn't contain two copies of \"Josh Megnauth.\"\n",
    "\n",
    "Sets in math are written as $Z = \\{0, 1, 2, 3...\\}$. Python's `set` is constructed similarly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "8aee5fd3",
   "metadata": {},
   "outputs": [],
   "source": [
    "Z = {0, 1, 2, 3, 4, 5, 6, 7}\n",
    "pokemon = {\"Bulbasaur\", \"Ivysaur\", \"Venusaur\"}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90f9b48c",
   "metadata": {},
   "source": [
    "Set elements must be hashable just like `dict` keys.\n",
    "\n",
    "**Question:** Why? _Hint: The answer is the same as why dictionary keys must be hashable._\n",
    "\n",
    "Python `set`s support common operations such as cardinality, intersection, difference, symmetric difference, union, et cetera. Clever use of `set`s save time and effort as well as look cleaner than equivalent solutions.\n",
    "\n",
    "Like `list`s and `dict`s, `set` operations may be called through symbols (operators) or functions.\n",
    "\n",
    "|Operation|Operator|Function|\n",
    "|:-:|:-:|:-:|\n",
    "|Cardinality|N/A|`len(a)`|\n",
    "|Intersection|`a & b`|`a.intersection(b)`|\n",
    "|Difference|`a - b`|`a.difference(b)`|\n",
    "|Symmetric diff|`a ^ b`|`a.symmetric_difference(b)`|\n",
    "|Union|`a \\| b`|`a.union(b)`|\n",
    "|Disjoint|N/A|`a.isdisjoint(b)`|\n",
    "|Subset|`a <= b`|`a.issubset(b)`|\n",
    "|Proper subset|`a < b`|(Operator function)|\n",
    "|Superset|`a >= b`|`a.issuperset(b)`|\n",
    "|Proper superset|`a > b`|(Operator function)|\n",
    "\n",
    "## Intersection\n",
    "\n",
    "The intersection is the set of common elements in two or more sets. Basic set theory is much easier to understand with examples, so let's turn to Pokémon once again! (You don't need to know Pokémon for this of course.)\n",
    "\n",
    "$water = \\{Mudkip, Marshtomp, Vaporeon\\}$\n",
    "\n",
    "$ground = \\{Phanpy, Flygon, Marshtomp\\}$\n",
    "\n",
    "$water \\cap ground = \\{Marshtomp\\}$\n",
    "\n",
    "Marshtomp is the only common element in both sets. Thus, the intersection of sets `water` and `ground` is a set containing Marshtomp.\n",
    "\n",
    "Let's turn to Python now. N.b. I used [Bulbapedia](https://bulbapedia.bulbagarden.net/wiki/List_of_type_combinations_by_abundance)'s excellent lists so I didn't go crazy trying to remember a bunch of type combinations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "0151acb6",
   "metadata": {},
   "outputs": [],
   "source": [
    "pokemon_water = {\n",
    "    \"Azumarill\",\n",
    "    \"Golduck\",\n",
    "    \"Gorebyss\",\n",
    "    \"Horsea\",\n",
    "    \"Krabby\",\n",
    "    \"Marshtomp\",\n",
    "    \"Mudkip\",\n",
    "    \"Poliwhirl\",\n",
    "    \"Popplio\",\n",
    "    \"Psyduck\",\n",
    "    \"Slowking\",\n",
    "    \"Starmie\",\n",
    "    \"Swampert\",\n",
    "    \"Vaporeon\",\n",
    "    \"Wailord\",\n",
    "    \"Wooper\",\n",
    "}\n",
    "\n",
    "pokemon_fire = {\n",
    "    \"Blaziken\",\n",
    "    \"Camerupt\",\n",
    "    \"Chandelure\",\n",
    "    \"Charizard\",\n",
    "    \"Flareon\",\n",
    "    \"Groudon\",\n",
    "    \"Litten\",\n",
    "    \"Moltres\",\n",
    "    \"Ninetails\",\n",
    "    \"Pansear\",\n",
    "    \"Rapidash\",\n",
    "    \"Typhlosion\",\n",
    "}\n",
    "\n",
    "pokemon_ground = {\n",
    "    \"Camerupt\",\n",
    "    \"Dugtrio\",\n",
    "    \"Flygon\",\n",
    "    \"Golem\",\n",
    "    \"Groudon\",\n",
    "    \"Marowak\",\n",
    "    \"Marshtomp\",\n",
    "    \"Phanpy\",\n",
    "    \"Rhyhorn\",\n",
    "    \"Sandslash\",\n",
    "    \"Swampert\",\n",
    "    \"Wooper\",\n",
    "}\n",
    "\n",
    "pokemon_psychic = {\n",
    "    \"Alakazam\",\n",
    "    \"Espeon\",\n",
    "    \"Girafarig\",\n",
    "    \"Grumpig\",\n",
    "    \"Jynx\",\n",
    "    \"Latios\",\n",
    "    \"Malamar\",\n",
    "    \"Meowstic\",\n",
    "    \"Mew\",\n",
    "    \"Slowking\",\n",
    "    \"Starmie\",\n",
    "    \"Wynaut\",\n",
    "}\n",
    "\n",
    "pokemon_dragon = {\n",
    "    \"Altaria\",\n",
    "    \"Charizard\",\n",
    "    \"Dragonite\",\n",
    "    \"Drampa\",\n",
    "    \"Exeggutor\",\n",
    "    \"Flygon\",\n",
    "    \"Garchomp\",\n",
    "    \"Goodra\",\n",
    "    \"Latios\",\n",
    "    \"Rayquaza\",\n",
    "    \"Salamence\",\n",
    "    \"Zygarde\",\n",
    "}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a257918b",
   "metadata": {},
   "source": [
    "Notice that Pokémon overlap within the sets because some of them have multiple types.\n",
    "\n",
    "Sets only contain one of each element. I'll demonstrate this first before intersections."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "6d0af5b5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Azumarill',\n",
      " 'Golduck',\n",
      " 'Gorebyss',\n",
      " 'Horsea',\n",
      " 'Krabby',\n",
      " 'Marshtomp',\n",
      " 'Mudkip',\n",
      " 'Poliwhirl',\n",
      " 'Popplio',\n",
      " 'Psyduck',\n",
      " 'Slowking',\n",
      " 'Starmie',\n",
      " 'Swampert',\n",
      " 'Vaporeon',\n",
      " 'Wailord',\n",
      " 'Wooper'}\n"
     ]
    }
   ],
   "source": [
    "pokemon_water.add(\"Mudkip\")\n",
    "pokemon_water.add(\"Mudkip\")\n",
    "pokemon_water.add(\"Mudkip\")\n",
    "pokemon_water.add(\"Mudkip\")\n",
    "pokemon_water.add(\"Mudkip\")\n",
    "\n",
    "pprint(pokemon_water)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec52204d",
   "metadata": {},
   "source": [
    "Notice that \"Mudkip\" is still present only once in the `set`. A `list` is different as you've seen in class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "efb6ce41",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Mudkip', 'Mudkip', 'Mudkip', 'Mudkip', 'Mudkip', 'Mudkip', 'Mudkip', 'Mudkip']\n"
     ]
    }
   ],
   "source": [
    "lots_o_mudkipz = [\"Mudkip\"]\n",
    "lots_o_mudkipz.append(\"Mudkip\")\n",
    "lots_o_mudkipz.append(\"Mudkip\")\n",
    "lots_o_mudkipz.append(\"Mudkip\")\n",
    "lots_o_mudkipz.append(\"Mudkip\")\n",
    "lots_o_mudkipz += [\"Mudkip\", \"Mudkip\", \"Mudkip\"]\n",
    "\n",
    "pprint(lots_o_mudkipz)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf85c12c",
   "metadata": {},
   "source": [
    "Now let's look at few intersections:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "a6d30f25",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'Water & fire: set()'\n",
      "\"Water & ground: {'Wooper', 'Swampert', 'Marshtomp'}\"\n",
      "\"Fire & dragon: {'Charizard'}\"\n"
     ]
    }
   ],
   "source": [
    "pprint(f\"Water & fire: {pokemon_water & pokemon_fire}\")\n",
    "pprint(f\"Water & ground: {pokemon_water & pokemon_ground}\")\n",
    "pprint(f\"Fire & dragon: {pokemon_fire & pokemon_dragon}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a53f22fe",
   "metadata": {},
   "source": [
    "**Questions:**\n",
    "1. Why is $water \\cap fire$ an empty `set`?\n",
    "\n",
    "2. What can you say about the other two intersections based on the `set`s returned?\n",
    "\n",
    "3. Is there any difference between `pokemon_psychic & pokemon_ground` and `pokemon_psychic.intersection(pokemon_ground)`?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8362391e",
   "metadata": {},
   "source": [
    "## Difference\n",
    "\n",
    "Set differences return the elements in the left set that are **not** in the right set.\n",
    "\n",
    "$water = \\{Mudkip, Marshtomp, Vaporeon\\}$\n",
    "\n",
    "$ground = \\{Phanpy, Flygon, Marshtomp\\}$\n",
    "\n",
    "$water \\backslash ground = \\{Mudkip, Vaporeon\\}$\n",
    "\n",
    "And in Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "5618c6ff",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(\"Fire - dragon: {'Flareon', 'Blaziken', 'Typhlosion', 'Moltres', \"\n",
      " \"'Chandelure', 'Pansear', 'Ninetails', 'Camerupt', 'Groudon', 'Litten', \"\n",
      " \"'Rapidash'}\")\n"
     ]
    }
   ],
   "source": [
    "pprint(f\"Fire - dragon: {pokemon_fire - pokemon_dragon}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "129f5921",
   "metadata": {},
   "source": [
    "## Symmetric difference\n",
    "\n",
    "Symmetric differences are the complement of intersections. In other words, symmetric difference results in a set containing the elements that are unique to each set.\n",
    "\n",
    "$water = \\{Mudkip, Marshtomp, Vaporeon\\}$\n",
    "\n",
    "$ground = \\{Phanpy, Flygon, Marshtomp\\}$\n",
    "\n",
    "$water \\triangle ground = \\{Mudkip, Vaporeon, Phanpy, Flygon\\}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "dac55663",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(\"Water ^ Ground: {'Popplio', 'Krabby', 'Phanpy', 'Marowak', 'Flygon', \"\n",
      " \"'Horsea', 'Golduck', 'Psyduck', 'Wailord', 'Azumarill', 'Slowking', \"\n",
      " \"'Groudon', 'Rhyhorn', 'Sandslash', 'Starmie', 'Poliwhirl', 'Camerupt', \"\n",
      " \"'Vaporeon', 'Golem', 'Mudkip', 'Dugtrio', 'Gorebyss'}\")\n"
     ]
    }
   ],
   "source": [
    "pprint(f\"Water ^ Ground: {pokemon_water ^ pokemon_ground}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c24332d",
   "metadata": {},
   "source": [
    "## Union\n",
    "\n",
    "Unions return the set of **all** unique elements in both sets.\n",
    "\n",
    "$water = \\{Mudkip, Marshtomp, Vaporeon\\}$\n",
    "\n",
    "$ground = \\{Phanpy, Flygon, Marshtomp\\}$\n",
    "\n",
    "$water \\cup ground = \\{Mudkip, Marshtomp, Vaporeon, Phanpy, Flygon\\}$\n",
    "\n",
    "Notice that elements from both sets were included but Marshtomp was not duplicated."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "efb0cfc9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(\"Dragon | psychic: {'Espeon', 'Altaria', 'Garchomp', 'Alakazam', 'Grumpig', \"\n",
      " \"'Starmie', 'Meowstic', 'Flygon', 'Charizard', 'Jynx', 'Exeggutor', \"\n",
      " \"'Malamar', 'Drampa', 'Zygarde', 'Wynaut', 'Dragonite', 'Goodra', 'Mew', \"\n",
      " \"'Salamence', 'Rayquaza', 'Slowking', 'Latios', 'Girafarig'}\")\n"
     ]
    }
   ],
   "source": [
    "pprint(f\"Dragon | psychic: {pokemon_dragon | pokemon_psychic}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58bdf079",
   "metadata": {},
   "source": [
    "# Python built in functions and collections\n",
    "\n",
    "[Built in functions](https://docs.python.org/3/library/functions.html)\n",
    "\n",
    "Idiomatic Python makes use of built in functions such as `sum()`, `sorted()`, or `max()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "fb870a63",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[82, 15, 4, 95, 36, 32, 29, 18, 95, 14]\n",
      "Max value: 95\n",
      "Min value: 4\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "random.seed(42)\n",
    "random_ints = [random.randint(1, 100) for _ in range(10)]\n",
    "\n",
    "print(random_ints)\n",
    "print(f\"Max value: {max(random_ints)}\")\n",
    "print(f\"Min value: {min(random_ints)}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b37f2ad",
   "metadata": {},
   "source": [
    "## Questions\n",
    "\n",
    "1. Select Jeff's \"total_visits\" by indexing `sales_data`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "116a4317",
   "metadata": {},
   "outputs": [],
   "source": [
    "sales_data[_][_]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "449c2cb8",
   "metadata": {},
   "source": [
    "2. Insert the missing number using a `list` method (check the link!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9b53345f",
   "metadata": {},
   "outputs": [],
   "source": [
    "missing = [1, 3, 4, 5, 6]\n",
    "\n",
    "missing.___\n",
    "\n",
    "missing\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41c0a72b",
   "metadata": {},
   "source": [
    "3. Actually, I don't like the `missing` `list` anymore. Which function clears the `list`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "07e3e631",
   "metadata": {},
   "outputs": [],
   "source": [
    "missing.____\n",
    "\n",
    "missing\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10a9201f",
   "metadata": {},
   "source": [
    "4. Let's add new starters to `poke_starters`! Add \"Turtwig\" to the grass `list` in the dictionary and \"Chimchar\" to the fire `list`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2861f81e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Turtwig\n",
    "poke_starters[___].___\n",
    "\n",
    "# Chimchar\n",
    "____\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ec1fae7",
   "metadata": {},
   "source": [
    "5. Are `list`s mutable or immutable? Based on this, can we use `list`s as **keys** for dictionaries?\n",
    "6. Calculate the mean of `random_ints`. Hint: Look at the built in functions. You need two different functions.\n",
    "\n",
    "(As an aside, the standard library has a `mean()` function and you can use that if you figure it out.)\n",
    "\n",
    "$\\bar{x} = \\frac{\\sum_{i=1}^{N}x_i}{N}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "45abfb97",
   "metadata": {},
   "outputs": [],
   "source": [
    "____ / ____\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dfab7e8e",
   "metadata": {},
   "source": [
    "7. Add generation 4's starters to `poke_gen_starters`.\n",
    "\n",
    "* Turtwig = Grass\n",
    "* Chimchar = Fire\n",
    "* Piplup = Water"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3230811e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ignore this line\n",
    "poke_gen_starters[4] = {}\n",
    "\n",
    "poke_gen_starters[___][___] = ____\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "61bf1097",
   "metadata": {},
   "source": [
    "Python's `frozenset` is an immutable set.\n",
    "\n",
    "8. Why are the following legal?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6e8e5820",
   "metadata": {},
   "outputs": [],
   "source": [
    "cats = {frozenset({\"Espeon\", \"Litten\", \"Skitty\"}): \"Cats\"}\n",
    "\n",
    "cats_two = {\"Cats\": frozenset({\"Espeon\", \"Litten\", \"Skitty\"})}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f7c850a",
   "metadata": {},
   "source": [
    "9. Convert `sales_data` to a `dict` where the columns are the keys."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "47adec23",
   "metadata": {},
   "outputs": [],
   "source": [
    "pprint(sales_data)\n",
    "\n",
    "sales_data_d = {}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc672893",
   "metadata": {},
   "source": [
    "10. Append a new row to `sales_data` as well as `sales_data_d`.\n",
    "\n",
    "* Name: Mary\n",
    "* Last visit: 2018-04-04\n",
    "* Last spent: 24.56\n",
    "* Total visits: 3\n",
    "\n",
    "_Hint:_ Check out [this page](https://docs.python.org/3/library/stdtypes.html#mapping-types-dict) for dictionary functions!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5390c2df",
   "metadata": {},
   "outputs": [],
   "source": [
    "new_row_list = []\n",
    "sales_data.____\n",
    "\n",
    "new_row_dict = {}\n",
    "sales_data_d.____\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a428224",
   "metadata": {},
   "source": [
    "11. The tuple for the _Economist_ is missing the website. How do we add it? _Hint:_ Remember that tuples are immutable.\n",
    "\n",
    "The site is https://www.economist.com/ so you don't have to look it up."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ca0d6f47",
   "metadata": {},
   "outputs": [],
   "source": [
    "awesome_periodicals = [\n",
    "    (\"New Yorker\", \"https://www.newyorker.com/\"),\n",
    "    (\"New York Times\", \"https://www.nytimes.com/\"),\n",
    "    (\"Economist\", \"\"),\n",
    "]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5f1e907",
   "metadata": {},
   "source": [
    "[Next: Control flow](https://github.com/joshuamegnauth54/data765-intro-python-tutoring/blob/main/notebooks/03-control_flow.ipynb)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.10.5 64-bit",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.10"
  },
  "vscode": {
   "interpreter": {
    "hash": "e7370f93d1d0cde622a1f8e1c04877d8463912d04d973331ad4851f04de6915a"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}