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><br>Today's Objects\n",
    "- Lists\n",
    "- Tuples\n",
    "- Sets\n",
    "- Ranges\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": null,
   "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": 1,
   "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": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 2,
     "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": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_grade = [90]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>A list can be empty:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "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": 5,
   "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": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "family = [\"Bob\", \"Linda\", \"Tina\", \"Gene\", \"Louise\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Bob', 'Linda', 'Tina', 'Gene', 'Louise']\n"
     ]
    }
   ],
   "source": [
    "print(family)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "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": 8,
   "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": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(grades)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br>The `sort()` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "grades.sort()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hmm, nothing was returned."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "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": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "students = [\"Alex\", \"Billy\", \"Casey\", \"Drake\", \"Ellis\", \"Frankie\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "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": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Alex', 'Billy', 'Casey', 'Drake', 'Ellis', 'Frankie', 'Gavi']"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "students"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or by printing the variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "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": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "grades = [93, 75, 80, 98, 100, 64, 88]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "598"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(grades)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[93, 75, 80, 98, 100, 64, 88]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "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": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "colors = [\"navy blue\", \"gold\", \"silver\", \"scarlet\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "colors.append(\"teal\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(colors)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br>More list functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "import statistics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We already learned some list functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "bananas_in_bunches = [4, 9, 7, 4, 3, 6]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>`sum()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "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": 25,
   "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": 26,
   "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": 27,
   "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": 28,
   "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 functions**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "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": 30,
   "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": 31,
   "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": 32,
   "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\">Exercise: Finding list functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>Let's practice finding information online. Use Google (or ChatGPT, if that's already your default search) 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": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "bananas_in_bunches = [4, 9, 7, 4, 3, 6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.258317958127243\n"
     ]
    }
   ],
   "source": [
    "stdev_banana_bunches = statistics.stdev(bananas_in_bunches)\n",
    "print(stdev_banana_bunches)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br>List operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use comparison operators with lists, just like other objects:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "students = [\"Alex\", \"Billy\", \"Casey\", \"Drake\", \"Ellis\", \"Frankie\"]\n",
    "grades = [93, 75, 80, 98, 100, 64, 88]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(students) == len(grades)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(students) > len(grades)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br>We can use some arithmetic operators with lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "grades = [93, 75, 80, 98, 100, 64, 88]\n",
    "more_grades = [70, 93]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "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": 40,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for -: 'list' and 'list'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[40], line 1\u001b[0m\n\u001b[1;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[0;32m      2\u001b[0m \u001b[38;5;28mprint\u001b[39m(grades)\n",
      "\u001b[1;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": 41,
   "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": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[93, 75, 80, 98, 100, 64, 88, 70, 93]"
      ]
     },
     "execution_count": 42,
     "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": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "students = [\"Alex\", \"Billy\", \"Casey\", \"Drake\", \"Ellis\", \"Frankie\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Alex'"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "students[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ellis'"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "students[-2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Billy', 'Casey', 'Drake']"
      ]
     },
     "execution_count": 46,
     "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": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Alex', 'Billy', 'Casey', 'Drake', 'Ellis', 'Frankie']"
      ]
     },
     "execution_count": 47,
     "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": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "students[1] = \"Billie\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Alex', 'Billie', 'Casey', 'Drake', 'Ellis', 'Frankie']"
      ]
     },
     "execution_count": 49,
     "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": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "states = [\"Hawaii\", \"Kentucky\", \"Illinois\", \"Iowa\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "states[2] = \"Indiana\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Hawaii', 'Kentucky', 'Indiana', 'Iowa']\n"
     ]
    }
   ],
   "source": [
    "print(states)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br><br>You can also 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>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": 53,
   "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": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'oo'"
      ]
     },
     "execution_count": 54,
     "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": 55,
   "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": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Mae'"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gradebook[0][-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "88"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gradebook[1][3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'y'"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gradebook[0][1][2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br><span style=\"color:red\">Exercise: Indexing Multiple Levels"
   ]
  },
  {
   "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": 59,
   "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": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'y'"
      ]
     },
     "execution_count": 60,
     "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": 61,
   "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": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.776"
      ]
     },
     "execution_count": 62,
     "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": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.001"
      ]
     },
     "execution_count": 63,
     "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": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6966"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "statistics.mean(results[1])"
   ]
  },
  {
   "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": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "frodo = [\"hobbit\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "sam = frodo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['hobbit']"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frodo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['hobbit']"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "frodo.append(\"ring\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['hobbit', 'ring']"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frodo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['hobbit', 'ring']"
      ]
     },
     "execution_count": 71,
     "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": "markdown",
   "metadata": {},
   "source": [
    "Example 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "harry = [\"wizard\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "ron = [\"wizard\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['wizard']"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "harry"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['wizard']"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ron"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "harry.append(\"scar\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['wizard', 'scar']"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "harry"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['wizard']"
      ]
     },
     "execution_count": 78,
     "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": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "frodo = [\"hobbit\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "sam = frodo.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['hobbit']"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frodo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['hobbit']"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "frodo.append(\"ring\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['hobbit', 'ring']"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frodo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['hobbit']"
      ]
     },
     "execution_count": 85,
     "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": "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": 86,
   "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": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Bartholomew JoJo Simpson'"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\" \".join(full_name_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Bartholomew-JoJo-Simpson'"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"-\".join(full_name_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'BartholomewDOHJoJoDOHSimpson'"
      ]
     },
     "execution_count": 89,
     "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": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'BartholomewJoJoSimpson'"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\".join(full_name_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br><span style=\"color:red\">Exercise: Joining a list into a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "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": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Documents/workshops/bootcamp/tuesday/tuesdayLecture.ipynb'"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"/\".join(path_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Bonus exercise*: Join the path_list together with a \"\\\\\" for a Windows computer. Does it behave as you expected? Can you think of a solution?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Documents\\\\workshops\\\\bootcamp\\\\tuesday\\\\tuesdayLecture.ipynb'"
      ]
     },
     "execution_count": 93,
     "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": null,
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "csv_line_list = csv_line.split(\",\")\n",
    "print(csv_line_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br><span style=\"color:red\">Exercise: Splitting a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "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": 95,
   "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": 96,
   "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": 97,
   "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><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": 98,
   "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=cowtgmZuai0. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "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": 100,
   "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": 101,
   "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": 102,
   "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": 103,
   "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": 104,
   "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": null,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'y' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[108], line 2\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m g \u001b[38;5;129;01min\u001b[39;00m grades:\n\u001b[1;32m----> 2\u001b[0m     \u001b[38;5;28mprint\u001b[39m(\u001b[43my\u001b[49m)\n",
      "\u001b[1;31mNameError\u001b[0m: name 'y' is not defined"
     ]
    }
   ],
   "source": [
    "for g in grades:\n",
    "    print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "expected ':' (205954698.py, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  Cell \u001b[1;32mIn[106], line 1\u001b[1;36m\u001b[0m\n\u001b[1;33m    for g in grades\u001b[0m\n\u001b[1;37m                   ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m expected ':'\n"
     ]
    }
   ],
   "source": [
    "for g in grades\n",
    "    print(g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "expected an indented block after 'for' statement on line 1 (972508709.py, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  Cell \u001b[1;32mIn[107], line 2\u001b[1;36m\u001b[0m\n\u001b[1;33m    print(g)\u001b[0m\n\u001b[1;37m    ^\u001b[0m\n\u001b[1;31mIndentationError\u001b[0m\u001b[1;31m:\u001b[0m expected an indented block after 'for' statement on line 1\n"
     ]
    }
   ],
   "source": [
    "for g in grades:\n",
    "print(g)"
   ]
  },
  {
   "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**. Try to predict what will happen when you run these code cells:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [],
   "source": [
    "if 8 > 10:\n",
    "    print(\"Wow!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "That seems right.\n"
     ]
    }
   ],
   "source": [
    "if 10 > 8:\n",
    "    print(\"That seems right.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hmmm... That seems wrong.\n"
     ]
    }
   ],
   "source": [
    "if 8 > 10:\n",
    "    print(\"Wow!\")\n",
    "else:\n",
    "    print(\"Hmmm... That seems wrong.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br>**if statements** are often used with for loops to filter data for different conditions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "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": 113,
   "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 print only grades that are 60 or higher:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "73\n",
      "64\n",
      "89\n",
      "93\n",
      "100\n",
      "79\n"
     ]
    }
   ],
   "source": [
    "for g in grades:\n",
    "    if g >= 60:\n",
    "        print(g)\n",
    "    else:\n",
    "        pass"
   ]
  },
  {
   "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": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "73\n",
      "64\n",
      "89\n",
      "93\n",
      "100\n",
      "79\n"
     ]
    }
   ],
   "source": [
    "for g in grades:\n",
    "    if g >= 60:\n",
    "        print(g)"
   ]
  },
  {
   "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": 116,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[73, 64, 89, 93, 59, 100, 79]\n"
     ]
    }
   ],
   "source": [
    "print(grades)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "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": 118,
   "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": 119,
   "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": 120,
   "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": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"pie\" in \"pizza pie\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Oreo\" in [\"Chips Ahoy\", \"Oreo\", \"Oatmeal raisin\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cookies = [\"Chips Ahoy\", \"Oreo\", \"Oatmeal raisin\"]\n",
    "\"Oreo\" in cookies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"oreo\" in [\"Chips Ahoy\", \"Oreo\", \"Oatmeal raisin\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Ahoy\" in \"Chips Ahoy\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 126,
     "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": 127,
   "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": 128,
   "metadata": {},
   "outputs": [],
   "source": [
    "grades = [73, 64, 89, 93, 59, 100, 79]\n",
    "grades_to_round = [59, 69, 79, 89]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll loop through the `grades` list. If the grade is in the `grades_to_round` list, we'll add one point to the grade. If the grade is not in `grades_to_round`, we'll print the original grade."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "73\n",
      "64\n",
      "90\n",
      "93\n",
      "60\n",
      "100\n",
      "80\n"
     ]
    }
   ],
   "source": [
    "for g in grades:\n",
    "    if g in grades_to_round:\n",
    "        print(g + 1)\n",
    "    else:\n",
    "        print(g)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br>There's also `not in`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "73\n",
      "64\n",
      "90\n",
      "93\n",
      "60\n",
      "100\n",
      "80\n"
     ]
    }
   ],
   "source": [
    "for g in grades:\n",
    "    if g not in grades_to_round:\n",
    "        print(g)\n",
    "    else:\n",
    "        print(g + 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br>If you want your code to run faster, you should think about when to use `in` vs. `not in`. If you think the majority of the items in your loop will be `in`, you should put that condition in the `if` statement. If you think the majority of the items in your loop will be `not in`, you should put that condition in the `if` statement. This is because once the condition is met for an item, the computer does not need to read any following `elif` or `else` statements, saving a bit of time."
   ]
  },
  {
   "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": 131,
   "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": 132,
   "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": [
    "Loop through the `my_toppings` list. If the topping is also in the `store_toppings` list, print out a message saying that the topping is available. 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": 133,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Olives are available.\n",
      "Carrots are not available.\n",
      "Jalapenos are available.\n",
      "Black pepper are not available.\n"
     ]
    }
   ],
   "source": [
    "for top in my_toppings:\n",
    "    if top in store_toppings:\n",
    "        print(top.capitalize() + \" are available.\")\n",
    "    else:\n",
    "        print(top.capitalize() + \" are not available.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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": {
    "tags": []
   },
   "source": [
    "# <br><br><span style=\"color:rebeccapurple\">LUNCH BREAK - meet back at 1 pm Central"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <br><br><span style=\"color:teal\">More fun with lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><span style=\"color:red\">Exercise: Indexing lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "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": 136,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'December'"
      ]
     },
     "execution_count": 136,
     "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": 137,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['June', 'July', 'August', 'September']"
      ]
     },
     "execution_count": 137,
     "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": 140,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I was born on December.\n"
     ]
    }
   ],
   "source": [
    "print(\"I was born on \" + months[11] + \".\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br><span style=\"color:red\">Exercise: Comparisons between lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "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": 142,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(characters) > len(water_tribe) and len(water_tribe) > 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Aang\" in water_tribe or \"Sokka\" not in water_tribe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 144,
     "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:red\">Exercise: List functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check out all of the list method functions at this link:\n",
    "<br>[https://docs.python.org/3/tutorial/datastructures.html](https://docs.python.org/3/tutorial/datastructures.html)\n",
    "<br>Choose at least one list method from the website that we haven't learned yet. Create a list of anything to practice with, and then try out your chosen list method function to see how it works."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "office = [\"Michael\", \"Jim\", \"Dwight\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <br><br>Adding 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>We'll start with a list of grades. Then, let's create a new list of grades, giving everyone 5 extra points. Run this cell to save our list of grades:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "grades = [73, 64, 89, 93, 59, 100, 79]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, we create a new **empty list**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for g in grades:\n",
    "    new_grades.append(g + 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_grades = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(new_grades)"
   ]
  },
  {
   "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": null,
   "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": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(rounded_bills)"
   ]
  },
  {
   "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>We just 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 coming week:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c_temps = [27, 22, 22, 24, 23, 24, 24]"
   ]
  },
  {
   "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": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fastest5k = [12.49, 14.13]"
   ]
  },
  {
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br><br>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": null,
   "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": null,
   "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": null,
   "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": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "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>Run the cell below to store a list of birds you observed at the bird feeder outside your window:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bird_obs = [\"Mourning Dove\", \n",
    "            \"Red-winged Blackbird\", \n",
    "            \"Red-winged Blackbird\", \n",
    "            \"Red-winged Blackbird\", \n",
    "            \"Mourning Dove\", \n",
    "            \"Mourning Dove\", \n",
    "            \"Northern Cardinal\", \n",
    "            \"Mourning Dove\", \n",
    "            \"Song Sparrow\", \n",
    "            \"Song Sparrow\", \n",
    "            \"Song Sparrow\", \n",
    "            \"American Crow\",\n",
    "            \"American Robin\", \n",
    "            \"American Crow\",\n",
    "            \"Song Sparrow\", \n",
    "            \"Red-winged Blackbird\", \n",
    "            \"Mourning Dove\", \n",
    "            \"Red-winged Blackbird\", \n",
    "            \"Blue Jay\", \n",
    "            \"Red-winged Blackbird\", \n",
    "            \"Song Sparrow\", \n",
    "            \"Red-winged Blackbird\", \n",
    "            \"Mourning Dove\", \n",
    "            \"Red-winged Blackbird\", \n",
    "            \"European Starling\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>How many Red-winged Blackbirds did you see?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First create a variable called `blackbird_count` that stores the number 0. Then, write a for loop to loop through the `bird_obs` list. *If* the bird is a Red-winged Blackbird, reassign the variable `blackbird_count` to it's current value plus 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now print the variable `blackbird_count`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "students = [\"Eleven\", \"Dustin\", \"Mike\", \"Will\", \"Lucas\", \"Max\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Print `final_grades`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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": null,
   "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": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "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": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "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": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <br><br><span style=\"color:teal\">tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You are already familiar with tuples! You just didn't know they were called that. A tuple follows every function call:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "round(489289, -3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>(489289, -3) is a tuple."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>A tuple is another Python **iterator**, like a list. An iterator is a collection of items kept in order that can be looped through.\n",
    "<br><br>A tuple is the same as a list, but it is **immutable**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br>Tuples are usually designated by parentheses:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_tuple = (4, 8, 10)\n",
    "type(my_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "but, they are technically designated just by having objects separated by commas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dog_tuple = \"beagle\", \"boxer\", \"border collie\"\n",
    "type(dog_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>To make an empty tuple, you have to use parentheses:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "empty_t = ()\n",
    "type(empty_t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>You can loop through a tuple:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for dog in dog_tuple:\n",
    "    print(dog)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br>Regular functions will work on tuples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sum((6, 7, 8))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(dog_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>List methods do not work with tuples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for dog in dog_tuple:\n",
    "    if \"collie\" in dog:\n",
    "        empty_t.append()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>In fact, tuples don't have methods! Tuples are mostly used behind the scenes in Python, but occasionally you will see one returned to you from a function, so it's good to recognize them."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>The function for calculating a T-test for the means of two independent samples returns a fancy tuple with two items. It is found in the **scipy** module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.stats import ttest_ind"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_a = [7, 4, 3, 9, 8, 29, 8, 17]\n",
    "list_b = [8, 10, 14, 28, 26, 18, 17, 17]\n",
    "answer = ttest_ind(list_a, list_b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(answer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>This is a very fancy tuple, with keywords, but it is still a tuple.\n",
    "<br>You can index a tuple to get the info you need:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stat = answer[0]\n",
    "p_value = answer[1]\n",
    "print(stat)\n",
    "print(p_value)         "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>**You can always change a tuple to a list to make it easier to work with**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "answer_list = list(answer)\n",
    "print(answer_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <br><br><span style=\"color:teal\">sets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Sets are like unordered lists with no duplicate values.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "They are great for removing duplicates from lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_list = [4, 4, 4, 4, 4, 4, 10]\n",
    "num_set = set(num_list)\n",
    "print(num_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can change them back to lists in the same line of code to quickly remove duplicates from a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_list = [4, 4, 4, 4, 4, 4, 10]\n",
    "num_list = list(set(num_list))\n",
    "print(num_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>Sets are designated by curly brackets (Python knows it's not a dictionary if you don't include any colons inside), or just by using the set`()` function on a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = {8, 9, 10, 9, 8}\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s2 = set([8, 9, 10, 9, 8])\n",
    "print(s2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <br><span style=\"color:red\">Exercise: sets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Store the following list. This is a list of birds you observed from your window."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bird_obs = [\"Mourning Dove\", \n",
    "            \"Red-winged Blackbird\", \n",
    "            \"Red-winged Blackbird\", \n",
    "            \"Red-winged Blackbird\", \n",
    "            \"Mourning Dove\", \n",
    "            \"Mourning Dove\", \n",
    "            \"Northern Cardinal\", \n",
    "            \"Mourning Dove\", \n",
    "            \"Song Sparrow\", \n",
    "            \"Song Sparrow\", \n",
    "            \"Song Sparrow\", \n",
    "            \"American Crow\",\n",
    "            \"American Robin\", \n",
    "            \"American Crow\",\n",
    "            \"Song Sparrow\", \n",
    "            \"Red-winged Blackbird\", \n",
    "            \"Mourning Dove\", \n",
    "            \"Red-winged Blackbird\", \n",
    "            \"Blue Jay\", \n",
    "            \"Red-winged Blackbird\", \n",
    "            \"Song Sparrow\", \n",
    "            \"Red-winged Blackbird\", \n",
    "            \"Mourning Dove\", \n",
    "            \"Red-winged Blackbird\", \n",
    "            \"European Starling\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How many total birds did you observe? Write code to find the length of the `bird_obs` list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How many different types of birds did you observe? Write code to turn the `bird_obs` list into a set, and then find the length of that set. Bonus if you can do it in one line of code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Which different bird types did you see? Turn the `bird_obs` list into a set, and loop through it, printing out each bird type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <br><br><span style=\"color:teal\">ranges"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another Python iterator! A range is created by the `range()` function. It is used to create a collection of integers in order so that you can loop through it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `range()` function takes 2 or 3 arguments: which integer to start with, which integer to end with, and how many integers to iterate by between numbers. If you do not provide the third argument, the range will iterate by 1."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>If you run the function alone, it will return the range object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "range(1, 10, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>This isn't very useful. But, if you loop through the range object, you can do something with each number:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(1, 10, 2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>**You can also change the range object into a list to work with it**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "r = list(range(1, 10, 2))\n",
    "print(r)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Note: `range()` does not work with floats, only integers. To create a range of floats, you will need to import the module numpy.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>Like Python indexing, the stop position is **exclusive** of the number passed as the stop argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(1, 11):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <br><span style=\"color:red\">Exercise: range"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a for loop to print every 20th number from 0 to 400."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <br><br><br>Day 2 Quiz"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Test yourself on what you learned today by completing 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/nuitrcs/pythonBootcamp_3Day/blob/main/day2Quiz.ipynb>."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will take some time now for you to complete the quiz, and we will review the quiz answers live after this period.\n",
    "<br><br>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/nuitrcs/pythonBootcamp_3Day/blob/main/day2Quiz-answers.ipynb>."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <br><br><br> For tomorrow\n",
    "Tomorrow we will be learning how to open files in Python. If you are not familiar with filepaths (using words to point the computer to your files instead of using point-and-click), you should watch the first section of the Programming Concepts recording before tomorrow. The link is in the email Colby sent you before the workshop with all the workshop info."
   ]
  },
  {
   "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.12.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}