A Beginners Guide to Python/__22. Try & Except.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Error Handling Using Try & Except\n",
    "\n",
    "> Errors should never pass silently.\n",
    "Unless explicitly silenced. ~ Zen of Python\n",
    "\n",
    "Hi guys, last lecture we looked at common error messages, in this lecture we shall look at a neat way to handle those errors:\n",
    "\n",
    "    The Syntax:\n",
    "    try:\n",
    "        {code block}\n",
    "    except {ErrorMessage}:\n",
    "        {code block}\n",
    "        \n",
    "Okay, so what does try & except actually do?  Well basically, Python tries to execute a statement, but if in the process of executing that statement an error (of type ErrorMessage) occurs then we to something else instead. In terms of logic, try/except works a bit like if/elif work. Here is a simple example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n",
      "1049.76\n",
      "201.64\n",
      "aa\n",
      "bb\n",
      "[]\n",
      "[1, 2, 1, 2]\n"
     ]
    }
   ],
   "source": [
    "a_list = [10, 32.4, -14.2, \"a\", \"b\", [], [1,2]]\n",
    "\n",
    "for item in a_list:\n",
    "        try:\n",
    "            print(item * item)\n",
    "        except TypeError:\n",
    "            print(item + item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So what’s going on here? Well, we have list which contains several different data-types. For every 'item' we try to multiply item by itself. If 'item' is a number this makes sense and so we print item * item. However, if we try to multiply a string by a string we get a TypeError, which the except statement catches. So if we receive a TypeError we try something else, in this particular case we add item to item, and thus \"aa\", \"bb\", etc get printed.\n",
    "\n",
    "Now it is important to note this current code is only set up to handle TypeErrors. What happens if we change the above bit of code to divide rather than multiply and feed it 0?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "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-4-34909c297959>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mitem\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m0\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[0m\n\u001b[0;32m----> 3\u001b[0;31m     \u001b[0mitem\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0mitem\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mTypeError\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[0mitem\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mitem\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mZeroDivisionError\u001b[0m: division by zero"
     ]
    }
   ],
   "source": [
    "item = 0\n",
    "try:\n",
    "    item / item\n",
    "except TypeError:\n",
    "    print(item + item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this case Python didn't receive a TypeError and thus the except block of code failed to execute. Now, we can fix this code in one of two ways:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bad  0\n",
      "Good 0\n"
     ]
    }
   ],
   "source": [
    "x = 0\n",
    "\n",
    "# The bad fix first...\n",
    "try:\n",
    "    x / x\n",
    "except: \n",
    "    print(\"Bad \", x + x)\n",
    "\n",
    "# The Good fix...\n",
    "try:\n",
    "    item / item\n",
    "except (TypeError, ZeroDivisionError): # please note the \"SnakeCase\".\n",
    "    print(\"Good\", x + x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The bad fix just leaves a blank except statement, this catches ALL errors. The good fix meanwhile specifically states what errors it should catch, but the code will still fail if the error is something other then Type or dividing by zero.\n",
    "\n",
    "So why is it bad to leave a bare except statement? Well, as I've stated elsewhere in these lecture series it is often better to crash than it is to output junk. And please trust me when I say bare except clauses are a great way to output junk.  \n",
    "\n",
    "In the second case we specifically state the errors we except to sometimes receive. And this is nice for a few reasons, first, by naming the exceptions the code is a bit more readable. Secondly, expressly stating the errors forces you to be much more *mindful* when writing the code in the first place. And thirdly, if something unexpected does happen then, unless you have bare except statements throughout all of your code eventually you'll pass junk data to some function and get an error there. So basically in many cases you are not really *solving* the problem, you end up *delaying* the problem. \n",
    "\n",
    "In short, for most applications you should be looking to handle the minimum number of cases you need for the code to function and in all other cases just let it crash.\n",
    "\n",
    "Okay, how about one more example?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting square = (2,2)\n",
      "Trying to move 'left' to square (1, 2):\n",
      "[0, 0, 0]\n",
      "[0, 0, 0]\n",
      "[0, 2, 1]\n",
      "\n",
      "\n",
      "Trying to move 'right' to square (3, 2):\n",
      "Square (3, 2), is out of bounds. IndexError sucessfully caught.\n",
      "\n",
      "Trying to move 'up' to square (2, 1):\n",
      "[0, 0, 0]\n",
      "[0, 0, 2]\n",
      "[0, 2, 1]\n",
      "\n",
      "\n",
      "Trying to move 'down' to square (2, 3):\n",
      "Square (2, 3), is out of bounds. IndexError sucessfully caught.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "def character_movement(x, y):\n",
    "    \"\"\"where (x,y) is the position on a 2-d plane\"\"\"\n",
    "    return [(\"start\", (x, y)), \n",
    "            (\"left\", (x -1, y)),(\"right\", (x + 1, y)),\n",
    "            (\"up\", (x, y - 1)), (\"down\", (x, y + 1))]\n",
    "\n",
    "the_map = [ [0, 0, 0],   \n",
    "            [0, 0, 0],\n",
    "            [0, 0, 1]] # 1 denotes our character\n",
    "\n",
    "\n",
    "moves = character_movement(2, 2)\n",
    "print(\"Starting square = (2,2)\")\n",
    "\n",
    "for (direction, position) in moves[1:]:\n",
    "    print(\"Trying to move '{}' to square {}:\".format(direction, position))\n",
    "    try:\n",
    "        the_map[position[1]][position[0]] = 2\n",
    "        print(*the_map, sep=\"\\n\")\n",
    "        print(\"\\n\")\n",
    "    except IndexError:\n",
    "        print(\"Square {}, is out of bounds. IndexError sucessfully caught.\\n\".format(position))"
   ]
  }
 ],
 "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}