day3Lecture.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <br><br><span style=\"color:purple\">Python Fundamentals Bootcamp - Day 3</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <br><br><span style=\"color:teal\">More About Modules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br>Importing modules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A quick bonus lesson about importing modules. Later in this notebook we are going to be using the `mean()` function again, from the `statistics` module. We learned yesterday that we can import the package like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import statistics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "statistics.mean([6, 4, 2, 7, 6])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This can sometimes make our function names long, like `statistics.variance()`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also import modules with a shortened nickname so that we don't have to type out the full module name every time we use a function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import statistics as st"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "st.mean([6, 4, 2, 7, 6])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "OR, if we know that we are only going to use one or two functions from a module, we can import only those functions. *When we do this, we do not have to include the module name when calling the function*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from statistics import mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mean([6, 4, 2, 7, 6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from statistics import mean, mode"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mean([6, 4, 2, 7, 6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mode([6, 4, 2, 7, 6])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br>A very quick lesson on installing modules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can install and update Python modules onto your computer using the command line, but you can also do it from inside a Jupyter Notebook. We don't have time to cover command line in this workshop, but I will teach you a shortcut.<br><br>If you use `!` directly before a command in a Jupyter Notebook, it tells the computer that you are going to be speaking to the computer in your command line language instead of Python. We will practice by installing Pandas, which is a very commonly-used package for working with dataframes, and making sure the Statistics package is upgraded."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install pandas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install statistics --upgrade"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>*Huge caveat:* If you are working in Jupyter Lab, you will sometimes need to restart Jupyter Lab before the packages will be available to import. There are more complicated workarounds for this, but I think everyone is ok to have to restart once in a while. YOU **DO NOT** NEED TO RESTART RIGHT NOW."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br>Today's Objects\n",
    "- Dictionaries\n",
    "- Files\n",
    "\n",
    "### Today's Functions\n",
    "- *Writing your own functions*\n",
    "\n",
    "### Today's Concepts\n",
    "- looping through dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <br><br><br><br><span style=\"color:teal\">Files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <br>First, where are the files we are working with today?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <br>*If you are using Jupyter Lab:*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The files should be in your working directory - where you are right now - \"pythonBootcamp_4Day-main\". You should see them in the filetree on the left side of your screen (if the files aren't visible, click on the folder icon on the top left)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <br>*If you are using Google Colab:*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You will need to run the line of code directly below this to upload the files from GitHub. *Do not run the next line if you are not using Google Colab.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!wget https://raw.githubusercontent.com/nuitrcs/pythonBootcamp_4Day/main/alice.txt\n",
    "!wget https://raw.githubusercontent.com/nuitrcs/pythonBootcamp_4Day/main/dogs.txt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br><br>Reading files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>We will be working with two files: \"alice.txt\" and \"dogs.txt\". We can first store the names of the files we will be working with as strings. I've chosen some basic variable names:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "alice_filename = \"alice.txt\"\n",
    "dog_filename = \"dogs.txt\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br>Python has a basic way to open files, but I'm going to teach you the better way. The way I teach you is the way all Python coders open files. You may someday encounter a logic situation where you need to use the old way to open a file, so I'll show the syntax to you briefly."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`f = open(filename, \"r\")`\n",
    "<br>*`#do something with the file`*\n",
    "<br>`f.close()`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This leaves the file needlessly open until you close it, which takes up memory. It also leaves you open to potentially forgetting to close the file.\n",
    "<br><br>Files tend to take up more memory inside Python than other Python objects like strings, lists, and dictionaries."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br>with/as statement: The better way to open files "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is the syntax to read a file. (This code isn't ready to run, it's just to look at to see the syntax.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(filename, \"r\") as f:\n",
    "    #save file as some other object\n",
    "    #or save part of a file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first line is the **with/as** statement. The `f` is a temporary variable that will store the **file object**. Just like in a for loop, you can use anything for the temporary variable, but `f` is commonly used.\n",
    "<br><br>**Inside** the with/as statement, you want to save the file as a different object type - something that doesn't take up as much memory as a file.\n",
    "<br><br>The file will automatically close when we exit the with/as statement (exit the indentation)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>**The open function**\n",
    "<br>The `open()` function takes two arguments: the filename and the mode."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mode options:\n",
    "- \"r\"  read\n",
    "- <span style=\"color:red\">\"w\"  write (wipes the file clean if it already exists)\n",
    "- \"a\"  append (add to the end of whatever is already in the file)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>**Filenames**\n",
    "<br>If you are accessing a file in your current working directory, you can just include the filename, but if the file is in a different directory, you must include either the relative or absolute path."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br>Let's try opening the file \"alice.txt\" and printing it to see what it looks like. We will use the read mode:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(alice_filename, \"r\") as f:\n",
    "    print(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>The file object isn't directly readable, so we need to change it into another object before exiting the with/as statement."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <br><br>Storing a file as a string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use a file object method function, `read()`, to change the file object into a string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(alice_filename, \"r\") as f:\n",
    "    alice_text = f.read()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have now exited the with/as statement, so the file is closed. `alice_text` is stored in memory, but `f` is closed and cannot be accessed again without reopening the file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(alice_text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f.read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(alice_text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br>Notice that `alice_text` is now stored as one long string. Sometimes you will want that. Other times it will be convenient to instead store your text as a list of individual lines instead of one big string."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <br><br>Storing a file as a list of strings (lines)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To store the text as a list of strings, use the file method `readlines()`. This will break the whole text up by any new line characters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(alice_filename, \"r\") as f:\n",
    "    alice_list = f.readlines()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(alice_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(alice_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for line in alice_list:\n",
    "    print(line)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>**Question:** The `len()` function told us that the list was 7 lines long, but when we print it it looks like there are only 4 lines. What do you think is causing that? What code could you run to test your theory?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br>We can now do anything with this list that we could do with any other list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for line in alice_list:\n",
    "    if \"Alice\" in line:\n",
    "        print(line)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br>As a reminder, the `f` variable I've been using in the with/as statement is a temporary variable that can be anything, just like when writing a for loop. `f` is just a commonly used shorthand in with/as statements. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(alice_filename, \"r\") as FN_2187:\n",
    "    alice_list = FN_2187.readlines()\n",
    "len(alice_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><span style=\"color:red\">Exercise: Reading a file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We saved another filename as `dog_filename`. Write a with/as statement to open the file in read mode. Inside the with/as statement, save the file as **one long string** called `dog_string`. Then, outside the with/as statement, print the string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a with/as statement to open the `dog_filename` file in read mode. Inside the with/as statement, save the file as **a list of lines** called `dog_list`. Then, outside the with/as statement, print the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br><br>Writing files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Remember that when you open a file in write mode, it will first create a new empty file. If you already have a file with the same name, it will empty that file.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's work with our `alice_list`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for line in alice_list:\n",
    "    print(line)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>Let's open a new file and write the Alice text without those extra empty new lines."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, we'll save the name we want for our new file as a string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "alice_out = \"alice_clean.txt\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we will open this new file in **write mode** using a with/as statement. Inside that statement, we will write each line of the `alice_list` as long as the line contains more than just the new line character. To write, we use the file method `write()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(alice_out, \"w\") as f:\n",
    "    for line in alice_list:\n",
    "        if line != \"\\n\":\n",
    "            f.write(line)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>To check the file, we can open it in read mode. We will just print the file inside the with/as statement without even saving it as a string or list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(alice_out, \"r\") as f:\n",
    "    print(f.read())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br>Turning a file into a clean list of lines"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's read in the dog file and see what it looks like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(dog_filename, \"r\") as f:\n",
    "    print(f.read())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>In the morning, we learned that we can save this text as a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(dog_filename, \"r\") as f:\n",
    "    dog_list = f.readlines()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(dog_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>Each item in the list is a string. Most lines end in a new line character, which we would like to remove."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can combine what we learned today about opening files with what we learned yesterday about making new lists in a for loop with what we learned on Day 1 about string functions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, make an empty list. Now, inside the with/as statement, you can loop through the lines in the file and append them to the empty list. But you also need to use a string function to remove the new line characters:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dog_list = []\n",
    "with open(dog_filename, \"r\") as f:\n",
    "    for line in f.readlines():\n",
    "        dog_list.append(line.rstrip(\"\\n\"))\n",
    "print(dog_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>A clean list of dogs!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br><span style=\"color:red\">Exercise: Cleaning files as we read them"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Make a clean list of dogs from the dog_file that only includes dogs with the word \"terrier\" in their names. I've pasted the code we wrote to make a list of all dogs. You need to edit this code to add an if statement inside the for loop to only append the terriers.  *Bonus: while you're at it, make the dog names all lowercase.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dog_list = []\n",
    "with open(dog_filename, \"r\") as f:\n",
    "    for line in f.readlines():\n",
    "        dog_list.append(line.rstrip(\"\\n\"))\n",
    "print(dog_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br><span style=\"color:red\">Exercise: Writing to a file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's write our new dog_list (which should only contain terriers) to a file. First, check the list to confirm that it looks okay."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dog_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now create the variable `terrier_out` and save the filename you want to use for your list of terriers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "terrier_out = \"\" #Enter your filename between the quotation marks."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use a with/as statement to open the `terrier_out` file in **write mode**. Inside the with/as statement, you need to loop through the `dog_list` and write each item to `f`. You will also need to write a new line character after each dog."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br>You will get more practice with files this afternoon."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <br><br><span style=\"color:teal\">Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "During yesterday's lecture, we practiced looping through fictional characters from Avengers, Star Wars, and Moana. But how did the computer know who was in which movie, or who could fly?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A dictionary is **a collection of *key: value* pairs.** \n",
    "- Dictionaries are surrounded by curly brackets {}\n",
    "- **key: value pairs** inside the dictionary are separated by commas\n",
    "- In each **key: value pair**, the key and value are separated by a colon :\n",
    "- The key must always be a string\n",
    "- The value can be any object"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>Here's a dictionary of heights, in inches. The keys are people's names and the values are integers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "inches_dict = {\"Jo\": 60, \"Rae\": 68, \"Tom\": 65}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`dict` *is a common abbreviation for a dictionary in Python.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>This dictionary has info about someone's mom. The keys are trait categories and the values are a mix of integers and strings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mom_dict = {\"height\": 65, \"eyes\": \"hazel\", \n",
    "            \"hair\": \"gray\", \"age\": 70}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>This dictionary contains results of an experiment. The keys are the names of the test runs and the values are lists of floats:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "results = {\"test1\": [3.4, 0.2, 1.4, 2.2, 8.0], \n",
    "           \"test2\": [0.9, 3.4, 2.5, 4.7, 2.6], \n",
    "           \"test3\": [4.9, 2.4, 0.4, 8.4, 2.5]}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*If a dictionary is long, you can write it on multiple lines, just like a list.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br>Indexing a dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "grade_dict = {\"Charlie\": [90, 96, 89, 79], \n",
    "              \"Tony\": [99, 98, 96, 93], \n",
    "              \"Suman\": [85, 88, 83, 87],\n",
    "              \"Yuvie\": [66, 76, 80, 62],\n",
    "              \"May\": [97, 94, 89, 91]}\n",
    "\n",
    "print(grade_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>**Unlike lists, dictionaries are indexed by the name of the key. They cannot be indexed by position in the dictionary.** In the latest versions of Python, dictionaries are saved in order, but the purpose of a dictionary isn't to keep entries in numerical order - would you ever need to know what the 110th word in the Oxford English Dictionary is?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "grade_dict[\"Tony\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "grade_dict[3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>To index something inside a value, first index the key, then the position in the value. In our `grade_dict` example, the values are lists, so to index Tony's last grade:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "grade_dict[\"Tony\"][-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><span style=\"color:red\">Exercise: Creating and indexing dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a dictionary called `favorites`. The keys should be \"color\", \"food\", and \"song\". The values should be your favorite color, food, and song. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write code to index your favorite song:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write code to index the third letter of your favorite food."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br>Adding an entry to a dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You don't have to use a function to add to a dictionary. Just **index** a new key and **assign** it a value:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's look at the `grade_dict` as it is now, and then add a new student."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(grade_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "grade_dict[\"Ben\"] = [60, 57, 63]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(grade_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>If the item already exists in the dictionary, you will overwrite it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "grade_dict[\"Ben\"] = [82, 88, 90]\n",
    "print(grade_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You should always be careful that your dictionary keys are unique."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><span style=\"color:red\">Exercise: Adding to dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Add a new key:value pair to your `favorites` dictionary. The key could be tv_show, movie, book, or anything else you'd like to add. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(favorites)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br>Looping through a dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for entry in grade_dict:\n",
    "    print(entry)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you have an updated version of Python 3, it will print out the keys in the order you gave them when you first created the dictionary. If you have a slightly older version of Python 3, it might give you an error."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>We can, and should, be more explicit to tell the computer that we want to loop through only the keys by adding the `keys()` method to the end of our dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for key in grade_dict.keys():\n",
    "    print(key)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or we can loop through the values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for value in grade_dict.values():\n",
    "    print(value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>Remember that we can give our temporary variable any name we want in our for loop. This is commonly used:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for k in grade_dict.keys():\n",
    "    print(k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for v in grade_dict.values():\n",
    "    print(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>But it's also good to use more appropriate variable names:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for student in grade_dict.keys():\n",
    "    print(student)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for grade_list in grade_dict.values():\n",
    "    print(grade_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><span style=\"color:red\">Exercise: Looping through a dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a dictionary called `favorites`. The keys should be \"color\", \"food\", and \"song\". The values should be your favorite color, food, and song. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Add a new key:value pair to your `favorites` dictionary. The key could be tv_show, movie, book, or anything else you'd like to add. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write code to loop through the keys of your favorites dictionary. Print out each key."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>Write code to loop through the values of your favorites dictionary. Print out each value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br><br>We can also loop through both the keys and values using the `items()` method. We include two temporary variables in our `for` loop statement instead of one:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for k, v in grade_dict.items():\n",
    "    print(k)\n",
    "    print(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for student, grade_list in grade_dict.items():\n",
    "    print(student)\n",
    "    print(grade_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><span style=\"color:red\">Exercise: Looping through a dictionary, both keys and values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write code to loop through both the keys and values of your favorites dictionary. Print out a full sentence for each favorite, like \"My favorite color is purple.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br><br>Since our values are list objects, we can also use a **nested loop** to loop through both the dictionary and the lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for student, grade_list in grade_dict.items():\n",
    "    print(student)\n",
    "    for grade in grade_list:\n",
    "        print(grade)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That code is called a **nested loop** - a loop inside a loop!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><span style=\"color:red\">Exercise: Nested loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run the cell below to store the `nicknames` dictionary. The keys are the full names, and the values are the nicknames."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nicknames = {\"Charles\": \"Charlie\", \n",
    "             \"Anthony\": \"Tony\", \n",
    "             \"Suman\": \"Suman\", \n",
    "             \"Yuval\": \"Yuvie\", \n",
    "             \"May-Lin\": \"May\", \n",
    "             \"Benjamin\": \"Ben\",\n",
    "             \"Keesha\": \"Keesha\"}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a nested loop to print out each letter in each person's nickname:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Hint: You must first decide if you need to loop through the keys, the values, or both. Do you need both to get the job done, or only the keys, or only the values?*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br>Filtering a dictionary\n",
    "Just like we did with a list, we will want to combine a for loop with an if statement (or an if/elif/else statement).\n",
    "<br><br>Let's practice with our `nicknames` dictionary. Some of the nicknames are the same as the full names. Let's loop through the dictionary. If the person has a nickname that is different than their full name, we will print out a sentence like \"Catherine goes by Katie.\" If they do not have a different nickname, we will print out a sentence like \"Kelsey does not have a nickname.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nicknames = {\"Charles\": \"Charlie\", \n",
    "             \"Anthony\": \"Tony\", \n",
    "             \"Suman\": \"Suman\", \n",
    "             \"Yuval\": \"Yuvie\", \n",
    "             \"May-Lin\": \"May\", \n",
    "             \"Benjamin\": \"Ben\",\n",
    "             \"Keesha\": \"Keesha\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for k, v in nicknames.items:\n",
    "    if k != v:\n",
    "        print(k + \" goes by \" + v + \".\")\n",
    "    else:\n",
    "        print(k + \" does not have a nickname.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br><span style=\"color:red\">Exercise: Filtering dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's an example dictionary. Run the cell below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hero_dict = {\"Captain Marvel\": \"Avengers\", \"Finn\": \"Star Wars\", \n",
    "             \"Maui\": \"Moana\", \"Captain America\": \"Avengers\", \n",
    "             \"Princess Leia\": \"Star Wars\"}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>Using `hero_dict`, write a for loop/if statement to print the name of all of the characters in Star Wars: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br>Adding key:value pairs to an empty dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Yesterday we learned how to loop through a list and add items to a new empty list. We can also do that with dictionaries.\n",
    "<br><br>We will work with the grade_dict we used earlier:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "grade_dict = {\"Charlie\": [90, 96, 89, 79], \n",
    "              \"Tony\": [99, 98, 96, 93], \n",
    "              \"Suman\": [85, 88, 83, 87],\n",
    "              \"Yuvie\": [66, 76, 80, 62],\n",
    "              \"May\": [97, 94, 89, 91],\n",
    "              \"Ben\": [82, 88, 90]}\n",
    "\n",
    "print(grade_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br>**<span style=\"color:crimson\">LOGIC** Here we will create a new dictionary from the data in the grades_dict. For the new dictionary, the keys will be the students' names and the values will be their final score for the class. The final score will be calculated as the mean of all the scores in their grade list. We can use the mean function from the statistics package."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import statistics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>First, we create an empty dictionary. Next, we loop through the old dictionary, calculate each person's final grade, and add them to the new dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_dict = {}\n",
    "for student, grade_list in grade_dict.items():\n",
    "    final_score = statistics.mean(grade_list)\n",
    "    final_dict[student] = final_score\n",
    "print(final_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>We can make the dictionary look more consistent by rounding all the numbers to two places after the decimal point:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_dict = {}\n",
    "for student, grade_list in grade_dict.items():\n",
    "    final_score = round(statistics.mean(grade_list), 2)\n",
    "    final_dict[student] = final_score\n",
    "print(final_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>The round function won't include trailing zeros, like on 96.5. We can make the dictionary look a little more consistent by changing the whole numbers, like 71, to floats:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_dict = {}\n",
    "for student, grade_list in grade_dict.items():\n",
    "    final_score = round(float(statistics.mean(grade_list)), 2)\n",
    "    final_dict[student] = final_score\n",
    "print(final_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br>List of dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes it is useful to have a list of dictionaries because that is how your data is best represented. You can index individual data points in the list or dictionaries, and you can loop through both levels."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gradebook = [{\"name\": \"Zygon\", \"HW1\": 10, \"HW2\": 10, \"HW3\": 10}, \n",
    "             {\"name\": \"Vogon\", \"HW1\": 10, \"HW2\": 10, \"HW3\": 10}, \n",
    "             {\"name\": \"Cylon\", \"HW1\": 10, \"HW2\": 10, \"HW3\": 10}, \n",
    "             {\"name\": \"Mudokon\", \"HW1\": 7, \"HW2\": 8, \"HW3\": 6}]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>**Indexing a list of dictionaries**\n",
    "<br>To return an individual dictionary, you use list indexing because each dictionary is an item in the list. What do you think this will return?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gradebook[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>To return a value in one of the dictionaries, you first index the dictionary's place in the list, and then index the key in your key:value pair of interest. What do you think this will return?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gradebook[3][\"HW1\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>**Looping through a list of dictionaries**\n",
    "<br>**<span style=\"color:crimson\">LOGIC** Let's print out a full sentence for each student. The sentence should report the sum of all the student's homework assignment grades."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's often useful to first just print each item in a loop, to confirm that you know what you're looking at. I do this all the time when I code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for dictionary in gradebook:\n",
    "    print(dictionary)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then you can do more and slowly build up your loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for dictionary in gradebook:\n",
    "    name = dictionary[\"name\"]\n",
    "    print(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for dictionary in gradebook:\n",
    "    name = dictionary[\"name\"]\n",
    "    HW_total = dictionary[\"HW1\"] + dictionary[\"HW2\"] + dictionary[\"HW3\"]\n",
    "    print(HW_total)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for dictionary in gradebook:\n",
    "    name = dictionary[\"name\"]\n",
    "    HW_total = dictionary[\"HW1\"] + dictionary[\"HW2\"] + dictionary[\"HW3\"]\n",
    "    print(name + \" scored \" + str(HW_total) + \" points on Homework\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>This code is ok, but it wouldn't work if more than 3 homework assignments were added. Let's say you teach the same class next year and you want to reuse the code, only next year you give 4 homework assignments instead of 3. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>When there are details in the code specific to your data, we say they are **hard coded**.\n",
    "<br><br>As a beginner, you will do a lot of hard coding to solve your problems, but if you ever want to reuse your scripts or share them with someone else, you will need to try to not hard code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>Instead, you can loop through the list and then loop through the dictionary (a **nested loop**). \n",
    "<br><br>I've included **comments** in the code to explain what I'm doing. Comments start with a `#` and are ignored by the computer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for dictionary in gradebook: #loop through the list\n",
    "    name = dictionary[\"name\"] #get student's name\n",
    "    HW_total = 0 \n",
    "    for k, v in dictionary.items(): #loop through the key:value pairs\n",
    "        if k != \"name\": #get every key:value pair except name\n",
    "            HW_total = HW_total + v #add the value to our HW total\n",
    "    print(name + \" scored \" + str(HW_total) + \" points on Homework\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>**OR**<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for dictionary in gradebook: #loop through the list\n",
    "    name = dictionary[\"name\"] #get student's name\n",
    "    HW_total = 0 \n",
    "    for v in dictionary.values(): #loop through the values only\n",
    "        if type(v) != str: #get every value except name, which is a string\n",
    "            HW_total = HW_total + v #add the value to our HW total\n",
    "    print(name + \" scored \" + str(HW_total) + \" points on Homework\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br>Dictionary of dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also format your data as a dictionary of dictionaries."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><span style=\"color:red\">Exercise: Indexing a nested dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gradebook_dict = {\"Zygon\": {\"HW1\": 3, \"HW2\": 2, \"HW3\": 4}, \n",
    "              \"Vogon\": {\"HW1\": 10, \"HW2\": 10, \"HW3\": 10}, \n",
    "              \"Cylon\": {\"HW1\": 10, \"HW2\": 10, \"HW3\": 10}, \n",
    "              \"Mudokon\": {\"HW1\": 7, \"HW2\": 8, \"HW3\": 6}}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use dictionary indexing to write code to return all of Cylon's grades:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use dictionary indexing to write code to return Vogon's score on HW2:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>**<span style=\"color:crimson\">LOGIC** If you remember, one of our students, \"Ben\", only had 3 grades entered, while everyone else had 4. That's something we might want to know when we're calculating final grades. Let's add an if/else statement to our code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_dict = {}\n",
    "for student, grade_list in grade_dict.items():\n",
    "    if len(grade_list) >= 4:\n",
    "        final_score = statistics.mean(grade_list)\n",
    "        final_dict[student] = final_score\n",
    "    else:\n",
    "        print(student + \" is missing grades.\")\n",
    "print(final_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>This code is ok, but it contains that number `4` for the length of the list. Let's say you teach the same class next year and you want to reuse the code, only next year you give 5 tests instead of 4. So right now our code is **hard coded**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>First, let's change our grade dictionary to reflect Ben's missing grade. The grade dictionary looks like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "grade_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>Ben's value is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "grade_dict[\"Ben\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br> We can reflect Ben's missing grade by adding another data point to Ben's list. Ben's value in the dictionary is a list, so we can index the list and then append to it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "grade_dict[\"Ben\"].append(\"Missed\")\n",
    "print(grade_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>Now we will remove the hard coding and instead handle the missing data through a try/except statement. First, let's run the previous code we wrote, but with our altered grade_dict, in order to get the error that we want to except:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_dict = {}\n",
    "for student, grade_list in grade_dict.items():\n",
    "    if len(grade_list) >= 4:\n",
    "        final_score = statistics.mean(grade_list)\n",
    "        final_dict[student] = final_score\n",
    "    else:\n",
    "        print(student + \" is missing grades.\")\n",
    "print(final_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>The error gets thrown because we added a string, `Missed`, to the `grade_list`. Python cannot calculate the mean of a list that includes a string. <br><br>Instead of specifying \"4\" as the number of grades required, we can use a try/except statement that references the error we just saw:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_dict = {}\n",
    "for student, grade_list in grade_dict.items():\n",
    "    try:\n",
    "        final_grade = statistics.mean(grade_list)\n",
    "        final_dict[student] = final_grade\n",
    "    except TypeError:\n",
    "        print(student + \" has missing grades.\")\n",
    "\n",
    "print(final_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <br><br><span style=\"color:rebeccapurple\">LUNCH BREAK - meet back at 1 pm Central"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <br><br><span style=\"color:teal\">More fun with files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### *If you are using Google Colab ONLY, run this line:*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!wget https://raw.githubusercontent.com/nuitrcs/pythonBootcamp_3Day/main/dogs.txt\n",
    "!wget https://raw.githubusercontent.com/nuitrcs/pythonBootcamp_3Day/main/gradebook.csv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br>**Everyone:** Store the filenames that we will be working with today:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dog_file = \"dogs.txt\"\n",
    "gradebook_file = \"gradebook.csv\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br>Turning a file into a dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll work through this example together. Let's open the gradebook file and see what it looks like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(gradebook_file, \"r\") as f:\n",
    "    print(f.read())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>**<span style=\"color:crimson\">LOGIC** **Our end goal is to have a dictionary with the student's name as the key and a list of their grades as the values.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>Ok, first let's store it as a list, but we want to leave out the first line of headers. When we call `f.readlines()` it turns the file into a list. We can index a list, so let's take all the lines except the first one:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(gradebook_file, \"r\") as f:\n",
    "    gradebook = f.readlines()[1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for line in gradebook:\n",
    "    print(line)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that there are new line characters at the end of each line (because it is printing extra empty lines between the lines). Let's make a note of that."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>We can apply what we know about lists and strings to make a list of what we need to code:\n",
    "- make an empty dictionary\n",
    "- loop through the gradebook list\n",
    "- remove the new line characters from the end\n",
    "- split the line on the commas\n",
    "- separate the first item to be the key\n",
    "- store the rest of the items as a list\n",
    "- assign the key:value pairs to our dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I've put **comments** in the code to remind us of what we need to do. Comments start with a `#` symbol and are ignored by the computer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#make an empty dictionary\n",
    "#loop through the gradebook list\n",
    "#remove the new line characters from the end\n",
    "#split the line on the commas\n",
    "#separate the first item to be the key\n",
    "#store the rest of the items as a list\n",
    "#assign the key:value pairs to our dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(grade_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>**Question:** We wrote out all the steps and wrote the code with one line per step. This code could be condensed into fewer lines or left how it is - as explicit as possible. **Can you think of ways that the code could be condensed to fewer lines?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "### <br><br>Writing files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### <span style=\"color:red\">Exercise: Reformatting data as we write it to a file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**<span style=\"color:crimson\">LOGIC** We just created a dictionary, `grade_dict`. The first three items in each value are homework grades. **Write a new file** that includes one complete sentence for each student in the dictionary. The sentence should include the student's name and their three homework grades. A sample sentence is \"Mary's homework grades are 10, 7, and 9.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>You will need to:\n",
    "- store a variable that contains the filename of the new file you want to create (I recommend you use the extension \".txt\".)\n",
    "- write a with/as statement to open the new file in write mode\n",
    "- loop through both the keys and values in the key:value pairs in the `grade_dict` dictionary\n",
    "- store a string that composes a sentence that uses the key (student's name) and indexes each of the first three items in the value\n",
    "- add a new line character to the end of the string so that each student will have their own line in the file\n",
    "- use `f.write()` to write the string to the `f` file object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br>Reading files line by line - demo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes you might be working with a very large file, with millions of lines, and you don't want to read it all into memory as a string or list."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is a file method, `readline()`, that reads in only one line at a time. **I don't expect you to practice this method here, but I will give an example, so that you know it exists if you ever need to look it up.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's imagine that there are millions of types of dogs (if only!) and our dogs.txt file is millions of lines long. We can use readline to loop through it and only store the dogs that we need for this notebook or script. This doesn't work the same way as `readlines()` because `readlines()` is a list and `readline()` is the string of only the first line. We need to use a while loop, which is something we aren't learning this week:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hounds = []\n",
    "with open(dog_file, \"r\") as f:\n",
    "    line = f.readline()\n",
    "    while line:\n",
    "        if \"hound\" in line:\n",
    "            hounds.append(line.rstrip(\"\\n\").lower())\n",
    "        line = f.readline()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(hounds)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <br><br><br><br><span style=\"color:teal\">Writing Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>You already know how to **call** a function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(\"How long is this string?\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "round(6479.382029, -2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br>You can also write your own custom functions. Why would you want to do that?\n",
    "- If you find yourself using the same code repeatedly, so that you don't have to write it over and over\n",
    "- If you want to break your code up into chunks to make it much more readable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>To create our own function, we create a **function definition**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function definition starts with a **def statement**.\n",
    "<br><br>The next line (inside the indentation) should be a short **comment** that says what your function does. This is just good practice. Comments start with a `#` and are ignored by Python. \n",
    "<br><br>Next (still inside the def statement), you write the code for what the function does."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is the syntax. (This code won't work, it's just to look at.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def function_name(arguments, if_needed):\n",
    "    #a useful comment\n",
    "    do something or create a new object"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <br><br>Writing a function with no arguments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First we'll write a function that just does something whenever it's called. It takes no arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hello():\n",
    "    # Prints Hello!\n",
    "    print(\"Hello!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br> Let's call the `hello()` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hello()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <br><br>Writing a function with one argument"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can add an argument. Whatever you call the arguments in your function definition must match exactly to how they are used inside the function definition, just like we saw with for loops and with/as statements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hello_you(name):\n",
    "    #Prints Hello You! replacing You with whatever string you give it.\n",
    "    print(\"Hello \" + name + \"!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can pass it any string as an argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hello_you(\"Eeyore\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br><span style=\"color:red\">Functions Exercise 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a function called `birthdayAge` that prints out a happy birthday message like \"Happy Birthday! You are 10 years old!\" The age should be provided as an argument when the function is called."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Test your function with this call:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "birthdayAge(86)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <br><br>Writing a function that returns an object"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's write our own function to find the area of a rectangle."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The arguments our function will need are length and width. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def area(length, width):\n",
    "    #This function takes a length and width of a rectangle and returns the area.\n",
    "    answer = length * width"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "area(10, 12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(answer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br><br>So we created `answer` inside our function definition, but it doesn't exist outside that definition. We need to include a **return statement** if we want our function to return the value of an object created inside the function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def area(length, width):\n",
    "    #This function takes a length and width of a rectangle and returns the area.\n",
    "    answer = length * width\n",
    "    return answer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "area(10, 12)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>Like any function, we can assign the output of a custom function to a variable. Let's say my kitchen is 10 feet long and 12 feet wide:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "kitchen_area = area(10, 12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(kitchen_area)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>Also like other functions, we can pass variables to the function as our arguments:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "kitchen_l = 10\n",
    "kitchen_w = 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "kitchen = area(kitchen_l, kitchen_w)\n",
    "print(kitchen)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br><span style=\"color:red\">Functions Exercise 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define a function called `initials`. It should take two strings as arguments - `first` and `last`. The function should return the first letters of each argument, combined into one string.\n",
    "<br><br>For example, if I called `initials(\"Colby\", \"Wood\")` it should return `'CW'`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Test the function with your name:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Did you remember to include a comment in your function?*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <br><br><span style=\"color:teal\">More fun with functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's write a simple function to convert a volume in teaspoons to a volume in cups. There are 48 teaspoons in 1 cup."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def tspToCup(tsp):\n",
    "    #converts a number from tsps to cups\n",
    "    return tsp / 48"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tspToCup(8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's improve it by rounding the answer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def tspToCup(tsp):\n",
    "    #converts a number from tsps to cups\n",
    "    cup = round(tsp / 48, 2)\n",
    "    return cup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tspToCup(8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br><span style=\"color:red\">Functions Exercise 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a function to convert  miles per hour to kilometers per hour. 1 mph is equal to 1.60934 kph. Round the answer to the nearest kph."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Test your function with 60 mph."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br><span style=\"color:red\">Functions Exercise 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is a dictionary containing the conversion factors from 1 pound to a variety of other units of weight or mass:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pound_dict = {\"ounce\": 16, \"gram\": 453.592, \"kilogram\": 0.453592, \n",
    "              \"ton\": 0.0005, \"stone\": 0.0714286}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>Write a function called `poundTo` that takes two arguments, a weight in pounds and the unit of measure that you want to convert it to, as included in the dictionary above. The function should return the converted weight. For example, someone might call `poundTo(150, \"stone\")` and the function should return `10.71`. The answer should be rounded to 2 places after the decimal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Test your function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "poundTo(150, \"stone\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### <br><br>Code along "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's try to create a new title function that won't capitalize letters after an apostrophe. We'll walk through it together."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is how the string method `title()` works:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"I'll be there\".title()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <br><br><br>Day 3 Quiz"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Test yourself on what you learned today by completing the Day 3 Quiz. The Jupyter Notebook file is called \"day3Quiz.ipynb\" and is in the same folder as this notebook. If you are using Colab, go to <https://colab.research.google.com/github/nuitrcs/pythonBootcamp_4Day/blob/main/day3Quiz.ipynb>."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>The quiz is self-graded - you do not need to turn anything in! The answer key is called \"day3Quiz-answers.ipynb\". For Colab users, the answer key is at <https://colab.research.google.com/github/nuitrcs/pythonBootcamp_4Day/blob/main/day3Quiz-answers.ipynb>."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**The last question of the quiz is a real thinking question that will take some time. There are many ways to do it - the answer key contains several different answers.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}