7-exceptions/errors-and-exceptions.ipynb

{
 "metadata": {
  "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-final"
  },
  "orig_nbformat": 2,
  "kernelspec": {
   "name": "Python 3.8.5 64-bit",
   "display_name": "Python 3.8.5 64-bit",
   "metadata": {
    "interpreter": {
     "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
    }
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2,
 "cells": [
  {
   "source": [
    "# Errors and Exceptions\n",
    "\n",
    "This section introduces the different exceptions in Python program and gives some examples that raise exceptions.\n",
    "\n",
    "## 1 Two Kinds of Errors\n",
    "\n",
    "Python has two kinds of program errors: syntax errors and exceptions.\n",
    "\n",
    "### 1.1 Syntax Errors\n",
    "\n",
    "When you learn Python, you often make many syntax errors because you are not familiar with the Python syntax (grammar). Typos and incorrect grammars are common reasons for syntax errors.\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for element in [1, 2, 3]\n",
    "    print(element)\n",
    "\n"
   ]
  },
  {
   "source": [
    "The above code has a `SyntaxError: invalid syntax` because it misses the `:` in the `for` statement."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "iff 6 > 5: print('hi')"
   ]
  },
  {
   "source": [
    "This example has a typo of `iff`. In both cases, you should practice more to learn the grammar and make less typos."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "### 1.2 Exceptions\n",
    "\n",
    "Even if all statements in a program are syntactically correct, Python may still fails to execute the program because something is wrong. These execution time errors are called `exceptions`,  `runtime exceptions` or `runtime errors`. When an exception happens and you don't handle it, the program crashes with an error message printed. Some common exceptions are:\n",
    "\n",
    "- `ZeroDivisionError`: divide by zero exception.\n",
    "- `NameError`: unknow variable identifier or function names, most likely cause by a typo.\n",
    "- `ImportError`: unable to import a specified module.\n",
    "- `AssertionError`: the boolean expression in an `assert` is false.\n",
    "- `FileNotFoundError`: unable to find the specified file when read a file.\n",
    "- `ValueError`: the value data is not expected. For example, unable to convert a string `\"abc\"` to an integer because the string value is not a valid number.\n",
    "\n",
    "You can find more exception in [exception document](https://docs.python.org/3/library/exceptions.html). The following are two simple examples that have exceptions:"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dividend = 42\n",
    "divisor = 0\n",
    "quotient = dividend / divisor\n",
    "print(quotient)"
   ]
  },
  {
   "source": [
    "The statement `dividend / divisor` is syntactically correct. However, dividing by 0 is undefined in math therefore a `ZeroDivisionError` happens. Python prints a message `ZeroDivisionError: division by zero` and stops execution at the statement that cuases the exception. In Python, we say that the statement `raises` an exception. The code after the statement is not executed.  "
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "prin('hi')"
   ]
  },
  {
   "source": [
    "The `prin('hi')` statement raises a `NameError` exception because it could't find the the function named `prin` -- in this case it is a typo for the built-in function `print`."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "## 2 Call Stack\n",
    "\n",
    "A non-trivial Python program usually has many functions. Staring from the `main` function, a function calls one or more functions that call other functions, and so on and so forth. An exception might be raised deeply in a function call."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def multiplyInput(factor):\n",
    "    input_str = input('Please type an integer: ')\n",
    "    input_number = int(input_str)\n",
    "    return factor * input_number\n",
    "   \n",
    "\n",
    "def multiplyBy7():\n",
    "    return multiplyInput(7)\n",
    "\n",
    "result = multiplyBy7()\n",
    "print(f'Result is {result}')"
   ]
  },
  {
   "source": [
    "When you run the above code and type `six` as the input, the prorgam crashes with an exception `ValueError: invalid literal for int() with base 10: 'six'`. Python couldn't convert string `'six'` to an integer. For demo purpose, we use two function calls here to show the `Traceback` of the error message. The error message contains all functions involved in the exception and list line number and statements of the code. In this example, the statement in line 10 `result = multileBy7()` calls the function `multiplyBy7` and the line 8 `return multiplyInput(7)` calls the function `multiplyInput(7)`. Finally, it is the line 3 `input_number = int(input_str)` that raises the `ValueError` exception.\n",
    "\n",
    "The function calls form a `stack` and the trace is called `stack trace`. The traceback message shows the stack in reverse order: in execution, the line 10 (usually in a `main` function) is at the bottom, the `multiplyBy7` is on top of it and the `multiplyInput` is at the top.\n",
    "\n",
    "The following digram describes a call stack.\n",
    "\n",
    "![stack](images/stack.png)"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "It puts the bottom function on the left and the top function (the currently running function) on the right. There could be many function calls in the middle."
   ],
   "cell_type": "markdown",
   "metadata": {}
  }
 ]
}