Lecture_11.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lecture 11\n",
    "\n",
    "### Learning objectives\n",
    "\n",
    "- Learn about Python's `lambda` functions.\n",
    "- Explore the joys of \"List, Dictionary & Set comprehension\".\n",
    "- Learn about how to handle errors (exceptions) in Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 11.1 Lambda functions\n",
    "\n",
    "You can spell any Greek letter and use it as a variable name EXCEPT for `lambda`. As we learned in Lecture 2, `lambda` is a _reserved word_. Why?  Because `lambda` has a special meaning in Python; it is reserved for **anonymous functions**.\n",
    "\n",
    "The syntax of a `lambda` function consists of  a `name =`, followed by the word `lambda` followed by an argument list, a colon (`:`), and ending with  an **expression**.  Here is a simple example of an anonymous function that returns the product of the argument list: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = lambda x, y : x*y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's dissect the statement. \n",
    "- `f` is a new kind of  object that represents the function,\n",
    "- `x` and `y` are the arguments of the anonymous function, \n",
    "- and the expression `x*y` is what is returned when the function is called. \n",
    "\n",
    "We're familiar with the following syntax for a \"normal\" function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def g(x, y):\n",
    "    return x*y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Both `f` and `g` take the same arguments and return the same value. They are essentially the same function.  \n",
    "\n",
    "Let us verify this, by calling both functions with the arguments `x = 2` and `y = 10`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n",
      "20\n"
     ]
    }
   ],
   "source": [
    "print(f(2, 10))\n",
    "print(g(2, 10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Yup.  Both the `lambda` function `f` and the \"regular\" Python function `g` defined with the keyword `def` are of the type: `function`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'function'>\n",
      "<class 'function'>\n"
     ]
    }
   ],
   "source": [
    "print(type(f))\n",
    "print(type(g))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`lambda` functions should seem familiar. They follow the same syntax you use in math to define functions:\n",
    "$$\n",
    "f(x) = x^2 +5x + 9 \n",
    "$$\n",
    "So we could easily write this as a `lambda` function like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "h = lambda x: x**2 + 5.0*x + 9"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "For a multivariate function (one with more than one argument), you need to list all the arguments after the reserved word `lambda`. For example, \n",
    "In math, you’d write the equation for the hypotenus of two sides, $a$ and $b$, as: \n",
    "$$\n",
    "\\text{hypotenuse}(a, b) = \\sqrt{a^2+ b^2}.\n",
    "$$\n",
    "In Python it would be:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hypotenus = lambda a, b: np.sqrt(a**2 + b**2)\n",
    "print\n",
    "(hypotenus(3, 4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 11.2 Uses of `lamda` functions\n",
    "\n",
    "You may be wondering why `lambda` functions are useful. The answer is that `lambda` functions are anonymous - you don't have to give them a name (although we did when we assigned the function to $f$ in the above examples). This comes in handy if you 1) write or use functions that take in other functions as arguments or 2) you just want a quickie one-off calculation.   \n",
    "\n",
    "Anticipating your further questions, you can look at this useful blog post on the subject:  https://stackoverflow.com/questions/890128/why-are-python-lambdas-useful"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 11.3 List comprehensions\n",
    "\n",
    "One way to iterate over sequences and apply different operations, is through List, Dictionary, and Set comprehensions.\n",
    "\n",
    "A List comprehension is a convenient way of applying an operation to a collection of objects. It takes this basic form:\n",
    "\n",
    "```python\n",
    "[expression for element in collection if condition]\n",
    "```\n",
    "\n",
    "Here is an example that takes a list of strings, looks for those with lengths greater than 5 and returns the upper case version using the `string.upper()` method for strings: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['MT. EVEREST', 'MAUNA LOA', 'SP MOUNTAIN']"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mtList = ['Andes', 'Mt. Everest', 'Mauna Loa', 'SP Mountain']\n",
    "[s.upper() for s in mtList if len(s) > 5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Fun fact: you can get the lower case equivalents with the method `string.lower()`.]\n",
    "\n",
    "Note that you could achieve the same result (the upper case list of all volcanoes with names having more than 5 characters) using our old friend the `for` loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['MT. EVEREST', 'MAUNA LOA', 'SP MOUNTAIN']"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "another_list = []\n",
    "for s in mtList:\n",
    "    if len(s) > 5:\n",
    "        another_list.append(s.upper())\n",
    "another_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 11.4 Dictionary comprehension\n",
    "Dictionary comprehensions are similar to list comprehensions, but they generate key-value pairs instead of lists. Dictionary comprehensions follow the format:\n",
    "\n",
    "```python\n",
    "{key:value for variable in collection if condition}\n",
    "```\n",
    "\n",
    "The following Dictionary comprehension generates a dictionary with a word from `mtList` as the key and the length of the word as the value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Andes': 5, 'Mt. Everest': 11, 'Mauna Loa': 9, 'SP Mountain': 11}"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mtList = ['Andes', 'Mt. Everest', 'Mauna Loa', 'SP Mountain'] # To remind you what mylist was\n",
    "{s:len(s) for s in mtList} # dictionary comprehension with mylist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice the `{key:value, key:value}` structure of the output  is a dictionary.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 11.5 Set comprehension\n",
    "\n",
    "A Set comprehension, returns a set and follows this format:\n",
    "\n",
    "```python\n",
    "{expression for value in collection if condition}\n",
    "```\n",
    "\n",
    "The following Set comprehension creates a set composed of the lengths of the words in `mylist`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{5, 9, 11}"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{len(s) for s in mtList}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can tell that a `set` was returned because it is in curly braces with no keys. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 11.6 Complicated comprehensions\n",
    "List, Dictionary, and Set comprehensions can also replace complicated, nested loops. Here's an example that generates a list of x,y,z triplets if the values obey Pythagorus' rules for right triangles.  Chew on it, until you get it: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(3, 4, 5),\n",
       " (5, 12, 13),\n",
       " (6, 8, 10),\n",
       " (7, 24, 25),\n",
       " (8, 15, 17),\n",
       " (9, 12, 15),\n",
       " (10, 24, 26),\n",
       " (12, 16, 20),\n",
       " (15, 20, 25),\n",
       " (20, 21, 29)]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[(x, y, z) for x in range(1, 30) \\\n",
    "    for y in range(x, 30) for z in range(y, 30) \\\n",
    "    if x**2 + y**2 == z**2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 11.7 Exceptions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It frequently occurs that functions (or methods) require assumptions be placed upon their input arguments. For example, one may require that the arguments are of a specific Python type, or that the argument value is within a specific range. For example, consider a function which will compute $a + b$, but we additionally assumption that this operation is only valid if $a \\ge b$. If the function recieves input such that $a < b$, would like an error to occur. Our first attempt is shown below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def constrained_add(a, b):\n",
    "    if a < b:\n",
    "        print('Error: constrained_add() requires a >= b')\n",
    "        return 0\n",
    "    return a + b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above function does the job, however it has some limitations.\n",
    "1. It required we \"hard code\" the name of the function in the message printed to the screen.\n",
    "2. It returned a value, we didn't know what else to return so we picked `0`.\n",
    "3. Since we defined that the result is invalid if $a < b$, we would / might actually like our Python script to stop executing if an invalid statement occurs. In the above example, Python keeps running."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python, the error above $a < b$ is referred to as **exception**. Exceptions are defined as conditions which are undesirable or \"illegal\", but not necessarily fatal. Python provides a special class named `Exception` for dealing with errors. We will use this class together with the reserved keyword `raise` in our `constrained_add()` as follows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def constrained_add(a, b):\n",
    "    if a < b:\n",
    "        raise Exception('Using a < b is invalid')\n",
    "    return a + b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The keyword `raise` signals to the Python interpreter that the execution should be stopped. Let's try it out:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "ename": "Exception",
     "evalue": "Using a < b is invalid",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mException\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-15-d4ba149d6a27>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mres\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mconstrained_add\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Result of a + b:'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mres\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-14-7a8e20d13b15>\u001b[0m in \u001b[0;36mconstrained_add\u001b[0;34m(a, b)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mconstrained_add\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m         \u001b[0;32mraise\u001b[0m \u001b[0mException\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Using a < b is invalid'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mException\u001b[0m: Using a < b is invalid"
     ]
    }
   ],
   "source": [
    "a = 1\n",
    "b = 2\n",
    "res = constrained_add(a, b)\n",
    "print('Result of a + b:', res)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, several new things happen. We get a nice message reporting that illegal behavior was detected, and we can clearly see which function produced this message. We also see the execution has halted, as should be clear as the result of $a + b$ is not displayed to the screen. \n",
    "\n",
    "Many predefined (built-in) variants of the `Exception` class are provided as part of the Python language (a link to these is provided in the section References below). Using built-in exceptions helps us be more specific about the type of exception which occured. The standard exception relevant for our case would be `ValueError`, since our invalid case arises from an input argument value. Hence we change our function as follows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def constrained_add(a, b):\n",
    "    if a < b:\n",
    "        raise ValueError('Using a < b is invalid') # Use an appropriate default exception\n",
    "    return a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "Using a < b is invalid",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-17-d4ba149d6a27>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mres\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mconstrained_add\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Result of a + b:'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mres\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-16-b0a4a5a539de>\u001b[0m in \u001b[0;36mconstrained_add\u001b[0;34m(a, b)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mconstrained_add\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m         \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Using a < b is invalid'\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Use an appropriate default exception\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m: Using a < b is invalid"
     ]
    }
   ],
   "source": [
    "a = 1\n",
    "b = 2\n",
    "res = constrained_add(a, b)\n",
    "print('Result of a + b:', res)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This looks nicer since we get a little more information returned to us about the type of error (i.e. it's not reporting `ValueError`). Using appropriate exceptions for specific use cases provides a more expressive and detailed report of what went wrong."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Suppose we do not necessarily want the execution to be stopped, but instead would like to take other action if an exception is raised. Python provides a mechanism to control this behavior via the so called try/except structure, which looks like\n",
    "```python\n",
    "try:\n",
    "    # CODE BLOCK 1\n",
    "except:\n",
    "    # CODE BLOCK 2\n",
    "finally:\n",
    "    # CODE BLOCK 3\n",
    "```\n",
    "The try/except feature is referred to as **exception handling**. The basic usage of this structures is that (i) code that can cause an exception to occur should be located in the `try` block and (ii) the handling / mangement of what to do in the event of an exception is included within the `except` block. The code in the `except` block will only be executed if the `try` block produces an exception. The `finally` block is executed last, and importantly it always gets executed independent of any exceptions. Note the `finally` block is not required, i.e. this is also perfectly valid:\n",
    "```python\n",
    "try:\n",
    "    # CODE BLOCK 1\n",
    "except:\n",
    "    # CODE BLOCK 2\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In summary: \n",
    "* The `try` block lets you test a block of code for errors.\n",
    "* The `except` block lets you handle the error.\n",
    "* The `finally` block lets you execute code, regardless of the result of the try- and except blocks.\n",
    "\n",
    "Whether we use the `finally` statement is dependent of the specifics of the error being handled. Often `finally` is used to \"clean up\" data structures / objects which might need special attention when something \"bad\" happended. A typical example would be closing a file.\n",
    "We now apply the try/except structure when calling our `constrained_add()` function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[personal message] An exception occurred in constrained_add().\n",
      "[last words] This text always gets displayed.\n",
      "Phew!, Made it past the try-except block\n"
     ]
    }
   ],
   "source": [
    "a = 1\n",
    "b = 2\n",
    "try:\n",
    "    res = constrained_add(a, b)\n",
    "    print('res[try]', res) # This line will NOT get executed if an exception occurred.\n",
    "except:\n",
    "    print('[personal message] An exception occurred in constrained_add().')\n",
    "    #raise  # Include raise if you want the execution to be halted.\n",
    "finally:\n",
    "    print('[last words] This text always gets displayed.')\n",
    "    \n",
    "print('Phew!, Made it past the try-except block') # Only displayed when no exceptions occur."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Experiment (play around) with the code structure above and familarize yourself with how it works. Exception handling in Python is very powerful and incredibly useful when you start writing complicated code as things (code) do not always go as planned (i.e. code misbehaves in unexpected ways)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## References\n",
    "1. Default Python exceptions are listed here: https://docs.python.org/3/library/exceptions.html."
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}