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><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>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><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: Looping through a dictionary"
   ]
  },
  {
   "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\"}"
   ]
  },
  {
   "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": [
    "### <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>**<span style=\"color:crimson\">LOGIC** Here we will create a new dictionary from the data in the `grades_dict`. 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."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "View the `grade_dict`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(grade_dict)"
   ]
  },
  {
   "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 = round(float(statistics.mean(grade_list)), 2)\n",
    "    final_dict[student] = final_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(final_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br>Working with messy data: a messy example"
   ]
  },
  {
   "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. "
   ]
  },
  {
   "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>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><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_3Day\". 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/aGitHasNoName/pythonBootcamp_3Day/main/alice.txt\n",
    "!wget https://raw.githubusercontent.com/aGitHasNoName/pythonBootcamp_3Day/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 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": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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": [
    "new_alice = \"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(new_alice, \"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(new_alice, \"r\") as f:\n",
    "    print(f.read())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br>You will get more practice with files this afternoon."
   ]
  },
  {
   "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>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>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><span style=\"color:red\">Exercise: Writing a function"
   ]
  },
  {
   "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>More function practice"
   ]
  },
  {
   "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><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 dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br><span style=\"color:red\">Dictionaries Exercise 1"
   ]
  },
  {
   "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>**Create your own dictionary.** Choose at least 5 characters from books/movies/tv/comics and create a dictionary. Each character should have a value, which can be anything you'd like about the character. Type and store the dictionary below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>Which character is your favorite? Write code to index the value of your favorite character:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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>To return an individual dictionary, you use list indexing because each dictionary is an item in the list:"
   ]
  },
  {
   "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, and then index the key in your key:value pair of interest:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gradebook[2][\"HW1\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>Looping through the list:"
   ]
  },
  {
   "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>That code worked well, but it wouldn't work if more than 3 homework assignments were added. Instead, you can loop through the list and then loop through the dictionary. I've included comments in the code to explain what I'm doing:"
   ]
  },
  {
   "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><br><span style=\"color:red\">Dictionaries Exercise 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "grade_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><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/aGitHasNoName/pythonBootcamp_3Day/main/dogs.txt\n",
    "!wget https://raw.githubusercontent.com/aGitHasNoName/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 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_file, \"r\") as f:\n",
    "    print(f.read())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>In the lecture, we learned that we can save this text as a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(dog_file, \"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_file, \"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\">Files Exercise 1"
   ]
  },
  {
   "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 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_file, \"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": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br>Turning a file into a dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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": [
    "Let's do this one together."
   ]
  },
  {
   "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": {},
   "source": [
    "### <br><br>Writing files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br><span style=\"color:red\">Files Exercise 2"
   ]
  },
  {
   "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"
   ]
  },
  {
   "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><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 1"
   ]
  },
  {
   "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 2"
   ]
  },
  {
   "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": {},
   "source": [
    "## <br><br><br>Day 3 Quiz"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On your own, complete 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/aGitHasNoName/pythonBootcamp_3Day/blob/main/day3Quiz.ipynb>."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>If you have questions about the quiz material, send me an email.\n",
    "<br><br>As a reminder, 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/aGitHasNoName/pythonBootcamp_3Day/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",
   "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.8.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}