workflow/exception_handling.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "524d0abc-373b-4445-91f6-0df61808b536",
   "metadata": {},
   "source": [
    "# What to do when things go wrong?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f64a1059-43db-4e92-9d8a-20e42a01b76a",
   "metadata": {},
   "source": [
    "We typically write code to look at the values of a variable and then do the right thing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "4b7230ac-aed3-491d-9374-a2e5bf28797f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "a = 0\n",
    "b = 1\n",
    "if a > 0:\n",
    "    print(a)\n",
    "else:\n",
    "    print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2e82781-f293-4708-902b-6818d0907516",
   "metadata": {},
   "source": [
    "But what about more complicated data structures? To catch and handle errors for so many possible issues would make extremely complex code. There must be a better way!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "296201b4-0f7b-4066-bd8a-0145555ac587",
   "metadata": {},
   "source": [
    "Here we make a loop to count up the values in a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "743f2a26-8af5-4cd6-bc8e-d0e658dd9af1",
   "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)",
      "Cell \u001b[0;32mIn[2], line 5\u001b[0m\n\u001b[1;32m      3\u001b[0m total \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0\u001b[39m\n\u001b[1;32m      4\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m ii \u001b[38;5;129;01min\u001b[39;00m values:\n\u001b[0;32m----> 5\u001b[0m     total \u001b[38;5;241m=\u001b[39m \u001b[43mtotal\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mii\u001b[49m\n\u001b[1;32m      7\u001b[0m total\n",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'"
     ]
    }
   ],
   "source": [
    "values = [0, 1, 2, 3, 4, 5]\n",
    "values = [0, 1, 2, 3, 'four', 5]\n",
    "total = 0\n",
    "for ii in values:\n",
    "    total = total + ii\n",
    "    \n",
    "total"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0044c62-a1f6-44b4-8cfa-56afadf2c48f",
   "metadata": {},
   "source": [
    "We could put in an if statement to check the type for each value in the list and only allow the addition to occur when both values are correct type. But we need to anticipate all the different permutations of possible values that someone could use."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "1ab7a121-3f70-43fe-8006-c9df7ee1aa5d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "total = 0\n",
    "values = [0, 1, 2., 3., 'four', 5.]\n",
    "for ii in values:\n",
    "    if isinstance(ii, int):  # Notice that only integers are counted, but 3 of the values are floats.\n",
    "        total = total + ii\n",
    "    \n",
    "total"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "476e9d6f-f66e-4d64-93d3-3f6f8ce8d18d",
   "metadata": {},
   "source": [
    "A better method is to allow the error to occur and handle it. This is an example of catching the exception and then handling it. The down side is that we don't get the correct value because the code stopped early in the loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "7d3b07fe-99a1-4f3b-88ce-824a4a036fe8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There was an error with the value 'four'\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "6.0"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "total = 0\n",
    "try:  # This is the beginning of the try block. All code until \"except\" is in the block.\n",
    "    for ii in values:\n",
    "        total = total + ii\n",
    "except: # If an exception is raised in the try block, that code stops and this code is executed.\n",
    "    print(f\"There was an error with the value '{ii}'\\n\")\n",
    "    \n",
    "total"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bea7d146-6132-4e60-9686-d37f70ac1aac",
   "metadata": {},
   "source": [
    "If we move the try/except block to a different part we can keep the loop going and handle the error better to get a correct value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "6642cc13-d597-4d5e-a59c-a16d05755844",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11.0"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "total = 0\n",
    "for ii in values:\n",
    "    try:\n",
    "        total = total + ii\n",
    "    except TypeError:  # Here we say only catch errors in the TypeError class.\n",
    "        pass  # We need to put something here. This is a special keyword in Python that says do nothing\n",
    "    \n",
    "total"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9cc9b05-b7d7-4b8c-bc8b-1b4bb8d1b959",
   "metadata": {},
   "source": [
    "This coding style is so useful that it has been set up to be a basic place to start with coding. It actually has the ability to not just be a backup for when things go wrong, but to be part of the standard flow of the code. When it is used and expected to execute as part of the normal flow, it's called \"duck typing\". If it walks like a duck, quacks like a duck, and looks like a duck - it is a duck."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "9dc57bb8-8e82-4c20-ae12-94dad660b3dc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Had a ZeroDivisionError exception\n",
      "Finally Block\n",
      "\n",
      "Else Block: Current total is 1.0\n",
      "Finally Block\n",
      "\n",
      "Else Block: Current total is 1.5\n",
      "Finally Block\n",
      "\n",
      "Else Block: Current total is 1.8333333333333333\n",
      "Finally Block\n",
      "\n",
      "Exception Block: I don't know what to do with this.\n",
      "Finally Block\n",
      "\n",
      "total is 1.8333333333333333\n"
     ]
    }
   ],
   "source": [
    "values = [0, 1, 2., 'three']\n",
    "total = 0\n",
    "for ii in range(0, 5):  # Notice we are looping over more than 4 elements\n",
    "\n",
    "    # Try to do what we want to do. If this does not raise an exception\n",
    "    # the else block is skipped.\n",
    "    try:\n",
    "        value = values[ii]\n",
    "        total = total + 1 / ii\n",
    "\n",
    "    # If the try block raised an error and that error is a ZeroDivisionError\n",
    "    # then execute this block.\n",
    "    except ZeroDivisionError:\n",
    "        print('Had a ZeroDivisionError exception')\n",
    "\n",
    "    # If the try block raised an error and that error is a TypeError\n",
    "    # then execute this block.\n",
    "    except TypeError:\n",
    "        total = total + 1. / 3.\n",
    "        print('Had a TypeError exception')\n",
    "\n",
    "    # If the try block raised an error and that error is not\n",
    "    # a ZeroDivisionError or TypeError then execute this block.\n",
    "    # This is the general exception block. Notice that we put it after\n",
    "    # the ZeroDivisionError and TypeError block. The exceptions fail\n",
    "    # in order.\n",
    "    except Exception:\n",
    "        print(\"Exception Block: I don't know what to do with this.\")\n",
    "\n",
    "    # If no exceptions are raised after executing the try block, execute\n",
    "    # the code in the else block.\n",
    "    else:\n",
    "        print(f'Else Block: Current total is {total}')\n",
    "\n",
    "    # This block is executed no matter what. This is great for cleaning things\n",
    "    # up or setting a value regardless of what happens in the previous blocks.\n",
    "    finally:\n",
    "        print('Finally Block\\n')\n",
    "              \n",
    "print(f\"total is {total}\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}