python_II_2_workshop.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "2870c958",
   "metadata": {},
   "source": [
    "# Sequences\n",
    "*Sequences* are groups of objects that are ordered based on their position.<br>\n",
    "They are capable of *iteration*: returning their items one at a time.<br>\n",
    "Sequences in Python include strings and lists."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11c312c5",
   "metadata": {},
   "source": [
    "## Indexing\n",
    "Because items are positionally ordered, we can access individual items via *indexing*.<br>\n",
    "Indices are *zero-based*: They start at 0 for the first (left-most) item and increment by 1 for each consecutive item to the right.<br>\n",
    "The largest index, for the last (right-most) item, is n - 1, where n is the length of the sequence."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b83cda71",
   "metadata": {},
   "source": [
    "### Negative indices\n",
    "Negative indices are measured relative to the last (right-most) item of a sequence.<br>\n",
    "We can work backwards (from right to left) through a sequence using negative indices.<br>\n",
    "We can access the last item of a sequence using the -1 index.<br>\n",
    "We can progress to the left item by item by subtracting 1.<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33e7934f-beab-4341-adfd-93cef22ee3b4",
   "metadata": {},
   "source": [
    "## Slicing\n",
    "We can access ranges of items in sequences via *slicing*, which builds on indexing.<br>\n",
    "Slices have the form **[start:stop:step]**, where the item at index \"start\" is included in the returned subsequence and the item at index \"stop\" is excluded from the subsequence (i.e., the half-open interval \\[start, step) is returned).<br>\n",
    "\"Step\" is the increment from one index to the next.<br><br>\n",
    "Some of this information can be omitted because convenient defaults are provided.\n",
    "* If \"start\" is omitted, the subsequence begins with the first (left-most) item.\n",
    "* If \"stop\" is omitted, the subsequence proceeds through the last (right-most) item.\n",
    "* If \"step\" is omitted, the increment is 1."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ddf3a83b",
   "metadata": {},
   "source": [
    "## Strings as sequences\n",
    "Since strings are sequences, they can be indexed and sliced.<br>\n",
    "We will use the built-in **print( )** function to display their contents to the screen (more on functions later!)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "74f868a6",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_string = 'What a beautiful day!'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2606255c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Predict what each of the following will print before running this cell\n",
    "# First to type correct predictions for all seven tasks into the Zoom chat wins!\n",
    "print(my_string[0])\n",
    "print(my_string[7])\n",
    "print(my_string[-1])\n",
    "print(my_string[17:20])\n",
    "print(my_string[:4])\n",
    "print(my_string[13:])\n",
    "print(my_string[::2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dd5326bf",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Write code to print each of the following.\n",
    "# First to type correct code for all three tasks into the Zoom chat wins!\n",
    "# 1. Print the \"y\" in day.\n",
    "# 2. Print the word \"beautiful\" only, with no surrounding spaces.\n",
    "# 3. Challenge: Reverse the string.\n",
    "#\n",
    "#\n",
    "#"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac5977a7",
   "metadata": {},
   "source": [
    "## Strings and mutability"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f71eb73a",
   "metadata": {},
   "source": [
    "Strings are *immutable* (their values cannot change after the object is created) and *homogeneous* (same data type—Unicode code points—across items)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "303545c0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Try to use slicing to replace the word 'beautiful' with 'gorgeous' in my_string\n",
    "#"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78760e96",
   "metadata": {},
   "source": [
    "We got a <code>TypeError</code> because strings are immutable and their items cannot be changed after creation."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8928006",
   "metadata": {},
   "source": [
    "In contrast to strings, lists are mutable sequences that can be heterogeneous.<br>\n",
    "This means we can store different data types in lists, and we can use indexing and slicing to change their values."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9bbdefaa",
   "metadata": {},
   "source": [
    "## Lists\n",
    "Lists are *mutable* (items can change after the object is created) sequences that are indicated by square brackets **\\[ \\]** with zero or more comma-separated items inside."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3768ad9e-6538-47c7-9b96-5a75faa9d9d4",
   "metadata": {},
   "source": [
    "Lists usually are homogeneous, but they can be *heterogeneous* (items of different types)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "09563870",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list1 = ['A', 'm', 'a', 'n', 'd', 'a'] #homogeneous list\n",
    "my_list2 = [6, 'hi', True, -3.2] # heterogeneous list\n",
    "print(my_list1)\n",
    "print(my_list2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a9a74602",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Use indexing to replace 'hi' in my_list2 with 'goodbye'\n",
    "# Then, print the list to make sure it works\n",
    "#\n",
    "#"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e5aeb32",
   "metadata": {},
   "source": [
    "Lists also can be empty."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ee54e41a",
   "metadata": {},
   "outputs": [],
   "source": [
    "[] # empty list"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6ac1f5b1",
   "metadata": {},
   "source": [
    "We can convert a string—or any iterable object—to a list by calling the built-in **list( )** function. Each item in the string becomes an item in the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3168847c",
   "metadata": {},
   "outputs": [],
   "source": [
    "list('hello')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ab8fca6",
   "metadata": {},
   "source": [
    "We also can use list( ) to create an empty list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "71e85291",
   "metadata": {},
   "outputs": [],
   "source": [
    "list() # empty list"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d1bb1f0",
   "metadata": {},
   "source": [
    "We can call the built-in **len( )** function to check a list's length, by inserting the list or its variable name into the parentheses.<br>\n",
    "Let's use len( ) to check the length of my_list1. We expect it to have a length of 6, since it contains six items."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0638129b",
   "metadata": {},
   "outputs": [],
   "source": [
    "len(my_list1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c910079",
   "metadata": {},
   "source": [
    "### Animals example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bf71c9bd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: First, make a list of strings with the names of your three favorite animals, in descending order\n",
    "# from favorite animal on the left to 3rd-favorite animal on the right, and assign it to the variable animals.\n",
    "# Then, print the list to make sure it works.\n",
    "# Finally, use indexing to print your 2nd-favorite animal.\n",
    "#\n",
    "#\n",
    "#"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0162df64",
   "metadata": {},
   "source": [
    "We expect the length of the animals list to be 3. Let's use len( ) to check this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bab5f26e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Call len() on the animals list to verify it has a length of 3\n",
    "#"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "648c2490",
   "metadata": {},
   "source": [
    "### Weather example"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a63f0a4",
   "metadata": {},
   "source": [
    "The following data were measured at <a href=\"https://www.weather.gov/wrh/Climate?wfo=oun\">Will Rogers Airport</a> over the first 15 days of June. (Click on the Observed Weather tab to access such data.)<br>\n",
    "Assume that minimum/maximum relative humidity (RH) occurred at the same time as the minimum/maximum temperature (t)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "95558a63",
   "metadata": {},
   "outputs": [],
   "source": [
    "days = list(range(1, 16))\n",
    "t_min = [61, 59, 62, 61, 67, 68, 68, 79, 65, 67, 72, 71, 75, 76, 76]\n",
    "t_max = [76, 77, 78, 83, 80, 89, 84, 86, 83, 89, 94, 96, 94, 90, 91]\n",
    "rh_min = [71, 57, 53, 58, 56, 59, 70, 69, 59, 54, 51, 43, 39, 48, 56]\n",
    "rh_max = [100, 100, 83, 97, 96, 88, 100, 100, 93, 94, 97, 84, 71, 76, 77]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bbe6a781",
   "metadata": {},
   "source": [
    "We expect the length of each list to be 15, with one item per day."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2556d50b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Call len() on t_min to verify it has a length of 15\n",
    "#"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d231abde",
   "metadata": {},
   "source": [
    "Let's make sure all the lists have equal lengths!<br>\n",
    "We can compare the lists using the <code>==</code> operator, which checks if values are equal and returns <code>True</code> if they all are equal and <code>False</code> if any are not equal.<br>\n",
    "<code>True</code> and <code>False</code> are *Boolean values*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6e0aaf14",
   "metadata": {},
   "outputs": [],
   "source": [
    "len(days) == len(t_min) == len(t_max) == len(rh_min) == len(rh_max)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "12a45ef8",
   "metadata": {},
   "source": [
    "Let's try indexing these lists!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3a59c47a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Predict what each of the following will print before running this cell\n",
    "# First to type correct predictions for both tasks into the Zoom chat wins!\n",
    "print(rh_max[8])\n",
    "print(rh_min[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8836e171",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Print the fourth item (from the left) of t_max, using a positive index\n",
    "#"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9b074426",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Print the sixth item (from the left) of rh_max, using a positive index\n",
    "#"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "71ea87d5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Predict what each of the following will print before running this cell\n",
    "# First to type correct predictions for both tasks into the Zoom chat wins!\n",
    "print(t_min[-1])\n",
    "print(t_max[-5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "373f50ae",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Print the second-to-last item of days, using a negative index\n",
    "#"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "83b6a745",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Print the fourth item of t_max two different ways (one positive index, one negative index)\n",
    "#\n",
    "#"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28c7ed10",
   "metadata": {},
   "source": [
    "Let's try slicing!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c194b38d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Predict what each of the following will print before running this cell\n",
    "# First to type correct predictions for all four tasks into the Zoom chat wins!\n",
    "print(days[3:7:2])\n",
    "print(days[2:8])\n",
    "print(days[:5])\n",
    "print(days[4:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dbd886c3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Print the maximum temperatures for each day between June 2 through June 10, inclusive\n",
    "#"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "97f5bf79",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Print the maximum relative humidity for every other day for the entire rh_max list\n",
    "#"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bacf6c7b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Challenge: Print the maximum relative humidity for every other day for the entire rh_max list, in reverse!\n",
    "#"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83d8eaf6",
   "metadata": {},
   "source": [
    "<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "114bd0a4",
   "metadata": {},
   "source": [
    "# Control flow\n",
    "*Control flow* is the order in which pieces of a computer program are executed.<br>\n",
    "We will discuss the following aspects of control flow in Python:\n",
    "* Indentation\n",
    "* Conditional execution via <code>if</code> statements\n",
    "* Repetition via <code>for</code> and <code>while</code> loops\n",
    "* Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10352c3b",
   "metadata": {},
   "source": [
    "# Indentation and code blocks\n",
    "*Indentation* is \"leading whitespace\": whitespace at the beginning of a line of code.<br>\n",
    "You can use either spaces or tabs to produce indentation, but **you cannot mix them!**<br>\n",
    "Indentation is used to group statements.<br>\n",
    "Code at smaller indentation level is given higher priority.<br><br>\n",
    "A *code block* is a piece of code that is executed as a unit.<br>\n",
    "Multi-line code blocks are defined via indentation.\n",
    "* Indentation creates a multi-line code block.\n",
    "* Dedentation terminates a multi-line code block."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d23f63b",
   "metadata": {},
   "source": [
    "# <code>if</code> statements\n",
    "The <code>if</code> statement is used for *conditional execution*: It allows action(s) in the *suite* (statement(s) at greater indentation beneath the header) to be executed only if the expression following the <code>if</code> keyword in the header is true.<br>\n",
    "~~~python\n",
    "if condition:\n",
    "    statement\n",
    "    statement\n",
    "    ...\n",
    "~~~"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76ed0608",
   "metadata": {},
   "source": [
    "Optionally, multiple conditions can be checked using one or more <code>elif</code> clauses.<br>\n",
    "**Only the suite for the first true condition is executed; all others headers and suites are ignored!**\n",
    "~~~python\n",
    "if condition:\n",
    "    statement\n",
    "    statement\n",
    "    ...\n",
    "elif condition:\n",
    "    statement\n",
    "    statement\n",
    "    ...\n",
    "elif condition:\n",
    "    statement\n",
    "    statement\n",
    "    ...\n",
    "...\n",
    "~~~"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb70006c",
   "metadata": {},
   "source": [
    "Optionally, when none of the conditions are true, action(s) can be executed in the suite for the <code>else</code> clause.\n",
    "~~~python\n",
    "if condition:\n",
    "    statement\n",
    "    statement\n",
    "    ...\n",
    "elif condition:\n",
    "    statement\n",
    "    statement\n",
    "    ...\n",
    "elif condition:\n",
    "    statement\n",
    "    statement\n",
    "    ...\n",
    "...\n",
    "else:\n",
    "    statement\n",
    "    statement2\n",
    "    ...\n",
    "~~~"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84de36f7",
   "metadata": {},
   "source": [
    "Let's work together to build an <code>if</code> statement for the animals list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f33759b2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Code will go here"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04101ebe-266f-4ece-bbca-dcb60ad7b59a",
   "metadata": {},
   "source": [
    "# Loops\n",
    "*Loops* enable code to be executed repeatedly."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6681d767-37ac-41be-836e-bde20617fa51",
   "metadata": {},
   "source": [
    "## <code>for</code> loops\n",
    "Code is executed repeatedly, once for each item of an iterable object.<br>\n",
    "For a sequence, the items are iterated in order by index.<br>\n",
    "~~~python\n",
    "for item in iterable:\n",
    "    statement\n",
    "    statement\n",
    "    ...\n",
    "~~~"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd902298",
   "metadata": {},
   "source": [
    "Let's put together what we know so far about indentation, <code>if</code> statements, and <code>for</code> loops to organize the 10 main cloud types, based on their prefixes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "54b27cac",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize empty lists for each cloud type\n",
    "low_clouds = []\n",
    "middle_clouds = []\n",
    "high_clouds = []\n",
    "tall_clouds = []\n",
    "\n",
    "# List of 10 main cloud types\n",
    "# Square brackets (and parentheses and curly braces) allow us to continue long expressions on multiple lines\n",
    "cloud_list = ['altocumulus', 'cirrostratus', 'cumulonimbus', 'stratus', 'nimbostratus', 'cirrus', 'cumulus',\n",
    "              'altostratus', 'stratocumulus', 'cirrocumulus']\n",
    "\n",
    "# Append each cloud type to the correct list\n",
    "for cloud in cloud_list:\n",
    "    if (cloud[:5] == 'nimbo') or (cloud[:6] == 'strato') or (cloud == 'stratus'):\n",
    "        low_clouds.append(cloud) # list.append() is a method to add an item to the end of a list\n",
    "    elif cloud[:4] == 'alto':\n",
    "        middle_clouds.append(cloud)\n",
    "    elif (cloud[:5] == 'cirro') or (cloud == 'cirrus'):\n",
    "        high_clouds.append(cloud)\n",
    "    else:\n",
    "        tall_clouds.append(cloud)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "032a40bf",
   "metadata": {},
   "source": [
    "Let's check out the results!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5fb3012e",
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Low clouds: ', low_clouds)\n",
    "print('Middle clouds: ', middle_clouds)\n",
    "print('High clouds: ', high_clouds)\n",
    "print('Tall clouds: ', tall_clouds)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8059bade",
   "metadata": {},
   "source": [
    "## <code>while</code> loops\n",
    "Code is executed repeatedly, as long as a condition is true.<br>\n",
    "On each iteration, the condition following the <code>while</code> keyword in the header is checked, and if it is true, the code is executed.<br>\n",
    "When the condition is false, the loop terminates.\n",
    "~~~python\n",
    "while condition:\n",
    "    statement\n",
    "    statement\n",
    "    ...\n",
    "~~~"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "05b57356",
   "metadata": {},
   "outputs": [],
   "source": [
    "day_of_month = 1 # start with the first day of the month\n",
    "while day_of_month <= 15:\n",
    "    print('It is day ' + str(day_of_month) + ' of the month') # str() converts an object to a string\n",
    "    day_of_month += 1 # augmented assignment, equivalent to day_of_month = day_of_month + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99ada500",
   "metadata": {},
   "source": [
    "## <code>break</code> statement\n",
    "Use a <code>break</code> statement to terminate a loop.<br>\n",
    "The <code>break</code> statement most often is used to terminate a loop when a certain condition is true."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f586a69b",
   "metadata": {},
   "source": [
    "Let's work together to build code to stop iterating through a list of hypothetical winter daily average temperatures when we reach the first at- or below-freezing temperature (32°F)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5b07c7d9",
   "metadata": {},
   "outputs": [],
   "source": [
    "avg_temps = [42, 36, 41, 38, 38, 35, 36, 33, 31, 34, 36, 30, 32, 33] # winter daily average temperatures in °F"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a216198c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Option #1, using for loop\n",
    "\n",
    "# Code will go here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fa8aca8b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Option #2, using while loop\n",
    "\n",
    "# Code will go here"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "773b557d",
   "metadata": {},
   "source": [
    "## <code>continue</code> statement\n",
    "Use a <code>continue</code> statement to skip any further statements in the suite of a loop for the current iteration, and instead return to the header for further execution.<br>\n",
    "The <code>continue</code> statement most often is used to return to the start of a loop when a certain condition is true."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "167aca39",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Option #1\n",
    "\n",
    "for temp in avg_temps:\n",
    "    print('Temperature is: ' + str(temp) + '°F')\n",
    "    if temp <= 32:\n",
    "        continue\n",
    "    print('This temperature is above freezing')\n",
    "print('Loop ended.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6bed561a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Option #2\n",
    "\n",
    "# Initialize counter\n",
    "i = 0\n",
    "\n",
    "while i < len(avg_temps):\n",
    "    current_temp = avg_temps[i]\n",
    "    print('Temperature is: ' + str(current_temp) + '°F')\n",
    "    i += 1\n",
    "    if current_temp <= 32:\n",
    "        continue\n",
    "    print('This temperature is above freezing.')\n",
    "print('Loop ended.')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "151bdcb3",
   "metadata": {},
   "source": [
    "<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f21d1d9-7dcd-40db-923f-08a0c73a7159",
   "metadata": {},
   "source": [
    "# Functions\n",
    "A body of statements that takes some action(s) and/or *returns* (passes back to the user) some value(s) when *called* (executed).<br>\n",
    "Can be passed zero or more *arguments* (values) to be assigned to *parameters* that may be used in the execution of the suite."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa9d284e",
   "metadata": {},
   "source": [
    "## Built-in functions\n",
    "Python provides many built-in functions that always are available to the user (no <code>import</code> statement required) and can be applied to many data types.<br>\n",
    "Here are several useful built-in functions.<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e3aaf264-71bc-4760-9c7a-11ef25bdecc2",
   "metadata": {},
   "source": [
    "| Function | Description |\n",
    "| -------- | ----------- |\n",
    "| abs(x) | returns absolute value of number x |\n",
    "| bool(o) | returns Boolean value of object o |\n",
    "| divmod(x, y) | returns (quotient, remainder) pairs |\n",
    "| enumerate(o) | returns (index, value) pairs for iterable object o |\n",
    "| id(o) | returns address of object o in memory, as an integer |\n",
    "| len(o) | returns number of items in iterable object o |\n",
    "| list(o) | returns list constructed from items in iterable object o |\n",
    "| max(o) | returns largest item in iterable object o |\n",
    "| min(o) | returns smallest item in iterable object o |\n",
    "| pow(x, y) | returns x to the power y |\n",
    "| print(o) | displays representation of object o to screen (or other standard output device) |\n",
    "| range(start=0, stop, step=0) | creates sequence of numbers |\n",
    "| round(x, n) | returns x rounded to n digits precision after the decimal point |\n",
    "| str(o) | returns string version of object o |\n",
    "| sum(o) | returns sum of items in iterable object o |\n",
    "| type(o) | returns the type (list, bool, str, etc.) of object o |"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad005793",
   "metadata": {},
   "source": [
    "Built-in functions are called using the format **function_name(arg1, arg2, ...)**, where values are inserted for each argument as necessary."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f44978ae",
   "metadata": {},
   "source": [
    "### Examples of built-in functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7a240b7a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Make a list of the letters in the string 'weather'\n",
    "#"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5d8d08f9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Print the coldest of the minimum temperatures in t_min.\n",
    "# Then, print the warmest of the maximum temperatures in t_max.\n",
    "#\n",
    "#"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "568f5197",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Challenge: Use the sum() function along with other calculations to find the average minimum temperature\n",
    "#"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "885ebb59",
   "metadata": {},
   "source": [
    "## Methods\n",
    "A *method* is a function that belongs to, or is associated with, a particular type of object.<br>\n",
    "Special calling format: **object.method_name(arg1, arg2, ...)**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98c14d5a",
   "metadata": {},
   "source": [
    "### List methods"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fabb7813",
   "metadata": {},
   "source": [
    "Run each of the following cells to demonstrate some list methods.<br>\n",
    "Predict what each method will do based on its name, before running the cell!<br>\n",
    "Notice that each of these methods acts *in-place*: It permanently modifies the list!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a95ef1f0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Predict what append will do to the list before running this cell\n",
    "# First to type correct prediction into the Zoom chat wins!\n",
    "my_list1.append('A')\n",
    "my_list1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6906d55a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Predict what extend will do to the list before running this cell\n",
    "# First to type correct prediction into the Zoom chat wins!\n",
    "my_list1.extend(['B', 'C'])\n",
    "my_list1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eeb54169",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Predict what pop will do to the list before running this cell\n",
    "# First to type correct prediction into the Zoom chat wins!\n",
    "my_list1.pop()\n",
    "my_list1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e50ad306",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: You can put the index of the item you want to remove into pop() to remove that element\n",
    "# First, remove the 'n' from my_list1\n",
    "# Then, check out what my_list1 looks like\n",
    "#\n",
    "#"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bcdf19c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Predict what reverse will do to the list before running this cell\n",
    "# First to type correct prediction into the Zoom chat wins!\n",
    "my_list1.reverse()\n",
    "my_list1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "47b8e47d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Predict what sort will do to the list before running this cell\n",
    "# First to type correct prediction into the Zoom chat wins!\n",
    "my_list1.sort()\n",
    "my_list1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1524c99c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Predict what clear will do to the list before running this cell\n",
    "# First to type correct prediction into the Zoom chat wins!\n",
    "my_list1.clear()\n",
    "my_list1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b2f544cc",
   "metadata": {},
   "source": [
    "If you want to perform a certain action on a list, there is a good chance a method already exists to do it!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f57580f0",
   "metadata": {},
   "source": [
    "## User-defined functions\n",
    "Sometimes, built-in functions or methods aren't sufficient for our needs.<br>\n",
    "In these cases, we can write our own functions!<br><br>\n",
    "Besides helping us accomplish what we need to do, writing our own functions takes our code to the next level by:\n",
    "* improving readability\n",
    "* automating tasks\n",
    "* reusing code rather than retyping it\n",
    "* breaking large tasks into smaller parts"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22847726",
   "metadata": {},
   "source": [
    "You can define your own function using the following *function definition* syntax (<em>parameters</em> and a <code>return</code> statement are optional).<br>\n",
    "~~~python\n",
    "def function_name(param1, param2, ...):\n",
    "    statement\n",
    "    statement\n",
    "    ...\n",
    "    ...\n",
    "    return value(s)\n",
    "~~~"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6ea20f0",
   "metadata": {},
   "source": [
    "Defining a function adds it to the *namespace* of the program, which means it can be accessed by the program.<br>\n",
    "A function will not do anything until it is called.<br>\n",
    "Like built-in functions, a user-defined function is called using the format **function_name(arg1, arg2, ...)**, where values are inserted for each argument as necessary.<br><br>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3b8e3f7-4345-48b5-b337-968035f48368",
   "metadata": {},
   "source": [
    "A <code>return</code> statement exits the function: No more code in the suite is executed.<br>\n",
    "No more code in the suite is executed after the return statement is run, so place it carefully!<br><br>\n",
    "If no values follow a <code>return</code> statement, or if an explicit <code>return</code> statement is omitted, by default, Python will cause the function to return <code>None</code>."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d94bac97",
   "metadata": {},
   "source": [
    "### i_love_cats() example"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db1a41c9",
   "metadata": {},
   "source": [
    "Run the cell below that to define i_love_cats.<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d2dacb07",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example user-defined function\n",
    "def i_love_cats():\n",
    "    print('Important message incoming.')\n",
    "    return \"I love cats! They're my favorite!\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a28ace77",
   "metadata": {},
   "source": [
    "Why didn't we see the printed statement or output string when we ran the cell?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "117dc7fd",
   "metadata": {},
   "source": [
    "Running the cell with the function definition simply adds i_love_cats to the namespace of this notebook. It does not call the function.<br>\n",
    "Now we can call the function in this notebook to cause its suite to execute.<br>\n",
    "The function will execute only when it is called as i_love_cats()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "66fcae87",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Call the function by typing i_love_cats() and running this cell\n",
    "#"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94784340",
   "metadata": {},
   "source": [
    "i_love_cats() returns a string, which we can assign to a variable for use elsewhere.<br>\n",
    "Let's call i_love_cats(), store its return value in a variable, and print it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7a9bcd6f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Code will go here"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6efc1c4",
   "metadata": {},
   "source": [
    "What would have happened if we had put the <code>return</code> statement before print()?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "87b92b08",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Predict what switching the order of the return and print statements will do before running this cell\n",
    "# First to type correct prediction into the Zoom chat wins!\n",
    "def i_love_cats():\n",
    "    return \"I love cats! They're my favorite!\"\n",
    "    print('Important message incoming.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "126ca0a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Call i_love_cats() and see if your prediction came true\n",
    "#"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76d60698",
   "metadata": {},
   "source": [
    "Remember that nothing is run after a <code>return</code> statement is executed!<br>\n",
    "print( ) is never called.<br>\n",
    "Place <code>return</code> statements carefully in your own functions!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a9012a2",
   "metadata": {},
   "source": [
    "### silly_print() example"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db8c2465",
   "metadata": {},
   "source": [
    "Run the cell with the function definition for silly_print to add it to the notebook namespace.<br>\n",
    "Notice that silly_print has one parameter, which means the user must supply one argument to run it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d3f9687f-d097-4788-8eda-1514920b4a6c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example user-defined functioon\n",
    "def silly_print(s):\n",
    "    return 'Silly ' + s + '!'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "401dbbe8",
   "metadata": {},
   "source": [
    "Call silly_print() several times, each time with a different argument in place of the parameter.<br>\n",
    "I've given you a couple of examples to get you started.<br>\n",
    "Choose your own arguments!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0421f83b-618f-4ba6-83d1-f76705ce83ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "# My examples\n",
    "print(silly_print('hi'))\n",
    "print(silly_print('cat'))\n",
    "\n",
    "# Exercise: Insert your own argument by typing inside the empty string\n",
    "#print(silly_print(''))\n",
    "#print(silly_print(''))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "099d1b83",
   "metadata": {},
   "source": [
    "What happens if we call silly_print() without inserting an argument?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "63a0c912",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Predict what calling silly_print() without an argument will do before running this cell\n",
    "# First to type correct prediction into the Zoom chat wins!\n",
    "silly_print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d3af728",
   "metadata": {},
   "source": [
    "We can avoid this type of problem by adding a *default parameter value*.<br>\n",
    "Let's add a default value to silly_print()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c9831f68",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Modified example\n",
    "def silly_print(s='default'):\n",
    "    return 'Silly ' + s + '!'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "033b570f",
   "metadata": {},
   "source": [
    "Now let's see what happens when we call silly_print() with no argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b72d7bba",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Predict what calling silly_print() without an argument will do before running this cell\n",
    "# First to type correct prediction into the Zoom chat wins!\n",
    "silly_print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81ea187a",
   "metadata": {},
   "source": [
    "Can we still call silly_print() with our own argument? Try it out!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "53dcaace",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Insert your own argument by typing inside the empty string\n",
    "#print(silly_print(''))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9292e912",
   "metadata": {},
   "source": [
    "### Weather example"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "745a9cf4",
   "metadata": {},
   "source": [
    "Meteorologists frequently perform calculations to convert numbers from one system of units to another.<br>\n",
    "Let's write a function that converts a temperature given in Fahrenheit to Celsius.<br>\n",
    "We will include a *docstring*, which is a special type of comment that documents the functions' behavior.<br><br>\n",
    "The conversion equation from Fahrenheit to Celsius is:<br>\n",
    "$$T_{°C}=\\frac{5}{9}(T_{°F}-32)$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d4f7021e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def fahrenheit_to_celsius(t):\n",
    "    \"\"\"Take a temperature in Fahrenheit and return its Celsius value.\"\"\"\n",
    "    return 5/9 * (t-32)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe3a12a3",
   "metadata": {},
   "source": [
    "Let's try it out!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "699d7ebe",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convert the freezing temperature 32°F to Celsius\n",
    "print(fahrenheit_to_celsius(32))\n",
    "# Convert the boiling temperature 212°F to Celsius\n",
    "#\n",
    "# Convert Earth's average surface temperature 59°F to Celsius\n",
    "#\n",
    "# Convert the pleasant temperature 70°F to Celsius\n",
    "#"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7dd3d5b0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Insert your own Fahrenheit temperature to convert it to Celsius\n",
    "#print(fahrenheit_to_celsius())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "23496202",
   "metadata": {},
   "source": [
    "Write your own function to convert a temperature given in Fahrenheit to Kelvin!<br><br>\n",
    "The conversion equation from Fahrenheit to Celsius is:<br>\n",
    "$$T_{K}=\\frac{5}{9}(T_{°F}-32)+273.15$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3398d046",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Write a function to convert a temperature given in Fahrenheit to Kelvin\n",
    "# Include a docstring!\n",
    "#\n",
    "#\n",
    "#"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f7e0c92",
   "metadata": {},
   "source": [
    "Test your function on a few temperatures. Consider if you would like to rewrite the function to round your answer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9ce2d48e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Insert some Fahrenheit temperatures into your function and print its results\n",
    "#\n",
    "#\n",
    "#"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c63a9e8",
   "metadata": {},
   "source": [
    "What if we want to apply this function to every temperature in a list of temperatures, without having to access each temperature manually ourselves?<br>\n",
    "We could use a <code>for</code> loop!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "40757ee1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use a for loop to convert every Fahrenheit temperature in t_max to Celsius\n",
    "# Code will go here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4244f3c7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Use a for loop and your own function to convert every Fahrenheit temperature in t_min to Kelvin\n",
    "#\n",
    "#"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb4c8216",
   "metadata": {},
   "source": [
    "We also could use the **map( )** built-in function, which applies a function to each item in an iterable object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e91dd24d",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(*list(map(fahrenheit_to_celsius, t_max)), sep=', ')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d66193a9",
   "metadata": {},
   "source": [
    "<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b14579d",
   "metadata": {},
   "source": [
    "# Structured programming\n",
    "*Structured programming* uses control flow to produce optimal code that is readable, reusable, efficient, and straightforward to develop and modify.<br>\n",
    "It is guided by the principles of:\n",
    "* sequence (order of execution)\n",
    "* selection (conditional execution)\n",
    "* iteration (repeated execution)\n",
    "\n",
    "These principles appear in Python as:\n",
    "* sequence (order of statements and function calls)\n",
    "* selection (<code>if</code> statements)\n",
    "* iteration (<code>for</code> and <code>while</code> loops)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f06d514",
   "metadata": {},
   "source": [
    "## Tips for structured programming\n",
    "* Consider the steps of the full task you're trying to accomplish. Arrange statements and function calls to accomplish these steps in a logical order.\n",
    "* Consider specific actions you must carry out. These should be defined as functions and called in a logically ordered way in the program.\n",
    "* Consider if some steps should be taken only under certain conditions. These require conditional statements.\n",
    "* Consider of some steps should be repeated. These require loops."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bcc26b68",
   "metadata": {},
   "source": [
    "## Guess-a-Word game\n",
    "Let's build a game using structured programming!<br>\n",
    "The computer will randomly choose a 5-letter word from a list.<br>\n",
    "On each turn, you (the player) will guess a letter that you hope appears in the word.<br>\n",
    "You win if you complete the word without making 5 wrong guesses!<br><br>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9adb270",
   "metadata": {},
   "source": [
    "Let's break this down into steps.\n",
    "* The computer must choose the word randomly from a list.\n",
    "* The computer must give the player repeated chances to guess the word.\n",
    "* The player must guess a letter on each attempt.\n",
    "* The computer must check each guessed letter.\n",
    "    * If the letter is incorrect, the computer must count the wrong guess toward the 5 wrong guess total.\n",
    "    * If the letter is correct, the computer must add the letter to the word and display it to the player.\n",
    "* If the player makes 5 wrong guesses, they lose.\n",
    "    * The computer shows the player the correct word.\n",
    "* If the player completes the word without making 5 wrong guesses, they win."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75dc7e4c",
   "metadata": {},
   "source": [
    "We will break these steps into individual functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2707eb5f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def guess_a_letter():\n",
    "    \"\"\"Ask the player to guess a letter and then add guessed letter to a list of guessed letters.\n",
    "    \n",
    "    Returns\n",
    "    str\n",
    "        The guessed letter\n",
    "    \"\"\"\n",
    "        \n",
    "    while True:\n",
    "        guessed_letter = input('Guess a letter: ').lower()\n",
    "        if guessed_letter not in guessed_letters:\n",
    "            guessed_letters.append(guessed_letter)\n",
    "            break\n",
    "        else:\n",
    "            print('You already guessed that letter! Try again.\\n')\n",
    "                \n",
    "    return guessed_letter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "234b218e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_a_letter(current_word, attempts_left):\n",
    "    \"\"\"Check if a guessed letter is in the secret word.\n",
    "    \n",
    "    If the guessed letter is in the word, add it to the word.\n",
    "    If the guessed letter is not in the word, record the incorrect guess.\n",
    "    \n",
    "    Params\n",
    "    guessed_letter : str\n",
    "        The player's guessed letter\n",
    "    secret_word : list\n",
    "        The secret word as a list of its letters\n",
    "        \n",
    "    Returns\n",
    "        None\n",
    "    \"\"\"\n",
    "    \n",
    "#    global attempts_left\n",
    "#    global current_word\n",
    "    \n",
    "    if guessed_letter in secret_word:\n",
    "        print('Great guess! That letter is in the word!')\n",
    "        for index, letter in enumerate(secret_word):\n",
    "            if letter == guessed_letter:\n",
    "                current_word[index] = guessed_letter\n",
    "    else:\n",
    "        print('Sorry, that\\'s not in the word!')\n",
    "        attempts_left -= 1\n",
    "    \n",
    "    return current_word, attempts_left"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4a1fe5a9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_current_word():\n",
    "    \"\"\"Tell the player when they have won.\"\"\"\n",
    "        \n",
    "    if ''.join(current_word) == secret_word:\n",
    "        print('You won!')\n",
    "        print('The word is: ' + secret_word)\n",
    "        return True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cffad851",
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_guesses_left():\n",
    "    \"\"\"Tell the player if they have guesses left or have used up all guesses.\"\"\"\n",
    "        \n",
    "    if attempts_left > 1:\n",
    "        print('You have ' + str(attempts_left) + ' wrong guesses left.')\n",
    "        return True\n",
    "    elif attempts_left == 1:\n",
    "        print('You have ' + str(attempts_left) + ' wrong guess left.')\n",
    "        return True\n",
    "    else:\n",
    "        print('No more guesses remaining!')\n",
    "        print('The correct answer was: ' + secret_word)\n",
    "        return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b720a62b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def display_current_word():\n",
    "    \"\"\"Display the player's correct guesses toward the secret word.\"\"\"\n",
    "        \n",
    "    print('Current word: ' + ' '.join(current_word) + '\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d519ab3a",
   "metadata": {},
   "source": [
    "Let's put it all together and make the game!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fd043efc",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"Guess-A-Word, a 5-letter word guessing game\n",
    "\n",
    "The computer randomly chooses a 5-letter word from a list.\n",
    "The player guesses one letter each turn. If the letter is correct, it is added to the word.\n",
    "The player can keep guessing until five incorrect guesses are reached.\n",
    "Then, the computer reveals the word and the game is over.\n",
    "\"\"\"\n",
    "\n",
    "# import other modules to gain access to their code\n",
    "import random, time\n",
    "\n",
    "from IPython.display import clear_output\n",
    "\n",
    "# List of 5-letter words\n",
    "wordlist = ['spine', 'chalk', 'areal', 'trash', 'slimy', 'break', 'blame', 'bread', 'third', 'chart', 'shake', \n",
    "    'shame', 'flash', 'queen', 'zebra', 'slice', 'cream', 'flask', 'plate', 'storm', 'stern', 'cobra', 'slash',\n",
    "    'grant', 'share', 'snare', 'clash', 'braid', 'fluff', 'radio', ]\n",
    "\n",
    "# Welcome and instructions\n",
    "print('Welcome to Guess-A-Word!')\n",
    "print('You can guess one letter per attempt.')\n",
    "print('Only five wrong guesses are allowed!\\n')\n",
    "time.sleep(0.2)\n",
    "\n",
    "while True:\n",
    "    \n",
    "    # Initialize\n",
    "    secret_word = random.choice(wordlist)\n",
    "    current_word = ['_'] * len(secret_word)\n",
    "    guessed_letters = []\n",
    "    attempts_left = 5\n",
    "\n",
    "    # Game loop\n",
    "    while attempts_left > 0:\n",
    "\n",
    "        # You will call the functions appropriately here!\n",
    "        \n",
    "        # conditional statements will be needed\n",
    "        \n",
    "        # break and continue statements will be needed\n",
    "    \n",
    "    # Ask the player if they want to play again\n",
    "    play_again = input('Want to play again? Type Y or N: ')\n",
    "    if play_again.upper() != 'Y':\n",
    "        print('\\nThanks for playing!\\nGame Over.')\n",
    "        break\n",
    "    else:\n",
    "        clear_output()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "954a1f5f",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}