BONUS_LEVEL-answers.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <span style=\"color:purple\">Python Fundamentals Bootcamp - BONUS LEVEL</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <br>BONUS OBJECTS\n",
    "- tuples\n",
    "- sets\n",
    "- ranges\n",
    "\n",
    "#### <br>CHEATCODE\n",
    "- fstrings\n",
    "\n",
    "#### <br>LEVEL UP\n",
    "- scripts\n",
    "\n",
    "#### <br>FINAL BOSS\n",
    "- bonus project"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <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": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "489000"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "empty_t = ()\n",
    "type(empty_t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>You can loop through a tuple:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "beagle\n",
      "boxer\n",
      "border collie\n"
     ]
    }
   ],
   "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": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "21"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum((6, 7, 8))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(dog_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>List methods do not work with tuples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'tuple' object has no attribute 'append'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "Input \u001b[0;32mIn [8]\u001b[0m, in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m dog \u001b[38;5;129;01min\u001b[39;00m dog_tuple:\n\u001b[1;32m      2\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcollie\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01min\u001b[39;00m dog:\n\u001b[0;32m----> 3\u001b[0m         \u001b[43mempty_t\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mappend\u001b[49m()\n",
      "\u001b[0;31mAttributeError\u001b[0m: 'tuple' object has no attribute 'append'"
     ]
    }
   ],
   "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": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.stats import ttest_ind"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "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": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ttest_indResult(statistic=-1.6991019936393787, pvalue=0.11140195153800304)\n"
     ]
    }
   ],
   "source": [
    "print(answer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>You can index a tuple to get the info you need:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-1.6991019936393787\n",
      "0.11140195153800304\n"
     ]
    }
   ],
   "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": 13,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-1.6991019936393787, 0.11140195153800304]\n"
     ]
    }
   ],
   "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": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{10, 4}\n"
     ]
    }
   ],
   "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": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 4]\n"
     ]
    }
   ],
   "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": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{8, 9, 10}\n"
     ]
    }
   ],
   "source": [
    "s = {8, 9, 10, 9, 8}\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{8, 9, 10}\n"
     ]
    }
   ],
   "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": 19,
   "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": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(bird_obs)"
   ]
  },
  {
   "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": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(set(bird_obs))"
   ]
  },
  {
   "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": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Blue Jay\n",
      "European Starling\n",
      "Song Sparrow\n",
      "American Crow\n",
      "Red-winged Blackbird\n",
      "Mourning Dove\n",
      "Northern Cardinal\n",
      "American Robin\n"
     ]
    }
   ],
   "source": [
    "for bird in set(bird_obs):\n",
    "    print(bird)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Blue Jay', 'European Starling', 'Song Sparrow', 'American Crow', 'Red-winged Blackbird', 'Mourning Dove', 'Northern Cardinal', 'American Robin'}\n"
     ]
    }
   ],
   "source": [
    "print(set(bird_obs))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <br>Check to see if a list even has any duplicates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(bird_obs) == len(set(bird_obs))"
   ]
  },
  {
   "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": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(1, 10, 2)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "5\n",
      "7\n",
      "9\n"
     ]
    }
   ],
   "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": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 5, 7, 9]\n"
     ]
    }
   ],
   "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>Ranges use commas, not colons"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 5]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r[1:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (3213977562.py, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  Input \u001b[0;32mIn [29]\u001b[0;36m\u001b[0m\n\u001b[0;31m    for i in range(1:10)\u001b[0m\n\u001b[0m                    ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "for i in range(1:10)"
   ]
  },
  {
   "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": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "for i in range(0, 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": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "20\n",
      "40\n",
      "60\n",
      "80\n",
      "100\n",
      "120\n",
      "140\n",
      "160\n",
      "180\n",
      "200\n",
      "220\n",
      "240\n",
      "260\n",
      "280\n",
      "300\n",
      "320\n",
      "340\n",
      "360\n",
      "380\n",
      "400\n"
     ]
    }
   ],
   "source": [
    "for i in range(0, 401, 20):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <br>Use range on the length of a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "4\n",
      "7\n",
      "4\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "list_x = [6, 5, 4, 6, 7, 5, 4, 8, 9, 7]\n",
    "for i in range(0, len(list_x), 2):\n",
    "    print(list_x[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <br><br><span style=\"color:teal\">fstrings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are going to cover how to **build strings out of variables and strings**. This is a very common task in Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Some examples:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Building filenames**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "myfile_ver2\n"
     ]
    }
   ],
   "source": [
    "old_filename = \"myfile\"\n",
    "new_filename = old_filename + \"_ver2\"\n",
    "print(new_filename)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Reporting results**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The mean size is 7.3.\n"
     ]
    }
   ],
   "source": [
    "size_list = [5.4, 8.4, 9.2, 4.7, 8.8]\n",
    "print(\"The mean size is \" + str(sum(size_list)/len(size_list)) + \".\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Creating unique identifiers**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6_control_010420\n"
     ]
    }
   ],
   "source": [
    "run_num = \"6\"\n",
    "condition = \"control\"\n",
    "date = \"010420\"\n",
    "ID = run_num + \"_\" + condition + \"_\" + date\n",
    "print(ID)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br>Over the years, Python has introduced several methods to make this a shorter process than using the `+` between the strings and variables. Each new method has made the process a little bit shorter, but also still had some common errors that were easy for people to make."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br>The latest solution prevents these common user errors by moving the variable names into the string. These are called **fstrings**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br>fstring syntax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "myFile_ver2\n"
     ]
    }
   ],
   "source": [
    "old_filename = \"myFile\"\n",
    "version = 2\n",
    "new_filename = f\"{old_filename}_ver{version}\"\n",
    "print(new_filename)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>fstrings begin with the letter `f` followed by the opening quotation mark. <br>You can use either a single or double quotation mark, just like with an ordinary string.\n",
    "<br>Do not put a space between `f` and the first `\"`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br> Variable names now go inside the the curly brackets inside the string."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The string ends with the closing quotation mark."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>Here's an example using single quotation marks:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "myFile_ver2\n"
     ]
    }
   ],
   "source": [
    "new_filename = f'{old_filename}_ver{version}'\n",
    "print(new_filename)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>And here's an example with a space between the `f` and the first `\"`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (2201814917.py, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  Input \u001b[0;32mIn [45]\u001b[0;36m\u001b[0m\n\u001b[0;31m    new_filename = f \"{old_filename}_ver{version}\"\u001b[0m\n\u001b[0m                     ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "new_filename = f \"{old_filename}_ver{version}\"\n",
    "print(new_filename)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <br><br>fstring examples and practice exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <br><br>Example 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = \"Colby\"\n",
    "adj = \"adventurous\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <br>Old way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Happy Birthday, Colby! Have an adventurous day.\n"
     ]
    }
   ],
   "source": [
    "hb = \"Happy Birthday, \" + name + \"! Have an \" + adj + \" day.\"\n",
    "print(hb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <br>fstring:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Happy Birthday, Colby! Have an adventurous day.\n"
     ]
    }
   ],
   "source": [
    "hb = f\"Happy Birthday, {name}! Have an {adj} day.\"\n",
    "print(hb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br>*NOTE: If you want to include curly brackets in a string, you can surround them with another set of curly brackets.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Happy Birthday, {Colby}! Have a adventurous day. {}\n"
     ]
    }
   ],
   "source": [
    "hb = f\"Happy Birthday, {{{name}}}! Have a {adj} day. {{}}\"\n",
    "print(hb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br>Exercise 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First run this cell:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "animal = \"rabbit\"\n",
    "month = \"January\"\n",
    "day = 22\n",
    "year = 2023"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>Now write an fstring to print: The year of the rabbit will begin on January 22, 2023."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The year of the rabbit will begin on January 22, 2023.\n"
     ]
    }
   ],
   "source": [
    "sentence = f\"The year of the {animal} will begin on {month} {day}, {year}.\"\n",
    "print(sentence)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br><br><br>Did you notice anything interesting about how numbers were handled in that exercise?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "count = 3.5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <br>Old way"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can only concatenate str (not \"float\") to str",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[0;32mIn [56]\u001b[0m, in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mYesterday I ate \u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mcount\u001b[49m \u001b[38;5;241m+\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m cookies.\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
      "\u001b[0;31mTypeError\u001b[0m: can only concatenate str (not \"float\") to str"
     ]
    }
   ],
   "source": [
    "print(\"Yesterday I ate \" + count + \" cookies.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br>We would have to explicitly change `count` to a string in order to include it in the string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yesterday I ate 3.5 cookies.\n"
     ]
    }
   ],
   "source": [
    "print(\"Yesterday I ate \" + str(count) + \" cookies.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <br><br>fstring"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An fstring automatically changes any integer or float to a string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yesterday I ate 3.5 cookies.\n"
     ]
    }
   ],
   "source": [
    "print(f\"Yesterday I ate {count} cookies.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <br><br><br><br>Example 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "fstrings aren't only for variables!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Eat 11 kiwis.'"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f\"Eat {6 + 5} kiwis.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Eat 102.4 kiwis.'"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f\"Eat {2**10 / (13-3)} kiwis.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Eat 39 kiwis.'"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "kiwi_piles = [10, 9, 13, 7]\n",
    "f\"Eat {sum(kiwi_piles)} kiwis.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Eat ONE HUNDRED kiwis. one hundred.'"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "kiwi_dreams = \"one hundred\"\n",
    "f\"Eat {kiwi_dreams.upper()} kiwis. {kiwi_dreams}.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br>Exercise 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = \"Colby\"\n",
    "count = 11"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I said I ate 11 kiwis, but you saw me eat 3 more kiwis in secret. Change the code below to reflect the truth:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Colby ate 14 kiwis.\n"
     ]
    }
   ],
   "source": [
    "print(f\"{name} ate {count + 3} kiwis.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <br><br><br>Example 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see how fstrings handle lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "cookies = [\"Oreo\", \"snickerdoodle\", \"oatmeal chocolate chip\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The cookies I ate were ['Oreo', 'snickerdoodle', 'oatmeal chocolate chip'].\n"
     ]
    }
   ],
   "source": [
    "print(f\"The cookies I ate were {cookies}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br>Instead we can index the items in the list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The cookies I ate were Oreo, snickerdoodle, and oatmeal chocolate chip.\n"
     ]
    }
   ],
   "source": [
    "print(f\"The cookies I ate were {cookies[0]}, {cookies[1]}, and {cookies[2]}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br>Sometimes we don't know how many items will be in a list."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's review list indexing and the `join()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "cookies = [\"Oreo\", \"snickerdoodle\", \"oatmeal chocolate chip\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>Before running the cells below, take a minute to think - what will these print?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['snickerdoodle', 'oatmeal chocolate chip']"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cookies[1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Oreo', 'snickerdoodle']"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cookies[:-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br>If we don't specify an index after the `:` if will print to the end."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we don't specify an index before the `:` if will print from the beginning."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br>The `join()` function is handy for creating a string out of a list of unknown length."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Oreo, snickerdoodle, oatmeal chocolate chip'"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\", \".join(cookies)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>Combine `join()` with indexing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Oreo, snickerdoodle'"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\", \".join(cookies[:-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br>Now we can combine that to make a nice, neat sentence:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "f-string: expecting '}' (3916060474.py, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  Input \u001b[0;32mIn [78]\u001b[0;36m\u001b[0m\n\u001b[0;31m    print(f\"The cookies I ate were {\", \".join(cookies[:-1])}, and {cookies[-1]}.\")\u001b[0m\n\u001b[0m          ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m f-string: expecting '}'\n"
     ]
    }
   ],
   "source": [
    "print(f\"The cookies I ate were {\", \".join(cookies[:-1])}, and {cookies[-1]}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br><br>Uh-oh! When referencing a string inside a string (like at the beginning of the join() function), use single quotes `'` inside double quotes `\"`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The cookies I ate were Oreo, snickerdoodle, and oatmeal chocolate chip.\n"
     ]
    }
   ],
   "source": [
    "print(f\"The cookies I ate were {', '.join(cookies[:-1])}, and {cookies[-1]}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br>Exercise 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = \"Colby\"\n",
    "grades = [85, 89, 87, 82, 83, 10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>Write an fstring to say Dear Colby, Your exam grades were 85, 89, 87, and 83, and your participation grade was 10."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Note:* `join()` can't implicitly join integers into a string. You have three options:\n",
    "<br>- Beginner: index the grades individually in your fstring.\n",
    "<br>- Intermediate: Before the `letter` variable assignment, write a for loop to change all the items in `grades` to strings.\n",
    "<br>- Advanced: Use a list comprehension to change the grades to strings inside the `join()` function inside the fstring."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dear Colby, Your exam grades were 85, 89, 82, and 82, and your participation grade was 83.\n"
     ]
    }
   ],
   "source": [
    "letter = f\"Dear {name}, Your exam grades were {grades[0]}, {grades[1]}, {grades[3]}, and {grades[3]}, and your participation grade was {grades[4]}.\"\n",
    "print(letter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dear Colby, Your exam grades were 85, 89, 87, 82 and 83, and your participation grade was 10.\n"
     ]
    }
   ],
   "source": [
    "grades_str = []\n",
    "for i in grades:\n",
    "    grades_str.append(str(i))\n",
    "letter2 = f\"Dear {name}, Your exam grades were {', '.join(grades_str[:-2])} and {grades_str[-2]}, and your participation grade was {grades[-1]}.\"\n",
    "print(letter2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dear Colby, Your exam grades were 85, 89, 87, 82 and 83, and your participation grade was 10.\n"
     ]
    }
   ],
   "source": [
    "letter3 = f\"Dear {name}, Your exam grades were {', '.join([str(i) for i in grades[:-2]])} and {grades[-2]}, and your participation grade was {grades[-1]}.\"\n",
    "print(letter3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'bumblebee'"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\".join((\"bumble\", \"bee\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "sequence item 0: expected str instance, int found",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[0;32mIn [82]\u001b[0m, in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mjoin\u001b[49m\u001b[43m(\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m8\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m8\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n",
      "\u001b[0;31mTypeError\u001b[0m: sequence item 0: expected str instance, int found"
     ]
    }
   ],
   "source": [
    "\"\".join((8,8))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <br><br>Example 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's practice using fstrings with dictionaries."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is a **list of dictionaries** with info about six experiments:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "results_list = [{\"run\": 1, \"date\": \"013020\", \"condition\": \"control\", \"result\": 1.3849}, \n",
    "                {\"run\": 1, \"date\": \"013020\", \"condition\": \"cold\", \"result\": .8309},\n",
    "                {\"run\": 2, \"date\": \"013020\", \"condition\": \"control\", \"result\": 1.1384},\n",
    "                {\"run\": 2, \"date\": \"013020\", \"condition\": \"cold\", \"result\": 1.0867},\n",
    "                {\"run\": 3, \"date\": \"013020\", \"condition\": \"control\", \"result\": .8479},\n",
    "                {\"run\": 3, \"date\": \"013020\", \"condition\": \"cold\", \"result\": .7238}]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>We want to create a results file for each experiment. (So we need to loop through the list.)<br>To create a unique identifier for each result, we will combine the condition, run number, and the word \"results\", in addition to a file extension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "control_1_results.txt\n",
      "cold_1_results.txt\n",
      "control_2_results.txt\n",
      "cold_2_results.txt\n",
      "control_3_results.txt\n",
      "cold_3_results.txt\n"
     ]
    }
   ],
   "source": [
    "for i in results_list:\n",
    "    #remember that each i is a dictionary\n",
    "    new_filename = f\"{i['condition']}_{i['run']}_results.txt\"\n",
    "    print(new_filename)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br>Exercise 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "results_dicts = [{\"run\": 1, \"date\": \"013020\", \"condition\": \"control\", \"result\": 1.3849}, \n",
    "                 {\"run\": 1, \"date\": \"013020\", \"condition\": \"cold\", \"result\": .8309},\n",
    "                 {\"run\": 2, \"date\": \"013020\", \"condition\": \"control\", \"result\": 1.1384},\n",
    "                 {\"run\": 2, \"date\": \"013020\", \"condition\": \"cold\", \"result\": 1.0867},\n",
    "                 {\"run\": 3, \"date\": \"013020\", \"condition\": \"control\", \"result\": .8479},\n",
    "                 {\"run\": 3, \"date\": \"013020\", \"condition\": \"cold\", \"result\": .7238}]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For each experiment, print a complete sentence with the date, run, condition, and result. Use the `round()` function to round the result to two decimal places."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The sentence for the first experiment should read: On 013020, I conducted a control experiment; the result from run 1 was 1.38."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "On 013020, I conducted a control experiment; the result from run 1 was 1.38.\n",
      "On 013020, I conducted a cold experiment; the result from run 1 was 0.83.\n",
      "On 013020, I conducted a control experiment; the result from run 2 was 1.14.\n",
      "On 013020, I conducted a cold experiment; the result from run 2 was 1.09.\n",
      "On 013020, I conducted a control experiment; the result from run 3 was 0.85.\n",
      "On 013020, I conducted a cold experiment; the result from run 3 was 0.72.\n"
     ]
    }
   ],
   "source": [
    "for exp in results_dicts:\n",
    "    print(f'On {exp[\"date\"]}, I conducted a {exp[\"condition\"]} experiment; the result from run {exp[\"run\"]} was {round(exp[\"result\"], 2)}.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>*Don't forget that you need to use single quotes inside double quotes or double quotes inside single quotes.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <br>How to break up a long fstring without new lines to make it more readable when coding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "v1 = 10983736\n",
    "v2 = \"Tuesday\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a very long string it is 10983736 words long. I won't be done typing it until Tuesday.\n"
     ]
    }
   ],
   "source": [
    "my_fstring = (f\"This is a very long string\"\n",
    "f\" it is {v1} words long.\"\n",
    "f\" I won't be done typing it until {v2}.\")\n",
    "print(my_fstring)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <br><br><span style=\"color:teal\">More functions (if we have extra time)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Link to view a list of all Python built-in functions](https://docs.python.org/3/library/functions.html#all)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python has 68 built-in functions, including the functions to change the type of an object (`list(), dict(), range(), tuple(), set(), int(), str(), float(), bool()`). We touched on 18 of the 68 functions this week. Many of the others are used only in special cases or for more technical purposes, but some may interest you.\n",
    "<br><br>We will talk about `any()` and `all()` below. These functions only return a boolean."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>[Link to all built-in string methods](https://docs.python.org/3/library/stdtypes.html#string-methods)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are many string methods we didn't get to. Many of these evaluate to a boolean - we will talk about some of them below."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Link to all built-in list methods](https://docs.python.org/3/library/stdtypes.html#mutable-sequence-types)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are a few methods we didn't cover, and they may interest you, so take a look!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <br><br><span style=\"color:teal\">More conditionals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Conditionals are booleans (True or False) that can be used to filter objects when you use the conditional in an if/elif/else statement.\n",
    "<br><br>We learned `< > <= >= == !=` and `in`.\n",
    "<br><br>There are several functions that you can also use in an if statement to help you filter. **These all return only True or False.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### String methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check out the link above for the full list of string methods, but I will show some of the ones that you can use with if statements. For each function, I'll show one example that evaluates to True and one that evaluates to False."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### For each line of code, try to guess if it will return True or False:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"peanut butter\".endswith(\"butter\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"jelly\".endswith(\"butter\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"peanut butter\".startswith(\"peanut\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"jelly\".startswith(\"peanut\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"peanut butter\".isspace()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"     \".isspace()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"jelly\".isalpha()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"peanut butter\".isalpha()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"73117\".isdigit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"peanut butter\".isdigit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"peanut butter\".isupper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"JELLY\".isupper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"peanut butter\".islower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"JELLY\".islower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Peanut Butter\".istitle()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"jelly\".istitle()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>Here's an example in a for loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "jelly\n"
     ]
    }
   ],
   "source": [
    "for food in [\"peanut butter\", \"jelly\"]:\n",
    "    if food.isalpha():\n",
    "        print(food)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <br><br>Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`any()` and `all()` can be used to combine multiple conditionals into one boolean. \n",
    "<br><br>For `any()` to be True, only one conditional in a list needs to be True:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [],
   "source": [
    "song_list = [\"Don't Stop Me Now (Queen)\",\n",
    "             \"Dancing Queen (Abba)\",\n",
    "             \"Good Vibrations (The Beach Boys)\",\n",
    "             \"Uptown Girl (Billie Joel)\",\n",
    "             \"Eye of the Tiger (Survivor)\",\n",
    "             \"I'm a Believer (The Monkees)\",\n",
    "             \"Girls Just Wanna Have Fun (Cyndi Lauper)\",\n",
    "             \"Livin' on a Prayer (Jon Bon Jovi)\",\n",
    "             \"I Will Survive (Gloria Gaynor)\",\n",
    "             \"Walking on Sunshine (Katrina & The Waves)\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Don't Stop Me Now (Queen)\n",
      "Good Vibrations (The Beach Boys)\n",
      "I Will Survive (Gloria Gaynor)\n"
     ]
    }
   ],
   "source": [
    "for song in song_list:\n",
    "    if any([song.startswith(\"I\") and \"'\" not in song, \n",
    "            song.startswith(\"Don't\"),\n",
    "            song.startswith(\"Good\")]):\n",
    "        print(song)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br>For `all()` to be True, all the conditionals in a list need to be True:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Girls Just Wanna Have Fun (Cyndi Lauper)\n"
     ]
    }
   ],
   "source": [
    "for song in song_list:\n",
    "    if all([\"Girl\" in song, \n",
    "            song.istitle(),\n",
    "            len(song) >= 26]):\n",
    "        print(song)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}