Functions_Handlind_Errors_Data_Structures.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# MSDS 430 Module 8 Python Assignment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\"> In this assignment you will complete the following exercises and submit your <b>notebook</b> and <b>html file</b> to Canvas. Your files should include all output, i.e. run each cell and save your file before submitting.</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\"> In this exercise we will focus on Errors and how to handle them. In programming, there are three main types of errors:\n",
    "<li> <b>Syntax errors</b>: In these the code is not valid Python (usually easy to fix) </li>\n",
    "<li> <b>Runtime errors</b>: The syntax is valid but there is an error during execution (sometimes easy to fix)</li>\n",
    "<li> <b>Logic errors</b>: The code executes without a problem, but the result is not what you expect (usually these are difficult to troubleshoot and fix)</li>\n",
    "\n",
    "<br></brSee>See https://docs.python.org/3.7/library/exceptions.html\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Syntax Errors\n",
    "\n",
    "In Python, like other programming languages, if you don't follow the correct syntax, such as not having matched parentheses, brackets, or quotations marks, your code will generate a `SyntaxError`. \n",
    "\n",
    "**Example 1**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-1-2cca51e943d5>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-1-2cca51e943d5>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    def multiply(a,b)\u001b[0m\n\u001b[0m                     ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "def multiply(a,b)\n",
    "    return (a*b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**How to read the error message**\n",
    "\n",
    "In the above cell, the error message comprises of the exception and the traceback. The first part is the traceback.\n",
    "\n",
    "<b><font color=\"seagreen\">File \"&lt;ipython-input-5-9378ff5a2104&gt;\" </font></b>\n",
    "\n",
    "The \"file\" is what the compiler was processing when the error occurred. In a Jupyter notebook where we aren't referencing any functions from external files, this part of the message is not providing any additional information to us.\n",
    "\n",
    "This is followed by the line number where the error occurred\n",
    "\n",
    "<b><font color=\"green\">, line 1</font></b>\n",
    "\n",
    "and that the parsing problem occurred at\n",
    "\n",
    "<b><font color=\"#b38220\">def multiply(a, b)</font></b>\n",
    "\n",
    "**Note: This information isn't always accurate.** Depending upon the type of error and the complexity of the line of code, the actual error could be above or below where it points out that the error is occurring.\n",
    "\n",
    "The second part is the exception.\n",
    "\n",
    "<b><font color=\"red\">SyntaxError:</font></b> invalid syntax\n",
    "\n",
    "It gives us an idea of the reason for the error. In this example, we have a SyntaxError because Python reached the end of line but didn't find the `:` that it was expecting as part of the function declaration.\n",
    "\n",
    "One other type of syntax error that can occur in Python is an Indentation Error as shown in example below. \n",
    "\n",
    "**Example 2**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "expected an indented block (<ipython-input-2-9b9cea9235f5>, line 5)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-2-9b9cea9235f5>\"\u001b[0;36m, line \u001b[0;32m5\u001b[0m\n\u001b[0;31m    return False\u001b[0m\n\u001b[0m    ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m expected an indented block\n"
     ]
    }
   ],
   "source": [
    "def is_even(x):\n",
    "    if x % 2 == 0:\n",
    "        return True\n",
    "    else:\n",
    "    return False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The fifth line in the code snippet - <b><font color=\"green\">return False</font></b> - should be aligned vertically with the beginning of the third line - <b><font color=\"green\">return True</font></b>\n",
    "\n",
    "**Example 3**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "Missing parentheses in call to 'print'. Did you mean print(\"Print function syntax changed in Python 3\")? (<ipython-input-3-a6f54104e66a>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-3-a6f54104e66a>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    print \"Print function syntax changed in Python 3\"\u001b[0m\n\u001b[0m          ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m Missing parentheses in call to 'print'. Did you mean print(\"Print function syntax changed in Python 3\")?\n"
     ]
    }
   ],
   "source": [
    "print \"Print function syntax changed in Python 3\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The print function format has changed from Python 2.x to Python 3.x. In the newer version a pair of parentheses is expected around the parameters to be printed.\n",
    "\n",
    "**Example 4**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "EOL while scanning string literal (<ipython-input-4-c2b9f48bc53d>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-4-c2b9f48bc53d>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    msg = 'Have you forgotten something\u001b[0m\n\u001b[0m                                       ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m EOL while scanning string literal\n"
     ]
    }
   ],
   "source": [
    "msg = 'Have you forgotten something\n",
    "print(msg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, the error message tells us what issue generated the error. A `SyntaxError` is displayed because Python reached the end of the line (EOL) while it was scanning the string we started with ' and it couldn't find the closing '."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Runtime Errors\n",
    "\n",
    "In the case of RunTime Errors, the syntax is valid but there is an error during execution. There are a couple of different flavors of these errors - Name, Type, Index, Value, and Attribute errors to name a few "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**NameError**\n",
    "\n",
    "When Python attempts to reference an object that hasn't been defined yet, the NameError will be flagged."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'whaaat' 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-e6b0fdbd8fec>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwhaaat\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'whaaat' is not defined"
     ]
    }
   ],
   "source": [
    "print(whaaat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**TypeError**\n",
    "\n",
    "This happens when we try to use a method that is for one data type on another data type that does not support it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'int' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-6-8df531ca1646>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;36m5\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m'xyz'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'"
     ]
    }
   ],
   "source": [
    "5 + 'xyz'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**IndexError**\n",
    "\n",
    "In objects such as strings, arrays etc. elements within it can be accessed using an index. The index ranges from 0 to the length of the object minus one. If we try to access an element with an index value that is outside the valid (0 to length-1)  then the Python interpreter returns an `IndexError`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    },
    {
     "ename": "IndexError",
     "evalue": "index 10 is out of bounds for axis 0 with size 4",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-12-af98229a435e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0marr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m4\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      3\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m \u001b[0marr\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\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----> 4\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m \u001b[0marr\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m10\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[0m",
      "\u001b[0;31mIndexError\u001b[0m: index 10 is out of bounds for axis 0 with size 4"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.array([1,2,3,4])\n",
    "print( arr[2] ) \n",
    "print( arr[10] ) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**AttributeError**\n",
    "\n",
    "Often Python objects have attributes that can be easily retrieved using the name of the attribute. When you try to use the `variable.attribute` and the attribute isn't valid then an error message is flagged.\n",
    "\n",
    "\n",
    "For example, the list object has an attribute `append` for adding elements to a list. However, the `string` object doesn't have an `append` attribute. You have to use the `+` sign for string concatenation. The use of `append` will flag an `AttributeError` in this case."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'str' object has no attribute 'append'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-13-645800787fa7>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mmsg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"Hi\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mmsg\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Not Allowed\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: 'str' object has no attribute 'append'"
     ]
    }
   ],
   "source": [
    "msg = \"Hi\"\n",
    "msg.append(\"Not Allowed\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\"><b>Problem 1 (6 pts.)</b>: Fix the syntax errors in the code block below to return the quotient and display a message indicating whether the quotient is one, two  or three digits.</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Three digits or more!\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "250"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# TODO: Fix the SYNTAXERROR in the function declaration\n",
    "def divide(x, y):\n",
    "    quotient = int(x/y)\n",
    "    threeOrMoreDigits = False\n",
    "\n",
    "    if (quotient < 10):\n",
    "        print(\"Single digit!\")\n",
    "    elif ((quotient >= 10) & (quotient < 100)):\n",
    "        print(\"Double Digits!\")\n",
    "    # TODO: fix the SYNTAXERROR\n",
    "    else:\n",
    "        threeOrMoreDigits = True\n",
    "\n",
    "    # TODO: fix the SYNTAXERROR \n",
    "    if threeOrMoreDigits:\n",
    "        print(\"Three digits or more!\")\n",
    "\n",
    "    return (int(x/y)) \n",
    "\n",
    "divide(1000,4) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The examples listed so far highlight some of the errors that are most frequently encountered when programming in Python. For the complete list of exceptions and errors you can refer to the official Python documentation.\n",
    "\n",
    "Python Built-in Exceptions docs: https://docs.python.org/3.7/library/exceptions.html\n",
    "\n",
    "Python Error Handling docs: https://docs.python.org/3.7/tutorial/errors.html\n",
    "\n",
    "Note: **It's important to read through the error message to understand what the interpreter is trying to tell you**. With a little practice, and the helpful error messages by the Python interpreter, you will be find and fix the errors quickly."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exception Handling\n",
    "\n",
    "So far, we have seen that code with syntax errors will not run. However, code with other types of Runtime errors will run until it comes upon an exception, at which point it will crash. As often as possible, as a programmer must try to prevent your code from crashing. At times the code will fail to execute properly due to 'user error'.  In these instances passing along the error message to the user is the recommended approach."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Example 1**\n",
    "\n",
    "Lets take a look at an example function that divides the first parameter by the second and returns the quotient. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def div(x, y):\n",
    "    x = int(x)\n",
    "    y = int(y)\n",
    "    quotient = int(x/y)\n",
    "    return quotient\n",
    "        \n",
    "div(4,1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That works. But, what happens if you pass in a 0 as the second parameter?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "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-19-86185baafcec>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mdiv\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\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-18-7425c2ad8697>\u001b[0m in \u001b[0;36mdiv\u001b[0;34m(x, y)\u001b[0m\n\u001b[1;32m      2\u001b[0m     \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m     \u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m     \u001b[0mquotient\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0my\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      5\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mquotient\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mZeroDivisionError\u001b[0m: division by zero"
     ]
    }
   ],
   "source": [
    "div(4,0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function throws an error (aptly named ZeroDivisionError) when we try to divide 4 by 0. So, how do we handle this specific situation?\n",
    "\n",
    "Python gives you a tool for handling runtime exceptions like these - the try...except block. Lets see to implement it in a new version of the function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "divideNoError: Please enter a non-zero value for the second parameter\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def divideNoError(x, y):\n",
    "    try:\n",
    "        x = int(x)\n",
    "        y = int(y)\n",
    "        quotient = int(x/y)\n",
    "    # The following block of code will only run if an attempt to divide by 0 is made.\n",
    "    except ZeroDivisionError:\n",
    "        print(\"divideNoError: Please enter a non-zero value for the second parameter\")\n",
    "    # The else clause will run if no Runtime error is thrown\n",
    "    else:\n",
    "        return quotient\n",
    "        \n",
    "divideNoError(4,0)\n",
    "divideNoError(4,2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above function, the try..except..else block is able to handle the cases there is a division by zero. \n",
    "\n",
    "Have we handled all runtime errors? Run the following cell to find out."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "invalid literal for int() with base 10: 'a'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-21-6608fe3d1475>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mdivideNoError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'a'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m1\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-20-aaa21346818d>\u001b[0m in \u001b[0;36mdivideNoError\u001b[0;34m(x, y)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mdivideNoError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\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;32mtry\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[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\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[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m         \u001b[0mquotient\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m)\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: 'a'"
     ]
    }
   ],
   "source": [
    "divideNoError('a',1)                "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This time a different type of Runtime error `ValueError` is flagged when the line of code `x = int(x)` attempts to convert `'a'`  to type int. \n",
    "\n",
    "We can handle this error by adding another except clause within the same function. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def divideNoError(x, y):\n",
    "    # same try clause as earlier\n",
    "    try:\n",
    "        x = int(x)\n",
    "        y = int(y)\n",
    "        quotient = int(x/y)\n",
    "    # we had this one last time too\n",
    "    except ZeroDivisionError:\n",
    "        print(\"divideNoError: Please enter a non-zero value for the second parameter\")\n",
    "    # this is the new clause we added to handle the error we ran into earlier\n",
    "    except ValueError:\n",
    "        print(\"divideNoError: Please enter numeric values for the two parameters\")\n",
    "    else:\n",
    "        return quotient        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now lets try to run the three different examples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "divideNoError: Please enter a non-zero value for the second parameter\n",
      "divideNoError: Please enter numeric values for the two parameters\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "divideNoError(4,0)\n",
    "divideNoError('a',1)\n",
    "divideNoError(4,2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This new version of the function handled the division by 0, string conversion and carried out the division correctly. \n",
    "\n",
    "We can handle each individual Runtime error by an `except` clause. This is the recommended approach since you get the chance to handle each error separately and display the appropriate message to the user. \n",
    "\n",
    "For a few lines of code, this still works. You can isolate the function where you had an error and also the type of the error that was thrown. But, you don't know which line of code actually threw the error. You are missing the sequence of messages that usually displayed when an error message is thrown without a try..except clause. \n",
    "\n",
    "Is there a way we can capture all that information and handle the exception? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Using logging.exception you can capture the type and location of the error.  \n",
    "import logging\n",
    "\n",
    "def divideNoError(x, y):\n",
    "    try:\n",
    "        x = int(x)\n",
    "        y = int(y)\n",
    "        quotient = int(x/y)\n",
    "    except Exception as e:\n",
    "        # pass the exception variable to the logging.exception function \n",
    "        logging.exception(e)\n",
    "    else:\n",
    "        return quotient     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "ERROR:root:division by zero\n",
      "Traceback (most recent call last):\n",
      "  File \"<ipython-input-24-691d5490c648>\", line 8, in divideNoError\n",
      "    quotient = int(x/y)\n",
      "ZeroDivisionError: division by zero\n"
     ]
    }
   ],
   "source": [
    "divideNoError(4,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "ERROR:root:invalid literal for int() with base 10: 'a'\n",
      "Traceback (most recent call last):\n",
      "  File \"<ipython-input-24-691d5490c648>\", line 7, in divideNoError\n",
      "    y = int(y)\n",
      "ValueError: invalid literal for int() with base 10: 'a'\n"
     ]
    }
   ],
   "source": [
    "divideNoError(2,'a')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "ERROR:root:int() argument must be a string, a bytes-like object or a number, not 'list'\n",
      "Traceback (most recent call last):\n",
      "  File \"<ipython-input-24-691d5490c648>\", line 6, in divideNoError\n",
      "    x = int(x)\n",
      "TypeError: int() argument must be a string, a bytes-like object or a number, not 'list'\n"
     ]
    }
   ],
   "source": [
    "# In this example we were able to capture the TypeError as well \n",
    "divideNoError([0],[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above example, you were able to use the generic `Exception` to handle the ZeroDivisionError, ValueError & TypeError scenarios. But, this is still **not recommended**. Its best to handle the expected error scenarios in individual exception blocks while displaying the appropriate error message to the user.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\"><b>Problem 2 (4 pts.)</b>: In the function below add exception handling code in the block below that will handle TypeErrors or ValueErrors.</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "power(base,exponent): <class 'TypeError'> float() argument must be a string or a number, not 'list'\n",
      "Error: invalid values specified, please enter numeric values for the two parameters\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "4.0"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def power(b, e):\n",
    "    try:\n",
    "        b = float(b)\n",
    "        e = float(e)\n",
    "        returnValue = b**e\n",
    "    except TypeError as te:            \n",
    "        print(\"power(base,exponent):\",type(te),te)\n",
    "    except ValueError:\n",
    "        print('Error: invalid values specified, please enter numeric values for the two parameters')\n",
    "    # TODO: Add an except clause to handle the ValueError followed by a print statement that displays the error. \n",
    "    # Pay attention to indentation.\n",
    "\n",
    "    \n",
    "    # TODO: Add an else clause that returns the final value. Pay attention to indentation.\n",
    "    else:\n",
    "        return returnValue\n",
    "    \n",
    "# DONT DELETE ANYTHING BELOW THIS LINE\n",
    "# Test Cases\n",
    "# Throws a TypeError\n",
    "power([0],2)\n",
    "# Throws a ValueError\n",
    "power('a',2)\n",
    "# Returns a value\n",
    "power(2,2)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Raising Exceptions\n",
    "\n",
    "So far, we have see how useful exceptions can be and how they are handled in the Python language. Now, we will explore how you can 'raise' exceptions to handle cases that wouldn't otherwise result in a runtime error.\n",
    "\n",
    "The way we do this is by using the raise statement. Let's take a look at an example.\n",
    "\n",
    "**Example**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Area of square is: 25\n",
      "Area of square is: 100\n",
      "areaSquare(side): <class 'ValueError'> -1 is not a valid length. Please enter a positive number.\n",
      "areaSquare(side): <class 'TypeError'> int() argument must be a string, a bytes-like object or a number, not 'list'\n"
     ]
    }
   ],
   "source": [
    "# This function calculates the area of a square \n",
    "def areaSquare(s):\n",
    "    side = 0\n",
    "    try:\n",
    "        side = int(s)\n",
    "        if (side < 0):\n",
    "            raise ValueError(str(side) + \" is not a valid length. Please enter a positive number.\")\n",
    "        else:\n",
    "            print(\"Area of square is:\", side*side)\n",
    "    except ValueError as ve:\n",
    "        print(\"areaSquare(side):\",type(ve),ve)    \n",
    "    except TypeError as te:\n",
    "        print(\"areaSquare(side):\",type(te),te)    \n",
    "\n",
    "# Test Cases        \n",
    "areaSquare(5)\n",
    "areaSquare(10)\n",
    "areaSquare(-1)\n",
    "areaSquare([1])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, the function areaSquare handles the TypeError successfully. But, the function would accept negative values for side. To handle that scenario we can use the `raise` keyword followed by the type of Runtime Exception we want to flag. In this case, we want to flag a `ValueError` since the function should only accept positive numbers.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\"><b>Problem 3 (6 pts.)</b>: In the function below add exception handling code in the block below that will handle ValueErrors.</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Guess a number between 0 and 3 (inclusive) or type q to quit: 1\n",
      "Sorry. The correct number was 0\n",
      "Guess a number between 0 and 3 (inclusive) or type q to quit: 3\n",
      "Sorry. The correct number was 1\n",
      "Guess a number between 0 and 3 (inclusive) or type q to quit: 2\n",
      "Your guess was correct!\n",
      "Guess a number between 0 and 3 (inclusive) or type q to quit: c\n",
      "playGuessANumber(guess): <class 'ValueError'> invalid literal for int() with base 10: 'c'\n"
     ]
    }
   ],
   "source": [
    "from random import randint\n",
    "\n",
    "def playGuessANumber():\n",
    "    num = randint(0, 3)\n",
    "    instructions = \"Guess a number between 0 and 3 (inclusive) or type q to quit: \"\n",
    "    guess = input(instructions)\n",
    "    if (guess == 'q'):\n",
    "        print(\"Thank you for playing!\")\n",
    "        return False\n",
    "    else:\n",
    "        try:    # TODO: Add a try clause to handle the Runtime errors. Pay attention to indentation.\n",
    "        \n",
    "            guess = int(guess)\n",
    "            if ((guess < 0) or (guess > 3)):\n",
    "                raise ValueError(str(guess) + 'Not a valid guess.')# TODO: Raise a ValueError with the message 'Not a valid guess'.\n",
    "                \n",
    "            elif (guess != num):\n",
    "                print(\"Sorry. The correct number was\",num)\n",
    "                return True\n",
    "            else:\n",
    "                print(\"Your guess was correct!\")\n",
    "                return True\n",
    "        except ValueError as ve:\n",
    "            print('playGuessANumber(guess):',type(ve),ve)# TODO: Add an except clause to handle a ValueError followed by a print statement that displays the error.    \n",
    "                \n",
    "        \n",
    "keepPlaying = True\n",
    "            \n",
    "while keepPlaying:\n",
    "        keepPlaying = playGuessANumber()\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Finally...\n",
    "\n",
    "In addition to try..except..else Python also supports the use of a `finally` clause as well. The only difference between `else` and `finally` is that the code in the `else` clause will execute only if the except block didn't execute while the `finally` block will always execute.\n",
    "\n",
    "Lets look at a final example. \n",
    "\n",
    "**Note: This example is for reference only. You don't need to run the cell. It won't produce any output.**\n",
    "\n",
    "**Example**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sqlite3\n",
    "import logging\n",
    "import os\n",
    "\n",
    "databaseFile = \"test430.db\"\n",
    "# Try clause where a connection to a database is made and a create sql is executed\n",
    "try:\n",
    "    if os.path.isfile(databaseFile):\n",
    "        os.remove(databaseFile)\n",
    "        \n",
    "    conn = sqlite3.connect(databaseFile)\n",
    "    conn.execute('''CREATE TABLE COMPANY\n",
    "             (ID INT PRIMARY KEY     NOT NULL,\n",
    "             NAME           TEXT    NOT NULL,\n",
    "             AGE            INT     NOT NULL,\n",
    "             ADDRESS        CHAR(50),\n",
    "             SALARY         REAL);''')\n",
    "# Except clause to catch all exceptions. We are logging the errors.\n",
    "except Exception as e:\n",
    "    logging.exception(e)\n",
    "# We only want the commit to go through if there were no Runtime errors\n",
    "else:\n",
    "    conn.commit()\n",
    "# We do want to close the connection even in the event that we ran into errors \n",
    "finally:\n",
    "    conn.close()    "
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.5"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}