PreFall2018/07-Exceptions.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# When Things Go Wrong:\n",
    "## Exceptions and Errors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Today we'll cover perhaps one of the most important aspects of using Python: dealing with errors and bugs in code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Three Classes of Errors\n",
    "\n",
    "Types of bugs/errors in code, from the easiest to the most difficult to diagnose:\n",
    "\n",
    "1. **Syntax Errors:** Errors where the code is not valid Python (generally easy to fix)\n",
    "2. **Runtime Errors:** Errors where syntactically valid code fails to execute (sometimes easy to fix)\n",
    "3. **Semantic Errors:** Errors in logic (often very difficult to fix)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Syntax Errors\n",
    "\n",
    "Syntax errors are when you write code which is not valid Python.  For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-3-dbcc3d32bbf7>, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-3-dbcc3d32bbf7>\"\u001b[0;36m, line \u001b[0;32m2\u001b[0m\n\u001b[0;31m    a = 4\u001b[0m\n\u001b[0m    ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "X = [1, 2, 3\n",
    "a = 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = 4*x + 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f():\n",
    "    return GARBAGE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No error is generated by defining this function. The error doesn't occur until the function is called."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'GARBAGE' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m-------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                               Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-5-c43e34e6d405>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-4-309043ae9eb7>\u001b[0m in \u001b[0;36mf\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mf\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[0;32m----> 2\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mGARBAGE\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'GARBAGE' is not defined"
     ]
    }
   ],
   "source": [
    "f()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that if your code contains even a *single* syntax error, none of it will run:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 4\n",
    "something == is wrong"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Even though the syntax error appears below the (valid) variable definition, the valid code is not executed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Runtime Errors\n",
    "Runtime errors occur when the code is **valid python code**, but are errors within the context of the program execution.  For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(Q)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "invalid literal for int() with base 10: 'aaa'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m-------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                              Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-6-4e46bd5be9f3>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;31m# blah blah blah\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      5\u001b[0m \u001b[0mprint\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m: invalid literal for int() with base 10: 'aaa'"
     ]
    }
   ],
   "source": [
    "a = 'aaa'\n",
    "\n",
    "# blah blah blah\n",
    "x = 1 + int(a)\n",
    "print (x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "ename": "ZeroDivisionError",
     "evalue": "division by zero",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m-------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mZeroDivisionError\u001b[0m                       Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-7-3bbf9829bc52>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mX\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mZeroDivisionError\u001b[0m: division by zero"
     ]
    }
   ],
   "source": [
    "X = 1 / 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "np.sum([1, 2, 3, 4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.sum?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [1, 2, 3]\n",
    "print(x[100])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unlike Syntax errors, RunTime errors occur **during code execution**, which means that valid code occuring before the runtime error *will* execute:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "spam = \"my all-time favorite\"\n",
    "eggs = 1 / 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(spam)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Semantic Errors\n",
    "Semantic errors are perhaps the most insidious errors, and are by far the ones that will take most of your time.  Semantic errors occur when the code is **syntactically correct**, but produces the wrong result.\n",
    "\n",
    "By way of example, imagine you want to write a simple script to approximate the value of $\\pi$ according to the following formula:\n",
    "\n",
    "$$\n",
    "\\pi = \\sqrt{12} \\sum_{k = 0}^{\\infty} \\frac{(-3)^{-k}}{2k + 1}\n",
    "$$\n",
    "\n",
    "You might write a function something like this, using numpy's vectorized syntax:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "total = 0\n",
    "for k in ks:\n",
    "    total += (-3.0) ** -k / (2 * k + 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-3.9508736907744493"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from math import sqrt\n",
    "\n",
    "def approx_pi(nterms=100):\n",
    "    ks = np.arange(nterms)\n",
    "    ans = sqrt(12) * np.sum([-3.0 ** -k / (2 * k + 1) for k in ks])\n",
    "    if ans < 1:\n",
    "        import pdb; pdb.set_trace()\n",
    "    return ans\n",
    "approx_pi(1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Looks OK, yes?  Let's try it out:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "approx_pi(1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Huh. That doesn't look like $\\pi$.  Maybe we need more terms?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "k = 2\n",
    "(-3.0) ** -k / (2 * k + 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "approx_pi(1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nope... it looks like the algorithm simply gives the wrong result.  This is a classic example of a semantic error.\n",
    "\n",
    "**Question: can you spot the problem?**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Runtime Errors and Exception Handling\n",
    "Now we'll talk about how to handle RunTime errors (we skip Syntax Errors because they're pretty self-explanatory).\n",
    "\n",
    "Runtime errors can be handled through \"exception catching\" using ``try...except`` statements.  Here's a basic example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this block gets executed first\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'GARBAGE' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m-------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                               Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-24-5d2b8d11a118>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"this block gets executed first\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m     \u001b[0mGARBAGE\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mValueError\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mRuntimeError\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0merr\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"this block gets executed if there's an error\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'GARBAGE' is not defined"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    print(\"this block gets executed first\")\n",
    "    GARBAGE\n",
    "except (ValueError, RuntimeError) as err:\n",
    "    print(\"this block gets executed if there's an error\")\n",
    "    print (err)\n",
    "print (\"I am done!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(x):\n",
    "    if isinstance(x, int) or isinstance(x, float):\n",
    "        return 1.0/x\n",
    "    else:\n",
    "        raise ValueError(\"argument must be an int.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(x):\n",
    "    try:\n",
    "        return 1.0/x\n",
    "    except (TypeError, ZeroDivisionError):\n",
    "        raise ValueError(\"Argument must be a non-zero number.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f('aa')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    print(\"this block gets executed first\")\n",
    "    x = 1 / 0  # ZeroDivisionError\n",
    "    print(\"we never get here\")\n",
    "except:\n",
    "    print(\"this block gets executed if there's an error\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that the first block executes **up until the point** of the Runtime error.\n",
    "Once the error is hit, the ``except`` block is executed.\n",
    "\n",
    "One important note: the above clause catches **any and all** exceptions.  It is not\n",
    "generally a good idea to catch-all.  Better is to name the precise exception you expect:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.0\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "def safe_divide(a, b):\n",
    "    try:\n",
    "        return a / b\n",
    "    except:\n",
    "        # print(\"oops, dividing by zero. Returning None.\")\n",
    "        return None\n",
    "    \n",
    "print(safe_divide(15, 3))\n",
    "print(safe_divide(1, 0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But there's a problem here: this is a **catch-all** exception, and will sometimes give us misleading information.  For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "safe_divide(15, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our program tells us we're dividing by zero, but we aren't!  This is one reason you should **almost never** use a catch-all ``try..except`` statement, but instead specify the errors you're trying to catch:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def better_safe_divide(a, b):\n",
    "    try:\n",
    "        return a / b\n",
    "    except ZeroDivisionError:\n",
    "        print(\"oops, dividing by zero. Returning None.\")\n",
    "        return None\n",
    "    \n",
    "better_safe_divide(15, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "better_safe_divide(15, 'three')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This also allows you to specify different behaviors for different exceptions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def even_better_safe_divide(a, b):\n",
    "    try:\n",
    "        return a / b\n",
    "    except ZeroDivisionError:\n",
    "        print(\"oops, dividing by zero. Returning None.\")\n",
    "        return None\n",
    "    except TypeError:\n",
    "        print(\"incompatible types.  Returning None\")\n",
    "        return None\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "even_better_safe_divide(15, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "even_better_safe_divide(15, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "even_better_safe_divide(15, 'three')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember this lesson, and **always specify your except statements!**  I once spent an entire day tracing down a bug in my code which amounted to this."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Raising Your Own Exceptions\n",
    "\n",
    "When you write your own code, it's good practice to use the ``raise`` keyword to create your own exceptions\n",
    "when the situation calls for it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os  # the \"os\" module has useful operating system stuff\n",
    "\n",
    "def read_file(filename):\n",
    "    if not os.path.exists(filename):\n",
    "        raise ValueError(\"'{0}' does not exist\".format(filename))\n",
    "    f = open(filename)\n",
    "    result = f.read()\n",
    "    f.close()\n",
    "    return result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll use IPython's ``%%file`` magic to quickly create a text file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%file tmp.txt\n",
    "this is the contents of the file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "read_file('tmp.txt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "read_file('file.which.does.not.exist')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is sometimes useful to define your own custom exceptions, which you can do easily via class inheritance:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NonExistentFile(RuntimeError):\n",
    "    # you can customize exception behavior by defining class methods.\n",
    "    # we won't discuss that here.\n",
    "    pass\n",
    "\n",
    "\n",
    "def read_file(filename):\n",
    "    if not os.path.exists(filename):\n",
    "        raise NonExistentFile(filename)\n",
    "    f = open(filename)\n",
    "    result = f.read()\n",
    "    f.close()\n",
    "    return result4o-"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "read_file('tmp.txt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "read_file('file.which.does.not.exist')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Get used to throwing appropriate &mdash; and meaningful &mdash; exceptions in your code!** It makes reading and debugging your code much, much easier."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### More Advanced Exception Handling\n",
    "\n",
    "There is also the possibility of adding ``else`` and ``finally`` clauses to your try statements.\n",
    "You'll probably not need these often, but in case you encounter them some time, it's good to know what they do.\n",
    "\n",
    "The behavior looks like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    print(\"doing something\")\n",
    "except:\n",
    "    print(\"this only happens if it fails\")\n",
    "else:\n",
    "    print(\"this only happens if it succeeds\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    print(\"doing something\")\n",
    "    raise ValueError()\n",
    "except:\n",
    "    print(\"this only happens if it fails\")\n",
    "else:\n",
    "    print(\"this only happens if it succeeds\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Why would you ever want to do this?\n",
    "Mainly, it prevents the code within the ``else`` block from being caught by the ``try`` block.\n",
    "Accidentally catching an exception you don't mean to catch can lead to confusing results."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The last statement you might use is the ``finally`` statement, which looks like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    print(\"do something\")\n",
    "except:\n",
    "    print(\"this only happens if it fails\")\n",
    "else:\n",
    "    print(\"this only happens if it succeeds\")\n",
    "finally:\n",
    "    print(\"this happens no matter what.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    print(\"do something\")\n",
    "    raise ValueError()\n",
    "except:\n",
    "    print(\"this only happens if it fails\")\n",
    "else:\n",
    "    print(\"this only happens if it succeeds\")\n",
    "finally:\n",
    "    print(\"this happens no matter what.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "``finally`` is generally used for some sort of cleanup (closing a file, etc.)  It might seem a bit redundant, though.  Why not write the following?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    print(\"do something\")\n",
    "except:\n",
    "    print(\"this only happens if it fails\")\n",
    "else:\n",
    "    print(\"this only happens if it succeeds\")\n",
    "print(\"this happens no matter what.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write exception code that handles all exceptions except ZeroDivideError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "    x = 0\n",
    "    excpt = None\n",
    "    try:\n",
    "        1.0/x\n",
    "    except Exception as err:\n",
    "        if isinstance(err, ZeroDivisionError):\n",
    "            pass\n",
    "        else:\n",
    "            raise Exception(\"Got error.\")\n",
    "        \n",
    "        \n",
    "        \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(excpt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The main difference is when the clause is used within a function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def divide(x, y):\n",
    "    try:\n",
    "       result = x / y\n",
    "    except ZeroDivisionError:\n",
    "        print(\"division by zero!\")\n",
    "        return None\n",
    "    else:\n",
    "        print(\"result is\", result)\n",
    "        return result\n",
    "    finally:\n",
    "        print(\"some sort of cleanup\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "divide(15, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "divide(15, 0)"
   ]
  }
 ],
 "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}