week_5_instructor_notes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ca53641d-6973-4ba3-9bbb-267957d24212",
   "metadata": {},
   "source": [
    "# Python Basics Week 5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10f1f5d0-19ea-4f81-89e7-4c50be823b65",
   "metadata": {},
   "source": [
    "Week 5 topics:\n",
    "- Dictionaries\n",
    "- The def statement\n",
    "- Try, Except, Raise"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94882059-60ae-4466-8ee5-634bf678341c",
   "metadata": {},
   "source": [
    "## Defining Custom Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e7e66ca-3d3f-431f-b60e-a0a18edd0677",
   "metadata": {},
   "source": [
    "The keyword `def` is used to define a custom function. Up until now, we have been writing code in our Jupyter notebooks and executing one cell at a time. If we have a task that we're going to perform repeatedly throughout our project or code, it will serve us better if we define that task as a custom function up front, and then just call the function when we need that task performed in the future. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4b50fe5-15a1-4e8e-9111-d5cb454d1b54",
   "metadata": {},
   "source": [
    "### The def Statement"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84551440-86fa-4fc2-99fc-7bdf52533be7",
   "metadata": {},
   "source": [
    "1. Start with the keyword \"def\"\n",
    "2. Define the name of your function\n",
    "3. Type a pair of parentheses\n",
    "4. Optional: if you want the function to take arguments, define a name for those variables\n",
    "5. End the statement with a colon"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "32f5f70f-b87f-41ec-b072-d4130b382ecc",
   "metadata": {},
   "outputs": [],
   "source": [
    "def function_name(arguments):\n",
    "    body of the function goes here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "1dd7753b-e18c-4312-a0dc-bba7578ffdb9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Good morning!\n"
     ]
    }
   ],
   "source": [
    "# A function that does not take an argument\n",
    "def greeting1():\n",
    "    print(\"Good morning!\")\n",
    "\n",
    "greeting1()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "985fa4fd-c58a-41b4-a6cb-d940c861eab4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Please enter your name: Shelby\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Good morning, Shelby!\n"
     ]
    }
   ],
   "source": [
    "# Another function that does not take an argument\n",
    "def greeting2():\n",
    "    name = input(\"Please enter your name:\")\n",
    "    print(f'Good morning, {name}!')\n",
    "\n",
    "greeting2()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "68b4d282-f8b7-496e-86f7-482843a86312",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "greeting2() takes 0 positional arguments but 1 was given",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[40], line 3\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[38;5;66;03m# If I try to pass an argument to a function that doesn't take one \u001b[39;00m\n\u001b[0;32m      2\u001b[0m \u001b[38;5;66;03m# or extra arguments that a function isn't expecting:\u001b[39;00m\n\u001b[1;32m----> 3\u001b[0m greeting2(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mShelby\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
      "\u001b[1;31mTypeError\u001b[0m: greeting2() takes 0 positional arguments but 1 was given"
     ]
    }
   ],
   "source": [
    "# If I try to pass an argument to a function that doesn't take one \n",
    "# or extra arguments that a function isn't expecting:\n",
    "greeting2(\"Shelby\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "dc006fd3-bf18-4914-84c5-7acd7a43368d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Good morning, Shelby!\n",
      "Good morning, Ivy!\n",
      "Good morning, Carolyne!\n"
     ]
    }
   ],
   "source": [
    "# A function that takes an argument\n",
    "def greeting3(name):\n",
    "    print(f'Good morning, {name}!')\n",
    "greeting3(\"Shelby\")\n",
    "greeting3(\"Ivy\")\n",
    "greeting3(\"Carolyne\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "a04d4781-253e-4ae1-a63a-af8fea371c5e",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "greeting3() takes 1 positional argument but 2 were given",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[43], line 2\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[38;5;66;03m# Again, if I try to pass extra arguments:\u001b[39;00m\n\u001b[1;32m----> 2\u001b[0m greeting3(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mShelby\u001b[39m\u001b[38;5;124m\"\u001b[39m,\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mWatson\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
      "\u001b[1;31mTypeError\u001b[0m: greeting3() takes 1 positional argument but 2 were given"
     ]
    }
   ],
   "source": [
    "# Again, if I try to pass extra arguments:\n",
    "greeting3(\"Shelby\",\"Watson\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "22681ccc-4341-4cb1-8824-8d0b312bc2d2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am a doctoral student.\n",
      "I am a masters student.\n",
      "I am a undergraduate student.\n"
     ]
    }
   ],
   "source": [
    "# A function with a default value\n",
    "def student(program = \"doctoral\"):\n",
    "    print(f'I am a {program} student.')\n",
    "student()\n",
    "student(\"masters\")\n",
    "student(\"undergraduate\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "d9066df0-f369-484e-8aaf-32157b5f4657",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My first name is Shelby.\n",
      "My last name is Watson.\n"
     ]
    }
   ],
   "source": [
    "# A function that takes an arbitrary number of arguments (*args)\n",
    "def who_am_i(*name):\n",
    "    print(f'My first name is {name[0]}.\\nMy last name is {name[-1]}.')\n",
    "\n",
    "who_am_i(\"Shelby\", \"Ann\", \"Watson\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "fa339044-e464-4982-a274-62d1a6ef7f87",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My first name is Shelby.\n",
      "My last name is Watson.\n"
     ]
    }
   ],
   "source": [
    "# A function that takes an arbitrary number of keyword arguments (**kwargs)\n",
    "def who_am_i_2(**name):\n",
    "    print(f'My first name is {name[\"first_name\"]}.\\nMy last name is {name[\"last_name\"]}.')\n",
    "\n",
    "who_am_i_2(last_name = \"Watson\", first_name = \"Shelby\")\n",
    "# Notice that the order in which we enter the arguments no longer matters, as it did above"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "e53808d3-5c80-43c2-91cd-dcc6defa7eb3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# How would we know which keywords should be entered?\n",
    "# We can give some information in the docstring for the function\n",
    "# Note - according to PEP8, docstrings are always in triple quotes\n",
    "# even if they only take one line, so they can be expanded if needed\n",
    "def who_am_i_2(**name):\n",
    "    \"\"\"Reports first and last name. Takes first_name and last_name as arguments.\"\"\"\n",
    "    \n",
    "    print(f'My first name is {name[\"first_name\"]}.\\nMy last name is {name[\"last_name\"]}.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "639645fd-c9b6-411a-8c10-3dd088705ac6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function who_am_i_2 in module __main__:\n",
      "\n",
      "who_am_i_2(**name)\n",
      "    Reports first and last name. Takes first_name and last_name as arguments.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(who_am_i_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "65e90ba5-1ad4-42b0-a703-6906dfb6a033",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function print in module builtins:\n",
      "\n",
      "print(*args, sep=' ', end='\\n', file=None, flush=False)\n",
      "    Prints the values to a stream, or to sys.stdout by default.\n",
      "    \n",
      "    sep\n",
      "      string inserted between values, default a space.\n",
      "    end\n",
      "      string appended after the last value, default a newline.\n",
      "    file\n",
      "      a file-like object (stream); defaults to the current sys.stdout.\n",
      "    flush\n",
      "      whether to forcibly flush the stream.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(print)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97364d8b-277a-4cc7-ad00-66e0865610ea",
   "metadata": {},
   "source": [
    "### Let's start putting it all together"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56c29799-6903-4617-8f23-dc073bc0a2e8",
   "metadata": {},
   "source": [
    "#### The pallindrome function"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "74d34e0e-aa98-4b09-98e1-bd2a52498b5a",
   "metadata": {},
   "source": [
    "This is one solution to last week's pallindromic phrases challenge."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "5a96a90c-a884-41f9-a320-8e6d6e4bc959",
   "metadata": {},
   "outputs": [],
   "source": [
    "def pallindrome(phrase):\n",
    "    \"\"\"Checks whether a string is a pallindrome\"\"\"\n",
    "    \n",
    "    import string\n",
    "    phrase_stripped = phrase.lower().translate(str.maketrans('', '', string.punctuation)).replace(' ','')\n",
    "    # Make the characters all lowercase, remove punctuation, and use str.replace to remove the whitespace\n",
    "    \n",
    "    # .translate replaces characters in a string; to replace multiple characters, we make a\n",
    "    # mapping table with .maketrans and specify what we're replacing (string.punctuation)\n",
    "    # and what we want to replace those characters with ('' and '')\n",
    "    # Why two '' in .maketrans? Because the method is expecting three arguments...\n",
    "    \n",
    "    pallindrome = False\n",
    "    if phrase_stripped == phrase_stripped[::-1]:\n",
    "        pallindrome = True\n",
    "\n",
    "    if pallindrome == True:\n",
    "        print(f\"The phrase '{phrase}' is a pallindrome!\")\n",
    "    else:\n",
    "        print(f\"The phrase '{phrase}' is not a pallindrome.\")\n",
    "\n",
    "# Try this famous pallindrome to test: \n",
    "    # A man, a plan, a canal: Panama!\n",
    "# Other fun pallindromes: \n",
    "    # Was it a car or a cat I saw?\n",
    "    # Drab as a fool, aloof as a bard"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "225f36d3-01de-4952-a3e3-7a59a9f58215",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function pallindrome in module __main__:\n",
      "\n",
      "pallindrome(phrase)\n",
      "    Checks whether a string is a pallindrome\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(pallindrome)  # check the docstring"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "aa725a4a-716b-4beb-b3bb-893b5a0740b2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The phrase 'A man, a plan, a canal: Panama!' is a pallindrome!\n"
     ]
    }
   ],
   "source": [
    "pallindrome(\"A man, a plan, a canal: Panama!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "b8676b70-a7cb-4117-96eb-213e218dad54",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The phrase 'Was it a car or a cat I saw?' is a pallindrome!\n"
     ]
    }
   ],
   "source": [
    "pallindrome(\"Was it a car or a cat I saw?\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "2021a8e2-31ae-4b81-9a6b-a8b574a8b9be",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The phrase 'Drab as a fool, aloof as a bard' is a pallindrome!\n"
     ]
    }
   ],
   "source": [
    "pallindrome(\"Drab as a fool, aloof as a bard\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "e9d3c3ec-cc1c-494e-bc8e-b81dd9281b36",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The phrase '1234321' is a pallindrome!\n"
     ]
    }
   ],
   "source": [
    "pallindrome(\"1234321\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99e270e9-a148-45c9-86a1-de5b99d31ba2",
   "metadata": {},
   "source": [
    "## What is a dictionary?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e6e41fe-8e01-4c20-b9ed-99b552345a7a",
   "metadata": {},
   "source": [
    "Shelby note to self: dictionaries store not just data but also the *relationships* between data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc2d4826-abca-4e40-96da-264d8aa0384c",
   "metadata": {},
   "source": [
    "Dictionaries are another type of data that Python recognizes. Dictionaries store \"key-value pairs\" - for example, `{\"first_name\" : \"Shelby\", \"last_name\" : \"Watson\"}`. The \"key\" is the item before the colon; the value(s) are the item(s) that come after. \n",
    "\n",
    "Keys have to be \"immutable\" objects - data types that can't be modified after their creation. This is so that they key values do not shift or change. Strings, numbers, Booleans (True/False) and \"tuples\" (which is similar to a list, but can't be modified after its creation) are immutable data types. Each key can only appear once in a given dictionary; if you include a key more than once, the last occurance will override any previous occurances of that key. \n",
    "\n",
    "Values can be any type of data - strings, numbers, lists, Booleans, other dictionaries... Values can appear more than once in a dictionary, and the same value can be associated with multiple keys. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "a07cf8f4-4d98-4226-b250-decd994685cd",
   "metadata": {},
   "outputs": [],
   "source": [
    "dogs_dict = {\"small\":[\"dauchshund\",\"pomeranian\",\"bichon frise\"],\"large\":[\"cane corso\",\"great dane\",\"saint bernard\"]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "62e07ea0-295e-43a0-9518-915e4b4e6046",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['dauchshund', 'pomeranian', 'bichon frise']"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dogs_dict[\"small\"]  # call upon a key to return its values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "c4de3e9b-f683-4244-a585-85514b641981",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'dauchshund'"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dogs_dict[\"small\"][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "0af16a90-d1d7-4a33-9f0b-ff3f345acd2f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['small', 'large'])"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dogs_dict.keys()  # see all keys for this dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "34b05964-082e-4eb6-be1a-dabf42de54b1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values([['dauchshund', 'pomeranian', 'bichon frise'], ['cane corso', 'great dane', 'saint bernard']])"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dogs_dict.values()  # see all values for this dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "2f08b52f-7b09-4396-a9d2-05378a37975a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# build a dictionary of Scrabble scores\n",
    "points_dict = {1:[\"a\", \"e\", \"i\", \"o\", \"u\", \"l\", \"n\", \"s\", \"t\", \"r\"],\n",
    "               2:[\"d\", \"g\"],\n",
    "               3:[\"b\", \"c\", \"m\", \"p\"],\n",
    "               4:[\"f\", \"h\", \"v\", \"w\", \"y\"],\n",
    "               5:[\"k\"],\n",
    "               8:[\"j\", \"x\"],\n",
    "               10:[\"q\", \"z\"]\n",
    "              }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "eed268b8-1820-438d-bc16-defd56568ac9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['f', 'h', 'v', 'w', 'y']"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "points_dict[4]  # call on a key to return its values - note this is a key, not an index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "0eb1d447-3480-4f5e-9f10-b549dac4887f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys([1, 2, 3, 4, 5, 8, 10])"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "points_dict.keys()  # see all keys for this dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "82d4f04b-2037-4bcc-8712-5583593df14c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values([['a', 'e', 'i', 'o', 'u', 'l', 'n', 's', 't', 'r'], ['d', 'g'], ['b', 'c', 'm', 'p'], ['f', 'h', 'v', 'w', 'y'], ['k'], ['j', 'x'], ['q', 'z']])"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "points_dict.values()  # see all values for this dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ab633eb-e9bb-4ca8-9a1f-37f222e866a4",
   "metadata": {},
   "source": [
    "#### The Scrabble function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "3f5cacea-2456-4315-8ffd-d5681977cd13",
   "metadata": {},
   "outputs": [],
   "source": [
    "def scrabble(word):\n",
    "    \"\"\"Tells you how many points a word is worth in Scrabble\"\"\"\n",
    "    \n",
    "    points_dict = {1:[\"a\", \"e\", \"i\", \"o\", \"u\", \"l\", \"n\", \"s\", \"t\", \"r\"],\n",
    "                   2:[\"d\", \"g\"],\n",
    "                   3:[\"b\", \"c\", \"m\", \"p\"],\n",
    "                   4:[\"f\", \"h\", \"v\", \"w\", \"y\"],\n",
    "                   5:[\"k\"],\n",
    "                   8:[\"j\", \"x\"],\n",
    "                   10:[\"q\", \"z\"]\n",
    "                  }\n",
    "    score = 0\n",
    "\n",
    "    # Note the nested loop (be careful with these)\n",
    "    for letter in word.lower():  # take a single letter from the word\n",
    "        for key in points_dict.keys():  # loop through the list of possible point values (which are our dictionary keys)\n",
    "            if letter in points_dict[key]:  # n.b. these are not index values; these are keys (which just happen to be integers in this case)\n",
    "                score += key\n",
    "                print(f'Letter: {letter}, Current score: {score}')\n",
    "    \n",
    "    print(f\"The Scrabble score for {word} is {score}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "76d3f1cb-8b6a-4016-9f24-65c8d82dc29c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function scrabble in module __main__:\n",
      "\n",
      "scrabble(word)\n",
      "    Tells you how many points a word is worth in Scrabble\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(scrabble)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "ecdd9deb-752c-497b-8cd4-bc3524fd35d6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Letter: q, Current score: 10\n",
      "Letter: u, Current score: 11\n",
      "Letter: i, Current score: 12\n",
      "Letter: x, Current score: 20\n",
      "Letter: o, Current score: 21\n",
      "Letter: t, Current score: 22\n",
      "Letter: i, Current score: 23\n",
      "Letter: c, Current score: 26\n",
      "The Scrabble score for quixotic is 26\n"
     ]
    }
   ],
   "source": [
    "scrabble(\"quixotic\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26c70878-b8f9-4aef-8cfe-d971db7ab960",
   "metadata": {},
   "source": [
    "## Raise Errors (on purpose)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "347c5cc2-f967-4d84-afcf-b9ae4044ec58",
   "metadata": {},
   "source": [
    "We can add in some code that will raise errors for us. This can be useful when we need our arguments to be in the form of a specific type of data, for example. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "cb3f726a-12aa-4e41-931c-5c7c7f6b3a37",
   "metadata": {},
   "outputs": [],
   "source": [
    "def scrabble(word):\n",
    "    \"\"\"Tells you how many points a word is worth in Scrabble\"\"\"\n",
    "    \n",
    "    if type(word) != str:\n",
    "        raise Exception(\"Scrabble function's argument must be a string\")\n",
    "        \n",
    "    elif word.isalpha() != True:\n",
    "        raise Exception(\"Scrabble function's argument must contain only alphabet characters\")\n",
    "    \n",
    "    points_dict = {1:[\"a\", \"e\", \"i\", \"o\", \"u\", \"l\", \"n\", \"s\", \"t\", \"r\"],\n",
    "                    2:[\"d\", \"g\"],\n",
    "                    3:[\"b\", \"c\", \"m\", \"p\"],\n",
    "                    4:[\"f\", \"h\", \"v\", \"w\", \"y\"],\n",
    "                    5:[\"k\"],\n",
    "                    8:[\"j\", \"x\"],\n",
    "                    10:[\"q\", \"z\"]\n",
    "                    }\n",
    "    score = 0\n",
    "    \n",
    "    # Note the nested loop (be careful with these)\n",
    "    for letter in word.lower():  # take a single letter from the word\n",
    "        for key in points_dict.keys():  # loop through the list of possible point values (which are our dictionary keys)\n",
    "            if letter in points_dict[key]:  # n.b. these are not index values; these are keys (which just happen to be integers in this case)\n",
    "                score += key\n",
    "                print(f'Letter: {letter}, Current score: {score}')\n",
    "    \n",
    "    print(f\"The Scrabble score for {word} is {score}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "4df553b3-4618-440a-a67a-132edcc7a797",
   "metadata": {},
   "outputs": [
    {
     "ename": "Exception",
     "evalue": "Scrabble function's argument must contain only alphabet characters",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mException\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[61], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m scrabble(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m10\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
      "Cell \u001b[1;32mIn[58], line 8\u001b[0m, in \u001b[0;36mscrabble\u001b[1;34m(word)\u001b[0m\n\u001b[0;32m      5\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mScrabble function\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124ms argument must be a string\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m      7\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m word\u001b[38;5;241m.\u001b[39misalpha() \u001b[38;5;241m!=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m:\n\u001b[1;32m----> 8\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mScrabble function\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124ms argument must contain only alphabet characters\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m     10\u001b[0m points_dict \u001b[38;5;241m=\u001b[39m {\u001b[38;5;241m1\u001b[39m:[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124ma\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124me\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mi\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mo\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mu\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124ml\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mn\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124ms\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mt\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mr\u001b[39m\u001b[38;5;124m\"\u001b[39m],\n\u001b[0;32m     11\u001b[0m                 \u001b[38;5;241m2\u001b[39m:[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124md\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mg\u001b[39m\u001b[38;5;124m\"\u001b[39m],\n\u001b[0;32m     12\u001b[0m                 \u001b[38;5;241m3\u001b[39m:[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mb\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mc\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mm\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mp\u001b[39m\u001b[38;5;124m\"\u001b[39m],\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m     16\u001b[0m                 \u001b[38;5;241m10\u001b[39m:[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mq\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mz\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n\u001b[0;32m     17\u001b[0m                 }\n\u001b[0;32m     18\u001b[0m score \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0\u001b[39m\n",
      "\u001b[1;31mException\u001b[0m: Scrabble function's argument must contain only alphabet characters"
     ]
    }
   ],
   "source": [
    "scrabble(\"10\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3db2d6b-a1a1-493d-b53f-08cc7dd91f72",
   "metadata": {},
   "source": [
    "**Important**: Note the way that the output of this exception message is structured. `Cell in[61], line 1` points to the `scrabble()` function. `Cell in[58], line 8` lets you peek inside of the `scrabble()` function's code and see exactly where the exception happened. As you get more familiar with coding, being able to look inside of other people's functions and identify errors will get easier for you and can provide you with valuable information as you debug and troubleshoot your own code. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14ff9854-aeb0-4e6c-9940-22eb1a68fda2",
   "metadata": {},
   "source": [
    "#### The roulette function"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fbe0bd60-22e0-401f-b723-8aae714589da",
   "metadata": {},
   "source": [
    "Last week we wrote some code that checked whether the sum of two dice rolls was odd or even. Let's turn that into a custom function called \"roulette()\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "d9faf4a1-d0c6-4b7d-8895-acce34b477a2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# guess is the stand-in name for the argument that will be passed to the function\n",
    "def roulette(guess):\n",
    "    \"\"\"Make a guess ('odd' or 'even') to win or lose\"\"\"  # docstring says what our function does\n",
    "    \n",
    "    import random  # we need functions from the random module, so we have to import it\n",
    "    \n",
    "    guess = guess.lower()  # use .lower() so we can ignore the case of the argument entered\n",
    "    \n",
    "    # cut off the player if they enter something other than \"odd\" or \"even\"\n",
    "    if guess not in ['odd','even']:\n",
    "        raise Exception(\"Please enter a guess (odd or even)\")\n",
    "    \n",
    "    else:  # if guess is \"odd\" or \"even\"\n",
    "        num = random.randint(0, 36)  # roulette boards are 0 (or 00 or 000) to 36\n",
    "        \n",
    "        # two possible win conditions\n",
    "        if (num % 2 == 0 and guess == 'even') or (num % 2 == 1 and guess == 'odd'):\n",
    "            print(f\"You guessed that the number is {guess}. The number is {num}. You won!\")\n",
    "        \n",
    "        # two possible lose conditions\n",
    "        elif (num % 2 == 0 and guess == 'odd') or (num % 2 == 1 and guess == 'even'):\n",
    "            print(f\"You guessed that the number is {guess}. The number is {num}. You lost!\")\n",
    "        \n",
    "        # this message should never be seen, but putting it in anyway \n",
    "        # might help us diagnose unexpected issues with our code\n",
    "        else:\n",
    "            print(\"Something went wrong. Please try again.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "614c79f7-7b0d-4754-8216-33d9d1687fb5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function roulette in module __main__:\n",
      "\n",
      "roulette(guess)\n",
      "    Make a guess ('odd' or 'even') to win or lose\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(roulette)  # shows us the docstring for our function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "96e3624e-34e6-4991-b9b2-88803d83db1d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You guessed that the number is odd. The number is 34. You lost!\n"
     ]
    }
   ],
   "source": [
    "roulette('odd')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a72203c0-c0db-4959-8cf4-38ad310b7787",
   "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.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}