day2Lecture-answers.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <br><br><span style=\"color:rebeccapurple\">Python Fundamentals Bootcamp - Day 2</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>Yesterday afternoon, we learned more string functions.\n",
    "All functions have limitations and some work in interesting ways.\n",
    "<br><br>For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"I'Ll Be There\""
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"I'll be there\".title()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>The L in I'll should not be capitalized, but that's how the function works. For now, don't get too hung up on the limits of a particular function!\n",
    "<br><br>Tomorrow, we'll walk through how you can use what you've learned (and some logic) to create a work around for the `title()` method."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br>Today's Objects\n",
    "- Lists\n",
    "\n",
    "### Today's Functions\n",
    "- List functions\n",
    "\n",
    "### Today's Concepts\n",
    "- `for` loops\n",
    "- `if` statements\n",
    "- basic error handling"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <br><span style=\"color:teal\">Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**A list is a collection of objects kept in a strict order. <br>A list is surrounded by square brackets. <br>Items in the list are separated by commas.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br>A list can contain any type of object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "grades = [93, 75, 80, 98, 100, 64, 88]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Remember that when we assign variables, nothing is returned.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "students = [\"Alex\", \"Billy\", \"Casey\", \"Drake\", \"Ellis\", \"Frankie\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Notice that using square brackets is all that you need to tell Python that you are creating a list. You do not need to use a function.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(students)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>A list can also contain only one item:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_grade = [90]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>A list can be empty:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_grades = []"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>You can even have a list of lists, called a **nested list**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "gradebook = [[\"Casey\", \"Taylor\", \"Lee\"], [93, 75, 80]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br><span style=\"color:red\">Exercise: List syntax"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a new variable called `family` and store the names of your family members as a list (or choose your favorite TV family!). Don't forget that each name should be stored as a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "family = [\"Bob\", \"Linda\", \"Tina\", \"Gene\", \"Louise\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Bob', 'Linda', 'Tina', 'Gene', 'Louise']\n"
     ]
    }
   ],
   "source": [
    "print(family)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br>List functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's learn some list functions. While we're learning list functions, we'll also learn a bit about how the list object works."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As a review, there are two types of functions: \n",
    "1. those that take a list as an argument and do something *with* the list\n",
    "2. methods that follow the list and do something *to* the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "grades = [93, 75, 80, 98, 100, 64, 88]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `len()` function that we learned with strings also works with lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(grades)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br>The `sort()` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "grades.sort()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hmm, nothing was returned."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[64, 75, 80, 88, 93, 98, 100]\n"
     ]
    }
   ],
   "source": [
    "print(grades)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uh oh. Our list has changed order. **Unlike strings, list methods can change the list object even if you didn't save the changed object as a new variable.** This is because lists are **mutable** objects, whereas strings, integers, floats, and booleans are **immutable** objects."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>*Be careful with list methods, as they will change your object!* We'll talk more about how to get around this later in this lecture. We'll also see why it's useful to have lists be mutable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br>The `append()` method will add a new item to the end of a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "students = [\"Alex\", \"Billy\", \"Casey\", \"Drake\", \"Ellis\", \"Frankie\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "students.append(\"Gavi\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just like all objects, you can return the variable value by either just running the name of the variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Alex', 'Billy', 'Casey', 'Drake', 'Ellis', 'Frankie', 'Gavi']"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "students"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or by printing the variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Alex', 'Billy', 'Casey', 'Drake', 'Ellis', 'Frankie', 'Gavi']\n"
     ]
    }
   ],
   "source": [
    "print(students)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br>Regular functions (not methods) will not change your list, because they do something *with* your object, not something *to* your object. The `sum()` function will give you the sum of a list of numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "grades = [93, 75, 80, 98, 100, 64, 88]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "598"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(grades)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[93, 75, 80, 98, 100, 64, 88]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grades"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br>We can use comparison operators with lists, just like other objects:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "students = [\"Alex\", \"Billy\", \"Casey\", \"Drake\", \"Ellis\", \"Frankie\"]\n",
    "grades = [93, 75, 80, 98, 100, 64, 88]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(students) == len(grades)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(students) > len(grades)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br><span style=\"color:red\">Exercise: List functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run the cell below to store the list `colors`. Write code to append a new color of your choice to the list `colors`. Then write code to return the length of the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "colors = [\"navy blue\", \"gold\", \"silver\", \"scarlet\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "colors.append(\"teal\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(colors)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br>We can use some arithmetic operators with lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "grades = [93, 75, 80, 98, 100, 64, 88]\n",
    "more_grades = [70, 93]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[93, 75, 80, 98, 100, 64, 88, 70, 93]\n"
     ]
    }
   ],
   "source": [
    "grades = grades + more_grades\n",
    "print(grades)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for -: 'list' and 'list'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[0;32mIn [29]\u001b[0m, in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m grades \u001b[38;5;241m=\u001b[39m \u001b[43mgrades\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mmore_grades\u001b[49m\n\u001b[1;32m      2\u001b[0m \u001b[38;5;28mprint\u001b[39m(grades)\n",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for -: 'list' and 'list'"
     ]
    }
   ],
   "source": [
    "grades = grades - more_grades\n",
    "print(grades)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>You can't subtract lists!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[93, 75, 80, 98, 100, 64, 88, 70, 93, 93, 75, 80, 98, 100, 64, 88, 70, 93, 93, 75, 80, 98, 100, 64, 88, 70, 93, 93, 75, 80, 98, 100, 64, 88, 70, 93]\n"
     ]
    }
   ],
   "source": [
    "print(grades * 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[93, 75, 80, 98, 100, 64, 88, 70, 93]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grades"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br>List indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Indexing works just like it does in strings (the first item is indexed as 0)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "students = [\"Alex\", \"Billy\", \"Casey\", \"Drake\", \"Ellis\", \"Frankie\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Alex'"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "students[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ellis'"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "students[-2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Billy', 'Casey', 'Drake']"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "students[1:4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>We can change the value of individual items in a list using indexing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Alex', 'Billy', 'Casey', 'Drake', 'Ellis', 'Frankie']"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "students"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To change Billy to Billie, I can assign the new string \"Billie\" to \"Billy\"'s indexed position in the list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "students[1] = \"Billie\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Alex', 'Billie', 'Casey', 'Drake', 'Ellis', 'Frankie']"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "students"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br><span style=\"color:red\">Exercise: List indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run the code cell below to store the list `states`. Write code to change \"Illinois\" to \"Indiana\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "states = [\"Hawaii\", \"Kentucky\", \"Illinois\", \"Iowa\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "states[2] = \"Indiana\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Hawaii', 'Kentucky', 'Indiana', 'Iowa']\n"
     ]
    }
   ],
   "source": [
    "print(states)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br><br>Indexing is a great example that illustrates the difference between a functional language like R and an object oriented language like Python. There is no `replace()` function for lists. Instead, you can use indexing to replace an item in a list..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "students = [\"Alex\", \"Billy\", \"Casey\", \"Drake\", \"Ellis\", \"Frankie\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "students[0] = \"Alexis\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Alexis', 'Billy', 'Casey', 'Drake', 'Ellis', 'Frankie']"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "students"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>... or you can use a `for loop` to make lots of different changes to a list, which we will learn later this morning."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br><span style=\"color:red\">Exercise - Code along to learn more about lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want more practice typing code, follow along with me. Otherwise, just watch me code and try to spot what I do differently between example 1 and example 2."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "frodo = [\"hobbit\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "sam = [\"hobbit\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['hobbit']"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frodo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['hobbit']"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "frodo.append(\"ring\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['hobbit', 'ring']"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frodo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['hobbit']"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sam"
   ]
  },
  {
   "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": [
    "Example 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "harry = [\"wizard\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "ron = harry"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['wizard']"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "harry"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['wizard']"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ron"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "harry.append(\"scar\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['wizard', 'scar']"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "harry"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['wizard', 'scar']"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ron"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>**What did we do differently between example 1 and example 2?**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "harry = [\"wizard\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "ron = harry.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['wizard']"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "harry"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['wizard']"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ron"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "harry.append(\"scar\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['wizard', 'scar']"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "harry"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['wizard']"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ron"
   ]
  },
  {
   "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:teal\">for loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before we start coding with \"for loops\", let's talk about how they work - **DEMO in the slides**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br>We're going to work with a list of student grades."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "grades = [73, 64, 89, 93, 59, 100, 79]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>When writing the for loop, the lines **inside** the loop are indented. You can use four spaces or one tab to indent. Jupyter Lab, Google Colab, and many other Python IDEs will automatically change a tab into four spaces. This is because all the indentations in a script have to match - when using **scripts** you can only use all tabs or all spaces or else you'll get an error - so the IDE does the work for you of making everything match as spaces. *However, when writing scripts in a text editor, you'll need to do the work yourself and make sure they all match*. If you ever watched the show Silicon Valley, now you can understand this scene: https://www.youtube.com/watch?v=SsoOG6ZeyUI. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "73\n",
      "64\n",
      "89\n",
      "93\n",
      "59\n",
      "100\n",
      "79\n"
     ]
    }
   ],
   "source": [
    "for grade in grades:\n",
    "    print(grade)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Notice that the items are printed in the same order as the list.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>We can change the name of our temporary variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "73\n",
      "64\n",
      "89\n",
      "93\n",
      "59\n",
      "100\n",
      "79\n"
     ]
    }
   ],
   "source": [
    "for g in grades:\n",
    "    print(g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "73\n",
      "64\n",
      "89\n",
      "93\n",
      "59\n",
      "100\n",
      "79\n"
     ]
    }
   ],
   "source": [
    "for sandwich in grades:\n",
    "    print(sandwich)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>Let's say we want to give each student an extra 5 points:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "78\n",
      "69\n",
      "94\n",
      "98\n",
      "64\n",
      "105\n",
      "84\n"
     ]
    }
   ],
   "source": [
    "for g in grades:\n",
    "    print(g + 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br><span style=\"color:red\">Exercise: for loop syntax"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run the following cell to store a list of coding languages."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "languages = [\"Python\", \"R\", \"JavaScript\", \"Julia\", \"Swift\", \"C#\", \"PHP\", \"BASIC\", \"C++\", \"Java\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a for loop to print each item in the `languages` list."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Be prepared for the IDE (Jupyter Lab or Google Colab) to automatically indent the line under your for loop.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python\n",
      "R\n",
      "JavaScript\n",
      "Julia\n",
      "Swift\n",
      "C#\n",
      "PHP\n",
      "BASIC\n",
      "C++\n",
      "Java\n"
     ]
    }
   ],
   "source": [
    "for lang in languages:\n",
    "    print(lang)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <br><br>Some common loop errors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Can you see the problem with each of these loops?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "73\n",
      "64\n",
      "89\n",
      "93\n",
      "59\n",
      "100\n",
      "79\n"
     ]
    }
   ],
   "source": [
    "for g in grades:\n",
    "    print(g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "73\n",
      "64\n",
      "89\n",
      "93\n",
      "59\n",
      "100\n",
      "79\n"
     ]
    }
   ],
   "source": [
    "for g in grades:\n",
    "    print(g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "73\n",
      "64\n",
      "89\n",
      "93\n",
      "59\n",
      "100\n",
      "79\n"
     ]
    }
   ],
   "source": [
    "for g in grades:\n",
    "    print(g)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br>Adding items to an empty list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**<span style=\"color:crimson\">LOGIC** *This is a very common task in Python.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>Let's create a new list of grades, giving everyone 5 extra points. As a reminder, run this cell to see our list of grades:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[73, 64, 89, 93, 59, 100, 79]\n"
     ]
    }
   ],
   "source": [
    "print(grades)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, we create a new **empty list**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_grades = []"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then we loop through our original list and **append** the changed items to our new list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "for g in grades:\n",
    "    new_grades.append(g + 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[78, 69, 94, 98, 64, 105, 84]\n"
     ]
    }
   ],
   "source": [
    "print(new_grades)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>If you are working with more complicated calculations, you will want to be more **explicit** by defining a new variable inside the loop instead of doing the calculations inside the `append()` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_grades = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "for g in grades:\n",
    "    new_g = round((g + 5) / 100, 2)\n",
    "    new_grades.append(new_g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.78, 0.69, 0.94, 0.98, 0.64, 1.05, 0.84, 0.78, 0.69, 0.94, 0.98, 0.64, 1.05, 0.84, 0.78, 0.69, 0.94, 0.98, 0.64, 1.05, 0.84, 0.78, 0.69, 0.94, 0.98, 0.64, 1.05, 0.84]\n"
     ]
    }
   ],
   "source": [
    "print(new_grades)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Note: Appending items to a list in a for loop wouldn't work if lists were immutable objects like strings!*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>There's one more thing we should consider. Go up and rerun the code cell with the `for loop` one more time. Then run the cell where we print the value of `new_grades`. Do this a few times and you'll see that there's a problem. Every time we rerun the loop, it's just adding the new grades to that same list.\n",
    "<br><br>Because we're not recreating the empty list in the same code cell as the `for loop`, it's easy to forget to rerun the `new_grades = []` cell every time we run our loop. Especially when we're testing out our code. To prevent this, we should include the creation of the empty list in the same code cell as the `for loop`, like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_grades = []\n",
    "for g in grades:\n",
    "    new_g = round((g + 5) / 100, 2)\n",
    "    new_grades.append(new_g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.78, 0.69, 0.94, 0.98, 0.64, 1.05, 0.84]\n"
     ]
    }
   ],
   "source": [
    "print(new_grades)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br><span style=\"color:red\">Exercise: Adding items to an empty list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Store this list of monthly bills that you pay:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "bills = [115.46, 70.40, 26.90, 170.83, 1250.00, 65.40]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, create a new empty list called `rounded_bills`. Then, loop through the list `bills`. **For** each item in the list, **round** the item to the closest whole number and **append** it to the list `rounded_bills`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [],
   "source": [
    "rounded_bills = []\n",
    "for bill in bills:\n",
    "    new_bill = round(bill)\n",
    "    rounded_bills.append(new_bill)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[115, 70, 27, 171, 1250, 65]\n"
     ]
    }
   ],
   "source": [
    "print(rounded_bills)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[115, 70, 27, 171, 1250, 65]\n"
     ]
    }
   ],
   "source": [
    "rounded_bills = []\n",
    "for bill in bills:\n",
    "    rounded_bills.append(round(bill))\n",
    "print(rounded_bills)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <br><br><span style=\"color:teal\">if statements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These are also called **conditional statements** or even **conditionals**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "source": [
    "grades = [73, 64, 89, 93, 59, 100, 79]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use a series of if/elif/else statements to perform different actions on grades in different ranges:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "73\n",
      "grade is C\n",
      "64\n",
      "grade is D\n",
      "89\n",
      "grade is B\n",
      "93\n",
      "grade is A\n",
      "59\n",
      "grade is Fail\n",
      "100\n",
      "grade is A\n",
      "79\n",
      "grade is C\n"
     ]
    }
   ],
   "source": [
    "for g in grades:\n",
    "    if g >= 90:\n",
    "        print(g)\n",
    "        print(\"grade is A\")\n",
    "    elif g >= 80:\n",
    "        print(g)\n",
    "        print(\"grade is B\")\n",
    "    elif g >= 70:\n",
    "        print(g)\n",
    "        print(\"grade is C\")\n",
    "    elif g >= 60:\n",
    "        print(g)\n",
    "        print(\"grade is D\")\n",
    "    else:\n",
    "        print(g)\n",
    "        print(\"grade is Fail\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>Here we are going to save a new list of grades that only includes grades 60 or higher:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[73, 64, 89, 93, 100, 79]\n"
     ]
    }
   ],
   "source": [
    "passing_grades = []\n",
    "for g in grades:\n",
    "    if g >= 60:\n",
    "        passing_grades.append(g)\n",
    "    else:\n",
    "        pass\n",
    "print(passing_grades)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>We don't have to explicitly pass if the condition isn't met. *You do not need to include an `else` statement.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[73, 64, 89, 93, 100, 79]\n"
     ]
    }
   ],
   "source": [
    "passing_grades = []\n",
    "for g in grades:\n",
    "    if g >= 60:\n",
    "        passing_grades.append(g)\n",
    "print(passing_grades)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Note:* In the code block above, we say the `if statement` is **inside** the `for loop` and the print function is **outside** the `for loop` because the indentation is gone."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>We can also stop the loop if a condition is or isn't met:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[73, 64, 89, 93, 59, 100, 79]\n"
     ]
    }
   ],
   "source": [
    "print(grades)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This student is doing ok.\n",
      "I give up. I quit.\n"
     ]
    }
   ],
   "source": [
    "for g in grades:\n",
    "    if g >= 70:\n",
    "        print(\"This student is doing ok.\")\n",
    "    else:\n",
    "        print(\"I give up. I quit.\")\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>Here I'm switching the order of the last two lines. Take a minute to try and predict what will happen before running the code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This student is doing ok.\n"
     ]
    }
   ],
   "source": [
    "for g in grades:\n",
    "    if g >= 70:\n",
    "        print(\"This student is doing ok.\")\n",
    "    else:\n",
    "        break\n",
    "        print(\"I give up. I quit.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br><span style=\"color:red\">Exercise: Writing if statements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Store this list of Therapod dinosaurs (meat eaters that walk on two legs)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [],
   "source": [
    "therapods = [\"Albertosaurus\", \n",
    "             \"Allosaurus\", \n",
    "             \"Baryonyx\", \n",
    "             \"Carnotaurus\", \n",
    "             \"Coelophysis\", \n",
    "             \"Compsognathus\", \n",
    "             \"Deinonychus\", \n",
    "             \"Giganotosaurus\", \n",
    "             \"Megalosaurus\", \n",
    "             \"Ornithomimus\", \n",
    "             \"Oviraptor\", \n",
    "             \"Saurophaganax\", \n",
    "             \"Spinosaurus\", \n",
    "             \"Tyrannosaurus\", \n",
    "             \"Tyrannotitan\", \n",
    "             \"Velociraptor\",\n",
    "             \"Yangchuanosaurus\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Note: When typing a long list, you can use multiple lines. Try to line up the next line with the first item in the list.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Loop through the list `therapods`. Use string indexing to check **if** the first letter of the dinosaur's name is equal to T. If it is T, print the dinosaur's name. If it is not T, print \"Not T\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Not T\n",
      "Not T\n",
      "Not T\n",
      "Not T\n",
      "Not T\n",
      "Not T\n",
      "Not T\n",
      "Not T\n",
      "Not T\n",
      "Not T\n",
      "Not T\n",
      "Not T\n",
      "Not T\n",
      "Tyrannosaurus\n",
      "Tyrannotitan\n",
      "Not T\n",
      "Not T\n"
     ]
    }
   ],
   "source": [
    "for dino in therapods:\n",
    "    if dino[0] == \"T\":\n",
    "        print(dino)\n",
    "    else:\n",
    "        print(\"Not T\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br>New boolean operator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So far we've learned `<` `>` `<=` `>=` `==` and `!=`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`in` is another Boolean operator. It works for both lists and strings. Take a minute to predict if each boolean statement will return True or False before you run the cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"pie\" in \"pizza pie\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Oreo\" in [\"Chips Ahoy\", \"Oreo\", \"Oatmeal raisin\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cookies = [\"Chips Ahoy\", \"Oreo\", \"Oatmeal raisin\"]\n",
    "\"Oreo\" in cookies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"oreo\" in [\"Chips Ahoy\", \"Oreo\", \"Oatmeal raisin\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Ahoy\" in \"Chips Ahoy\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Ahoy\" in [\"Chips Ahoy\", \"Oreo\", \"Oatmeal raisin\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>We can use the `in` comparison operator with if statements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Chips Ahoy\n"
     ]
    }
   ],
   "source": [
    "cookies = [\"Chips Ahoy\", \"Oreo\", \"Oatmeal raisin\"]\n",
    "for c in cookies:\n",
    "    if \"Ahoy\" in c:\n",
    "        print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br>Let's say we want to give one extra point to anyone who is right on the cusp of getting a better grade:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [],
   "source": [
    "grades = [73, 64, 89, 93, 59, 100, 79]\n",
    "grades_to_round = [59, 69, 79, 89]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, we'll make an empty list to collect the final grades. Then, we'll loop through the `grades` list. If the grade is in the `grades_to_round` list, we'll add one point and append the new grade to the final list. If the grade is not in `grades_to_round`, we'll add the original grade to the final list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_grades = []\n",
    "for g in grades:\n",
    "    if g in grades_to_round:\n",
    "        final_grades.append(g + 1)\n",
    "    else:\n",
    "        final_grades.append(g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[73, 64, 90, 93, 60, 100, 80]\n"
     ]
    }
   ],
   "source": [
    "print(final_grades)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br>There's also `not in`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [],
   "source": [
    "grades = [73, 64, 89, 93, 59, 100, 79]\n",
    "grades_to_round = [59, 69, 79, 89]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_grades = []\n",
    "for g in grades:\n",
    "    if g not in grades_to_round:\n",
    "        final_grades.append(g)\n",
    "    else:\n",
    "        final_grades.append(g + 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[73, 64, 90, 93, 60, 100, 80]\n"
     ]
    }
   ],
   "source": [
    "print(final_grades)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br><span style=\"color:red\">Exercise: The `in` boolean"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Make a list of the toppings you like to eat on your ideal pizza (don't forget to run the cell):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_toppings = [\"olives\", \"carrots\", \"jalapenos\", \"black pepper\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run the cell below to store a list of toppings that are available at the store."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [],
   "source": [
    "store_toppings = [\"pepperoni\", \n",
    "                  \"figs\", \n",
    "                  \"olives\", \n",
    "                  \"pistachios\", \n",
    "                  \"jalapenos\", \n",
    "                  \"mozzarella\", \n",
    "                  \"marscapone\", \n",
    "                  \"tomato sauce\", \n",
    "                  \"garlic\", \n",
    "                  \"mushrooms\", \n",
    "                  \"extra cheese\",\n",
    "                  \"tomatoes\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a new empty list called `final_toppings`. Loop through the `my_toppings` list. If the topping is also in the `store_toppings` list, add it to your `final_toppings`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_toppings = []\n",
    "for top in my_toppings:\n",
    "    if top in store_toppings:\n",
    "        final_toppings.append(top)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['olives', 'jalapenos']\n"
     ]
    }
   ],
   "source": [
    "print(final_toppings)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>*Bonus question:* If the topping in your list is not available at the store, print out a message telling you that the topping isn't available."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "olives available.\n",
      "carrots not available.\n",
      "jalapenos available.\n",
      "black pepper not available.\n",
      "Your final toppings are: olives, jalapenos\n"
     ]
    }
   ],
   "source": [
    "final_toppings = []\n",
    "for top in my_toppings:\n",
    "    if top in store_toppings:\n",
    "        final_toppings.append(top)\n",
    "        print(top + \" available.\")\n",
    "    else:\n",
    "        print(top + \" not available.\")\n",
    "print(\"Your final toppings are: \" + \", \".join(final_toppings))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <br><br><span style=\"color:teal\">Basic error handling"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Short DEMO in the slides.** You will get more practice with try/except this afternoon."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <br><br><span style=\"color:rebeccapurple\">LUNCH BREAK - meet back at 1 pm Central"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### We will get started at 1:02 pm Central"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <br><br><span style=\"color:teal\">More fun with lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br>We are going to use some list functions in this notebook that aren't automatically loaded with Python. They are in a module that is included with Python, called `statistics`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run this cell to import the `statistics` module:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [],
   "source": [
    "import statistics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br>List functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We already learned some list functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [],
   "source": [
    "bananas_in_bunches = [4, 9, 7, 4, 3, 6]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>`sum()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "33\n"
     ]
    }
   ],
   "source": [
    "total_bananas = sum(bananas_in_bunches)\n",
    "print(total_bananas)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>`len()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "how_many_bunches = len(bananas_in_bunches)\n",
    "print(how_many_bunches)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>`append()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 9, 7, 4, 3, 6, 8]\n"
     ]
    }
   ],
   "source": [
    "new_bunch = 8\n",
    "bananas_in_bunches.append(new_bunch)\n",
    "print(bananas_in_bunches)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>`sort()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 4, 4, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "bananas_in_bunches.sort()\n",
    "print(bananas_in_bunches)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>We can also pass a **keyword argument** to the `sort()` function to reverse the sort order of the list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[9, 8, 7, 6, 4, 4, 3]\n"
     ]
    }
   ],
   "source": [
    "bananas_in_bunches.sort(reverse=True)\n",
    "print(bananas_in_bunches)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As a reminder, a **keyword argument** is an argument that has a default value. If you want to use something other than the default value, you have to pass the function the keyword with the new value. So for `sort()` the default of the `reverse` argument is `False`. When we want to reverse it, we need to change `reverse` to `True` by passing it as an argument."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>**More built-in list functions**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "smallest_bunch = min(bananas_in_bunches)\n",
    "print(smallest_bunch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "largest_bunch = max(bananas_in_bunches)\n",
    "print(largest_bunch)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br>As a reminder, to use a function from an imported module, you type the name of the module followed by `.` followed by the name of the function. Let's use `statistics.mean()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.857142857142857\n"
     ]
    }
   ],
   "source": [
    "mean_bunch_size = statistics.mean(bananas_in_bunches)\n",
    "print(mean_bunch_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>`statistics.median()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "median_bunch_size = statistics.median(bananas_in_bunches)\n",
    "print(median_bunch_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br><span style=\"color:red\">Lists Exercise 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>Let's practice finding information online. Use Google to search for the correct Python function to calculate standard deviation, and then write the code to find the standard deviation of `bananas_in_bunches`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bananas_in_bunches = [4, 9, 7, 4, 3, 6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.2677868380553634\n"
     ]
    }
   ],
   "source": [
    "stdev_banana_bunches = statistics.stdev(bananas_in_bunches)\n",
    "print(stdev_banana_bunches)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br><br>Joining items in a list into one string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes you will need to join the items in a list together into a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [],
   "source": [
    "full_name_list = [\"Bartholomew\", \"JoJo\", \"Simpson\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `join()` function is actually a string method. The string you start with is the string that you want to use to connect all the items in the list. Then you pass the list to the function as an argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Bartholomew JoJo Simpson'"
      ]
     },
     "execution_count": 167,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\" \".join(full_name_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Bartholomew-JoJo-Simpson'"
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"-\".join(full_name_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'BartholomewDOHJoJoDOHSimpson'"
      ]
     },
     "execution_count": 169,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"DOH\".join(full_name_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>You can use an empty string to connect all the items in the list with nothing in between:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'BartholomewJoJoSimpson'"
      ]
     },
     "execution_count": 170,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\".join(full_name_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br><span style=\"color:red\">Lists Exercise 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [],
   "source": [
    "path_list = [\"Documents\", \"workshops\", \"bootcamp\", \"tuesday\", \"tuesdayLecture.ipynb\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use the join function to combine these words into one string. The words should be separated by a \"/\" to create a file path."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Documents/workshops/bootcamp/tuesday/tuesdayLecture.ipynb'"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"/\".join(path_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br><br>Splitting a string into a list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another common task is splitting a string into a list. This is also a string method, so let's load a string to practice with:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [],
   "source": [
    "csv_line = \"sample 1,5,24,864,NA,.4556,,,65\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You must pass the `split()` function an argument - what string do you want to use to separate the items for your list. Here we'll use a comma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['sample 1', '5', '24', '864', 'NA', '.4556', '', '', '65']\n"
     ]
    }
   ],
   "source": [
    "csv_line_list = csv_line.split(\",\")\n",
    "print(csv_line_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br><span style=\"color:red\">Lists Exercise 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_data = \"Year: 2005\\nYear: 2007\\nYear: 2010\\nYear: 2011\\nYear: 2015\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run the cell above. We want to turn the string `my_data` into a list of years, without any other text or new lines.\n",
    "<br><br>First, write code to remove every occurrence of \"Year: \" from the string. You'll have to remember a string function you learned yesterday:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2005\n",
      "2007\n",
      "2010\n",
      "2011\n",
      "2015\n"
     ]
    }
   ],
   "source": [
    "my_data_clean = my_data.replace(\"Year: \", \"\")\n",
    "print(my_data_clean)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>Now, write code to split the string into a list of years:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['2005', '2007', '2010', '2011', '2015']\n"
     ]
    }
   ],
   "source": [
    "year_list = my_data_clean.split(\"\\n\")\n",
    "print(year_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>*Challenge:* Change `my_data` into a list of years again, but this time do it in only one line of code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['2005', '2007', '2010', '2011', '2015']\n"
     ]
    }
   ],
   "source": [
    "year_list = my_data.replace(\"Year: \", \"\").split(\"\\n\")\n",
    "print(year_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br>Indexing lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [],
   "source": [
    "days = [\"Sunday\", \"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\", \"Saturday\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Saturday'"
      ]
     },
     "execution_count": 182,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "days[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Wednesday'"
      ]
     },
     "execution_count": 183,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "days[3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Sunday', 'Monday', 'Tuesday', 'Wednesday']"
      ]
     },
     "execution_count": 184,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "days[:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Today is Wednesday\n"
     ]
    }
   ],
   "source": [
    "print(\"Today is \" + days[3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br><span style=\"color:red\">Lists Exercise 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {},
   "outputs": [],
   "source": [
    "months = [\"January\", \"February\", \"March\", \"April\", \n",
    "          \"May\", \"June\", \"July\", \"August\", \"September\", \n",
    "          \"October\", \"November\", \"December\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Note: When typing a long list, you can use multiple lines. Try to line up the next line with the first item in the list.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <br>Run the line of code above. Use list indexing to answer these questions:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Which month has your favorite holiday?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'December'"
      ]
     },
     "execution_count": 187,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "months[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Which months do you consider to be part of Summer?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['June', 'July', 'August', 'September']"
      ]
     },
     "execution_count": 188,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "months[5:9]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What month were you born? Try to print out your answer in a complete sentence that includes your indexed month."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I was born in April.\n"
     ]
    }
   ],
   "source": [
    "print(\"I was born in \" + months[3] + \".\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br>Indexing multiple levels"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can index characters inside a string inside a list. Like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My first name starts with C.\n"
     ]
    }
   ],
   "source": [
    "name = [\"Colby\", \"Witherup\", \"Wood\"]\n",
    "print(\"My first name starts with \" + name[0][0] + \".\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'oo'"
      ]
     },
     "execution_count": 191,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name[2][1:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br>You would use the same style of indexing to index items inside a **nested list**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {},
   "outputs": [],
   "source": [
    "gradebook = [[\"Casey\", \"Maya\", \"Toni\", \"Mae\"], [85, 95, 100, 88]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Try to guess what will be returned before you run the following cells."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Mae'"
      ]
     },
     "execution_count": 193,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gradebook[0][-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "88"
      ]
     },
     "execution_count": 194,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gradebook[1][3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'y'"
      ]
     },
     "execution_count": 195,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gradebook[0][1][2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br><span style=\"color:red\">Lists Exercise 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write your own name as a list of your first, middle, and last names (or however many names you have):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {},
   "outputs": [],
   "source": [
    "full_name = [\"Colby\", \"Witherup\", \"Wood\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write code to index the last letter of your first name:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'y'"
      ]
     },
     "execution_count": 198,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "full_name[0][-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>You ran an experiment 5 times a day for 3 days. These are your results:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {},
   "outputs": [],
   "source": [
    "results = [[.001, .455, .789, .765, .602], \n",
    "           [.67, .899, .482, .847, .585], \n",
    "           [.943, .984, .423, .45, .776]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>What is the value of the very last run on the last day?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.776"
      ]
     },
     "execution_count": 200,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results[-1][-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>What is the minimum value you obtained on the first day of your experiment?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.001"
      ]
     },
     "execution_count": 208,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "min(results[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What is the mean of the values you obtained on your second day?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6966"
      ]
     },
     "execution_count": 202,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "statistics.mean(results[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br>Comparisons between lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><span style=\"color:red\">Lists Exercise 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "metadata": {},
   "outputs": [],
   "source": [
    "characters = [\"Aang\", \"Katara\", \"Sokka\", \"Zuko\", \"Iroh\", \"Toph\"]\n",
    "water_tribe = [\"Katara\", \"Sokka\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Based on the lists above, will the following booleans evaluate to True or False? Try to answer before running the code to check:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 204,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(characters) > len(water_tribe) and len(water_tribe) > 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 205,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Aang\" in water_tribe or \"Sokka\" not in water_tribe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 206,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "characters[3] == water_tribe[1] or characters[0][0] == water_tribe[0][-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <br><br><span style=\"color:teal\">More fun with for loops and if statements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>In today's morning lecture, we walked through one common situation you'll use in your own Python code - looping through a list and appending items to a new list. \n",
    "<br><br>**<span style=\"color:crimson\">LOGIC** Now we'll work through 4 other common situations you'll encounter. These exercises are about applying logic to solve problems - you already know all the objects, functions, and syntax needed to solve these."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br>Example 1 - Doing something with each item in a list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>First, let's store a list of the forecasted high temperatures on Northwestern's Qatar campus for this week:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "metadata": {},
   "outputs": [],
   "source": [
    "c_temps = [43, 42, 42, 42, 43, 44, 41]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>The equation to convert from Celsius to Farenheit is F = C x 9/5 + 32. \n",
    "<br>We can write a for loop to convert our `c_temps` to Farenheit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "109.4\n",
      "107.60000000000001\n",
      "107.60000000000001\n",
      "107.60000000000001\n",
      "109.4\n",
      "111.2\n",
      "105.8\n"
     ]
    }
   ],
   "source": [
    "for temp in c_temps:\n",
    "    f = temp * (9/5) + 32\n",
    "    print(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>Let's improve this output by rounding the temperatures to one digit past the decimal, and by writing a complete sentence:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The high temperature was 109.4 degrees F (43 C).\n",
      "The high temperature was 107.6 degrees F (42 C).\n",
      "The high temperature was 107.6 degrees F (42 C).\n",
      "The high temperature was 107.6 degrees F (42 C).\n",
      "The high temperature was 109.4 degrees F (43 C).\n",
      "The high temperature was 111.2 degrees F (44 C).\n",
      "The high temperature was 105.8 degrees F (41 C).\n"
     ]
    }
   ],
   "source": [
    "for temp in c_temps:\n",
    "    f = temp * (9/5) + 32\n",
    "    f2 = round(f, 1)\n",
    "    print(\"The high temperature was \" + str(f2) + \" degrees F (\" + str(temp) + \" C).\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><span style=\"color:red\">Loops Exercise 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, store this list. It contains the world record fastest 5K times for men and women:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "metadata": {},
   "outputs": [],
   "source": [
    "fastest5k = [12.5833, 14.1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>5 kilometers is equal to 3.10686 miles."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To convert a runner's 5K time to their 1 mile time, use the equation:\n",
    "<br>mile_time = fiveK_time / 3.10686"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>Write a for loop to loop through the `fastest5k` list. Inside the for loop, convert the 5K time to a mile time, round the mile time to two digits after the decimal point, and print the answer in a complete sentence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The 5K time 12.5833 is 4.05 in miles.\n",
      "The 5K time 14.1 is 4.54 in miles.\n"
     ]
    }
   ],
   "source": [
    "for fiveK_time in fastest5k:\n",
    "    mile_time = fiveK_time / 3.10686\n",
    "    round_time = round(mile_time, 2)\n",
    "    print(\"The 5K time \" + str(fiveK_time) + \" is \" + str(round_time) + \" in miles.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The 5K time 12.5833 is 4.05 in miles.\n",
      "The 5K time 14.1 is 4.54 in miles.\n"
     ]
    }
   ],
   "source": [
    "for fiveK_time in fastest5k:\n",
    "    round_time = round(fiveK_time / 3.10686, 2)\n",
    "    print(\"The 5K time \" + str(fiveK_time) + \" is \" + str(round_time) + \" in miles.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br><br>Example 2 - Using all the items in the list to find one number"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This list contains the names of students in your class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "metadata": {},
   "outputs": [],
   "source": [
    "students = [\"Eleven\", \"Dustin\", \"Mike\", \"Will\", \"Lucas\", \"Max\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>On your classroom wall, you want to spell out all of the students' names with one letter per piece of paper, but you need to know how many pieces of paper you need. Luckily, the `len()` function will tell you how many letters are in each name, but you need to tally up the total."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>To do this, you are first going to assign the number zero to a variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "metadata": {},
   "outputs": [],
   "source": [
    "papers = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>Next, you can loop through the list, adding the length of each name to your `papers` variable as you go:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "metadata": {},
   "outputs": [],
   "source": [
    "for student in students:\n",
    "    papers = papers + len(student)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see if it worked:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 224,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "84\n"
     ]
    }
   ],
   "source": [
    "print(papers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>This is a common situation that comes up when you're coding, so it's good to practice it now."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>Remember the lesson we learned earlier today when we created an empty list in a code cell outside the cell where we wrote our `for loop`? Go up and rerun the cell with our `for loop` and then the cell where we print `papers`.\n",
    "<br><br>Oops! We forgot to reset `papers` to 0 before rerunning the `for loop`. We should have written the code in one cell:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 227,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "28\n"
     ]
    }
   ],
   "source": [
    "papers = 0\n",
    "for student in students:\n",
    "    papers = papers + len(student)\n",
    "print(papers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><span style=\"color:red\">Loops Exercise 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>This list contains the dimensions of your new fish tank, in inches:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 228,
   "metadata": {},
   "outputs": [],
   "source": [
    "tank = [32, 17, 31]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>You want to calculate the volume of your fish tank in cubic inches. The equation is length x width x height, but your length, width, and height are stored in your list."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First create a variable called `volume` that contains the number 1. Then, write a for loop to loop through the `tank` list, reassigning the variable `volume` to the product of  each item in the list and `volume`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "metadata": {},
   "outputs": [],
   "source": [
    "volume = 1\n",
    "for side in tank:\n",
    "    volume = volume * side"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now print the variable `volume`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16864\n"
     ]
    }
   ],
   "source": [
    "print(volume)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br><br>Example 3 - Using a for loop with if/elif/else statements to filter the items in a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "metadata": {},
   "outputs": [],
   "source": [
    "students = [\"Eleven\", \"Dustin\", \"Mike\", \"Will\", \"Lucas\", \"Max\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I'm not sure who this student is, they just showed up one day.\n",
      "Dustin can move up to 8th grade.\n",
      "Mike can move up to 8th grade.\n",
      "Will should repeat 7th grade because of absences.\n",
      "Lucas can move up to 8th grade.\n",
      "Max can move up to 8th grade.\n"
     ]
    }
   ],
   "source": [
    "for student in students:\n",
    "    if student == \"Will\":\n",
    "        print(student + \" should repeat 7th grade because of absences.\")\n",
    "    elif student == \"Eleven\":\n",
    "        print(\"I'm not sure who this student is, they just showed up one day.\")\n",
    "    else:\n",
    "        print(student + \" can move up to 8th grade.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>We can add more code under each if/elif/else statement. Let's add the students to the correct empty list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 233,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I'm not sure who this student is, they just showed up one day.\n",
      "Dustin can move up to 8th grade.\n",
      "Mike can move up to 8th grade.\n",
      "Will should repeat 7th grade because of absences.\n",
      "Lucas can move up to 8th grade.\n",
      "Max can move up to 8th grade.\n"
     ]
    }
   ],
   "source": [
    "grade_8 = []\n",
    "grade_7 = []\n",
    "unsure = []\n",
    "for student in students:\n",
    "    if student == \"Will\":\n",
    "        print(student + \" should repeat 7th grade because of absences.\")\n",
    "        grade_7.append(student)\n",
    "    elif student == \"Eleven\":\n",
    "        print(\"I'm not sure who this student is, they just showed up one day.\")\n",
    "        unsure.append(student)\n",
    "    else:\n",
    "        print(student + \" can move up to 8th grade.\")\n",
    "        grade_8.append(student)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 234,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Grade 7:\n",
      "['Will']\n",
      "Grade 8:\n",
      "['Dustin', 'Mike', 'Lucas', 'Max']\n",
      "Unsure where to place:\n",
      "['Eleven']\n"
     ]
    }
   ],
   "source": [
    "print(\"Grade 7:\")\n",
    "print(grade_7)\n",
    "print(\"Grade 8:\")\n",
    "print(grade_8)\n",
    "print(\"Unsure where to place:\")\n",
    "print(unsure)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><span style=\"color:red\">Loops Exercise 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*This one will take a little thought.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "metadata": {},
   "outputs": [],
   "source": [
    "grades = [90, 75, 92, 89, 95, 94, 100, 92]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The list `grades` shows the homework grades that one student received over the quarter. You told the students that you would drop their one lowest homework grade."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>First, create a new empty list called `final_grades`. Then, write a for loop to loop through `grades`. **For** each grade in the list, **if** the grade is **not equal to** the lowest grade in the list, **append** it to `final_grades`:\n",
    "<br>*Hint: you can use the min() function to find the lowest grade in the list.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 236,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_grades = []\n",
    "for g in grades:\n",
    "    if g != min(grades):\n",
    "        final_grades.append(g)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Print `final_grades`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 237,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[90, 92, 89, 95, 94, 100, 92]\n"
     ]
    }
   ],
   "source": [
    "print(final_grades)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 238,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[90, 92, 89, 95, 94, 100, 92]\n"
     ]
    }
   ],
   "source": [
    "final_grades = []\n",
    "low = min(grades)\n",
    "for g in grades:\n",
    "    if g != low:\n",
    "        final_grades.append(g)\n",
    "print(final_grades)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br><br>Example 4: Using try/except to handle unexpected variations in a list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We often need to use try/except if we aren't sure whether all the items in our list are of the correct data type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 239,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_scores = [90, 95, \"absent\", 100, 76]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's say we want to give an extra 2 points for every test."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 240,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can only concatenate str (not \"int\") to str",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[0;32mIn [240]\u001b[0m, in \u001b[0;36m<cell line: 2>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m bonus_scores \u001b[38;5;241m=\u001b[39m []\n\u001b[1;32m      2\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m score \u001b[38;5;129;01min\u001b[39;00m test_scores:\n\u001b[0;32m----> 3\u001b[0m     bonus_scores\u001b[38;5;241m.\u001b[39mappend(\u001b[43mscore\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m2\u001b[39;49m)\n\u001b[1;32m      4\u001b[0m \u001b[38;5;28mprint\u001b[39m(bonus_scores)\n",
      "\u001b[0;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
     ]
    }
   ],
   "source": [
    "bonus_scores = []\n",
    "for score in test_scores:\n",
    "    bonus_scores.append(score + 2)\n",
    "print(bonus_scores)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>This gave us an error because you can't add the number 2 to the word \"absent\", so we can rewrite it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 241,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[92, 97, 'absent', 102, 78]\n"
     ]
    }
   ],
   "source": [
    "bonus_scores = []\n",
    "for score in test_scores:\n",
    "    try:\n",
    "        bonus_scores.append(score + 2)\n",
    "    except TypeError:\n",
    "        bonus_scores.append(score)\n",
    "print(bonus_scores)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>You need to specify the type of error in your except statement.\n",
    "<br><br>Sometimes this means that you need to run the code without try/except first to get the name of the error you should expect.\n",
    "<br><br>If you don't include the error type, it will perform the except code for all exceptions, which might seem great, but it can actually create more trouble for you down the road."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 242,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_scores2 = [90, 95, \"absent\", 100, \"76\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we have the same list, except you accidentally entered the last score as a string instead of an integer. Let's try this list with the same code we just wrote:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 243,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[92, 97, 'absent', 102, '76']\n"
     ]
    }
   ],
   "source": [
    "bonus_scores2 = []\n",
    "for score in test_scores2:\n",
    "    try:\n",
    "        bonus_scores2.append(score + 2)\n",
    "    except TypeError:\n",
    "        bonus_scores2.append(score)\n",
    "print(bonus_scores2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>It didn't add bonus points to the last score, even though you need that score included. Let's try this to account for the last score:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 244,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "invalid literal for int() with base 10: 'absent'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[0;32mIn [244]\u001b[0m, in \u001b[0;36m<cell line: 2>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m----> 4\u001b[0m     bonus_scores2\u001b[38;5;241m.\u001b[39mappend(\u001b[43mscore\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m2\u001b[39;49m)\n\u001b[1;32m      5\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m:\n",
      "\u001b[0;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str",
      "\nDuring handling of the above exception, another exception occurred:\n",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Input \u001b[0;32mIn [244]\u001b[0m, in \u001b[0;36m<cell line: 2>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      4\u001b[0m         bonus_scores2\u001b[38;5;241m.\u001b[39mappend(score \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m2\u001b[39m)\n\u001b[1;32m      5\u001b[0m     \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m:\n\u001b[0;32m----> 6\u001b[0m         bonus_scores2\u001b[38;5;241m.\u001b[39mappend(\u001b[38;5;28;43mint\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mscore\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m2\u001b[39m)\n\u001b[1;32m      7\u001b[0m \u001b[38;5;28mprint\u001b[39m(bonus_scores2)\n",
      "\u001b[0;31mValueError\u001b[0m: invalid literal for int() with base 10: 'absent'"
     ]
    }
   ],
   "source": [
    "bonus_scores2 = []\n",
    "for score in test_scores2:\n",
    "    try:\n",
    "        bonus_scores2.append(score + 2)\n",
    "    except TypeError:\n",
    "        bonus_scores2.append(int(score) + 2)\n",
    "print(bonus_scores2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>Now we can see that we get a second error, a ValueError, because Python can't convert \"absent\" to an integer. We can add a second try/except to our code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 245,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[92, 97, 'absent', 102, 78]\n"
     ]
    }
   ],
   "source": [
    "bonus_scores2 = []\n",
    "for score in test_scores2:\n",
    "    try:\n",
    "        bonus_scores2.append(score + 2)\n",
    "    except TypeError:\n",
    "        try:\n",
    "            bonus_scores2.append(int(score) + 2)\n",
    "        except ValueError:\n",
    "            bonus_scores2.append(score)\n",
    "print(bonus_scores2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>This was a complicated example, but it shows how it can take some logic to get the results you want."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><span style=\"color:red\">Loops Exercise 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Store this list of students:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 256,
   "metadata": {},
   "outputs": [],
   "source": [
    "students = [\"Dustin\", \"Mike\", \"Will\", \"Lucas\", 11, \"Max\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>Run the code below to identify the error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 247,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "4\n",
      "4\n",
      "5\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "object of type 'int' has no len()",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[0;32mIn [247]\u001b[0m, in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m student \u001b[38;5;129;01min\u001b[39;00m students:\n\u001b[0;32m----> 2\u001b[0m     \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;28;43mlen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mstudent\u001b[49m\u001b[43m)\u001b[49m)\n",
      "\u001b[0;31mTypeError\u001b[0m: object of type 'int' has no len()"
     ]
    }
   ],
   "source": [
    "for student in students:\n",
    "    print(len(student))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>Write a new loop to print the length of each student's name. Include a try/except block. You can decide what you want to do with 11 - pass? print something? change to a string?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 248,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "4\n",
      "4\n",
      "5\n",
      "Computer does not recognize this as a name.\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "for student in students:\n",
    "    try:\n",
    "        print(len(student))\n",
    "    except TypeError:\n",
    "        print(\"Computer does not recognize this as a name.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 249,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "4\n",
      "4\n",
      "5\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "for student in students:\n",
    "    try:\n",
    "        print(len(student))\n",
    "    except TypeError:\n",
    "        print(len(str(student)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 250,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "4\n",
      "4\n",
      "5\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "for student in students:\n",
    "    print(len(str(student)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 259,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length of this name is 6\n",
      "Length of this name is 4\n",
      "Length of this name is 4\n",
      "Length of this name is 5\n",
      "Computer doesn't recognise this as a name\n",
      "Length of this name is 3\n"
     ]
    }
   ],
   "source": [
    "for n in students:\n",
    "    try:\n",
    "        print(\"Length of this name is \" + str(len(n)))\n",
    "    except TypeError:\n",
    "        print(\"Computer doesn't recognise this as a name\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 258,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can only concatenate str (not \"int\") to str",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[0;32mIn [258]\u001b[0m, in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m n \u001b[38;5;129;01min\u001b[39;00m students:\n\u001b[0;32m----> 2\u001b[0m     \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mLength of this name is \u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;28;43mlen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mn\u001b[49m\u001b[43m)\u001b[49m)\n",
      "\u001b[0;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
     ]
    }
   ],
   "source": [
    "for n in students:\n",
    "    print(\"Length of this name is \" + len(n))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 260,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can only concatenate str (not \"int\") to str",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[0;32mIn [260]\u001b[0m, in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mLength of this name is \u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;28;43mlen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mstudents\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m)\n",
      "\u001b[0;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
     ]
    }
   ],
   "source": [
    "print(\"Length of this name is \" + len(students[0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <br><br>Converting a list to a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 251,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"['Dustin', 'Mike', 'Will', 'Lucas', 11, 'Max']\""
      ]
     },
     "execution_count": 251,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str(students)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 253,
   "metadata": {},
   "outputs": [],
   "source": [
    "students[-2] = \"Eleven\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 254,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Dustin, Mike, Will, Lucas, Eleven, Max'"
      ]
     },
     "execution_count": 254,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\", \".join(students)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 255,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'[9, 5, 6]'"
      ]
     },
     "execution_count": 255,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str([9, 5, 6])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <br><br><br>Day 2 Quiz"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On your own, before we meet again for tomorrow's morning lecture, complete the Day 2 Quiz. The Jupyter Notebook file is called \"day2Quiz.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/day2Quiz.ipynb>."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>If you have questions about the quiz material, send an email to me or Rahul and we will try our best to reply to all emails before tomorrow's lecture (which starts at 10 am Central on the same Zoom channel as today).\n",
    "<br><br>As a reminder, the quiz is self-graded - you do not need to turn anything in! The answer key is called \"day2Quiz-answers.ipynb\". For Colab users, the answer key is at <https://colab.research.google.com/github/aGitHasNoName/pythonBootcamp_3Day/blob/main/day2Quiz-answers.ipynb>."
   ]
  },
  {
   "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
}