Merge pull request #12 from Warwick-xSoc/w6-except-theres-excpetions

Adds a section at the start of Week 6 on recursion.

Author: Levelent

week6/w6.ipynb

@@ -18,6 +18,190 @@
     "---"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Expect Everything\n",
+    "Throughout the course, you may have run into an error message or two (or three or...). In Python, we typically refer to these as **Exceptions**.\n",
+    "\n",
+    "It would be really inconvenient if all programs, ever, crashed the first time they ran into a problem. Luckily, we can write code to deal with these exceptions, should they arise - this is **Exception Handling**. For example, look at this short script that takes an input, converts it to an `int` and doubles it:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "num = int(input(\"Enter a number: \"))\n",
+    "num *= 2\n",
+    "print(num)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Seems fine? But what if the user decides they *don't* want to enter a number, what if, e.g., they enter \"Hello\"? Python doesn't know how to convert a string to an integer, so it will throw a **ValueError** and exit the program.\n",
+    "\n",
+    "In reality, entering the wrong type of data isn't the end of the world. To stop Python from exiting immeadiately, we can surround any potentially problem-causing code in a `try-expect` block like this:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "try:\n",
+    "    num = int(input(\"Enter a number\"))\n",
+    "    num *= 2\n",
+    "    print(num)\n",
+    "except ValueError:\n",
+    "    print(\"uh oh - that wasn't a number\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The `try` statement tells the Python interpreter that something could go wrong in the following statements, but we know and have ways to deal with it. \n",
+    "\n",
+    "Note: we need `num *= 2` and `print(num)` in the `try` block because if the user inputs something wrong, `num` won't be defined. If the statements were *after* the try statement, this could cause an error as `num` wouldn't be defined.\n",
+    "\n",
+    "We can also catch multiple types of exceptions!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "try:\n",
+    "    num = int(input(\"Enter a number\"))\n",
+    "    result = 2 / num\n",
+    "    print(result)\n",
+    "except ValueError:\n",
+    "    print(\"uh oh - that wasn't a number\")\n",
+    "except ZeroDivisionError:\n",
+    "    print(\"Friends don't let friends divide by zero\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "All exceptions are a type of class, all inheriting from the **Exception** class. Also, certain exceptions are also subclasses of other exceptions, e.g. `ZeroDivisionError` is a subclass of `ArithmeticError`, here's a full hierarchy: \n",
+    "\n",
+    "***Image of Exception hierarchy goes here***"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "So what if we were to do this:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "try:\n",
+    "    num = int(input(\"Enter a number\"))\n",
+    "    result = 2 / num\n",
+    "    print(result)\n",
+    "except Exception:\n",
+    "    print(\"Something went wrong :(\")\n",
+    "except ValueError:\n",
+    "    print(\"uh oh - that wasn't a number\")\n",
+    "except ZeroDivisionError:\n",
+    "    print(\"Friends don't let friends divide by zero\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Try running the above block and input a string. Now input 0. We've caused two different errors, but the same statement is being executed. Why?\n",
+    "\n",
+    "Since all exceptions are a subclass of **Exception**, Python considers them to be of type *Exception*. Why does this matter? Python executes the *first relevant* catch statement - in this case it will *always* be an Exception, so the first statement will execute *regardless* of what type of exception we're throwing. You need to make sure that you put any catch statements for subclasses *above* those of their parent classes, otherwise the subclasses will never execute:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "try:\n",
+    "    num = int(input(\"Enter a number\"))\n",
+    "    result = 2 / num\n",
+    "    print(result)\n",
+    "except ValueError:\n",
+    "    print(\"uh oh - that wasn't a number\")\n",
+    "except ZeroDivisionError:\n",
+    "    print(\"Friends don't let friends divide by zero\")\n",
+    "except Exception:\n",
+    "    print(\"Something went wrong :(\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Sometimes we may not want to continue the program if we encounter an error, if we want to throw an exception, we use the `raise` keyword. For example:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def division(num1: int, num2: int) -> float:\n",
+    "    if (num2 == 0):\n",
+    "        raise ZeroDivisionError(\"We've been through this - you can't divide by zero\")\n",
+    "    else:\n",
+    "        return num1 / num2\n",
+    "\n",
+    "inp_1 = input(\"Enter first number: \")\n",
+    "inp_2 = input(\"Enter second number: \")\n",
+    "try:\n",
+    "    inp_1 = int(inp_1)\n",
+    "    inp_2 = int(inp_2)\n",
+    "except ValueError:\n",
+    "    print(\"uh oh - one of those numbers wasn't a number\")\n",
+    "\n",
+    "print(division(inp_1, inp_2))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can also write our own custom exceptions. We define them the same way we define a class, making sure to say it inherits from **Exception**. Then, we can call it anywhere in our code by using `raise`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class MyException(Exception):\n",
+    "    def __init__(self, msg):\n",
+    "        super().__init__(msg)\n",
+    "\n",
+    "thing = input(\"Enter your favourite society: \")\n",
+    "if thing != \"UWCS\":\n",
+    "    raise MyException(\"Ding dong, your opinion is wrong\")"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -1005,7 +1189,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3.10.4 64-bit",
+   "display_name": "Python 3.10.8 64-bit",
    "language": "python",
    "name": "python3"
   },
@@ -1019,12 +1203,12 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.7"
+   "version": "3.10.8"
   },
   "orig_nbformat": 4,
   "vscode": {
    "interpreter": {
-    "hash": "268a003517095b3e00ec49a0832a87899bac50083c754616205934d33472dfcd"
+    "hash": "bb33f6d328f18c07440802b8c66874c52744b86bff5cfe8eb1d71afeb55a2150"
    }
   }
  },