debugging.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "f0634295",
   "metadata": {},
   "source": [
    "\n",
    "<a id='debugging'></a>\n",
    "<div id=\"qe-notebook-header\" align=\"right\" style=\"text-align:right;\">\n",
    "        <a href=\"https://quantecon.org/\" title=\"quantecon.org\">\n",
    "                <img style=\"width:250px;display:inline;\" width=\"250px\" src=\"https://assets.quantecon.org/img/qe-menubar-logo.svg\" alt=\"QuantEcon\">\n",
    "        </a>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ade0dff5",
   "metadata": {},
   "source": [
    "# Debugging and Handling Errors\n",
    "\n",
    "\n",
    "<a id='index-0'></a>\n",
    "> “Debugging is twice as hard as writing the code in the first place.\n",
    "> Therefore, if you write the code as cleverly as possible, you are, by definition,\n",
    "> not smart enough to debug it.” – Brian Kernighan"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c4b0a67",
   "metadata": {},
   "source": [
    "## Overview\n",
    "\n",
    "Are you one of those programmers who fills their code with `print` statements when trying to debug their programs?\n",
    "\n",
    "Hey, we all used to do that.\n",
    "\n",
    "(OK, sometimes we still do that…)\n",
    "\n",
    "But once you start writing larger programs you’ll need a better system.\n",
    "\n",
    "You may also want to handle potential errors in your code as they occur.\n",
    "\n",
    "In this lecture, we will discuss how to debug our programs and improve error handling."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "194c0af3",
   "metadata": {},
   "source": [
    "## Debugging\n",
    "\n",
    "\n",
    "<a id='index-1'></a>\n",
    "Debugging tools for Python vary across platforms, IDEs and editors.\n",
    "\n",
    "For example, a [visual debugger](https://jupyterlab.readthedocs.io/en/stable/user/debugger.html) is available in JupyterLab.\n",
    "\n",
    "Here we’ll focus on Jupyter Notebook and leave you to explore other settings.\n",
    "\n",
    "We’ll need the following imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c31e2463",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9fb3eb0",
   "metadata": {},
   "source": [
    "\n",
    "<a id='debug-magic'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4bde94e3",
   "metadata": {},
   "source": [
    "### The `debug` Magic\n",
    "\n",
    "Let’s consider a simple (and rather contrived) example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4de9be1c",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "def plot_log():\n",
    "    fig, ax = plt.subplots(2, 1)\n",
    "    x = np.linspace(1, 2, 10)\n",
    "    ax.plot(x, np.log(x))\n",
    "    plt.show()\n",
    "\n",
    "plot_log()  # Call the function, generate plot"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94a8dce3",
   "metadata": {},
   "source": [
    "This code is intended to plot the `log` function over the interval $ [1, 2] $.\n",
    "\n",
    "But there’s an error here: `plt.subplots(2, 1)` should be just `plt.subplots()`.\n",
    "\n",
    "(The call `plt.subplots(2, 1)` returns a NumPy array containing two axes objects, suitable for having two subplots on the same figure)\n",
    "\n",
    "The traceback shows that the error occurs at the method call `ax.plot(x, np.log(x))`.\n",
    "\n",
    "The error occurs because we have mistakenly made `ax` a NumPy array, and a NumPy array has no `plot` method.\n",
    "\n",
    "But let’s pretend that we don’t understand this for the moment.\n",
    "\n",
    "We might suspect there’s something wrong with `ax` but when we try to investigate this object, we get the following exception:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "98362fa8",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "ax"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac6b2a39",
   "metadata": {},
   "source": [
    "The problem is that `ax` was defined inside `plot_log()`, and the name is\n",
    "lost once that function terminates.\n",
    "\n",
    "Let’s try doing it a different way.\n",
    "\n",
    "We run the first cell block again, generating the same error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "12c31253",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "def plot_log():\n",
    "    fig, ax = plt.subplots(2, 1)\n",
    "    x = np.linspace(1, 2, 10)\n",
    "    ax.plot(x, np.log(x))\n",
    "    plt.show()\n",
    "\n",
    "plot_log()  # Call the function, generate plot"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2409ecfd",
   "metadata": {},
   "source": [
    "But this time we type in the following cell block"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b860883e",
   "metadata": {
    "hide-output": false
   },
   "source": [
    "```ipython\n",
    "%debug\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec9a8ed9",
   "metadata": {},
   "source": [
    "You should be dropped into a new prompt that looks something like this"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38b3e080",
   "metadata": {
    "hide-output": false
   },
   "source": [
    "```ipython\n",
    "ipdb>\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b038c851",
   "metadata": {},
   "source": [
    "(You might see pdb> instead)\n",
    "\n",
    "Now we can investigate the value of our variables at this point in the program, step forward through the code, etc.\n",
    "\n",
    "For example, here we simply type the name `ax` to see what’s happening with\n",
    "this object:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a4ba9e3",
   "metadata": {
    "hide-output": false
   },
   "source": [
    "```ipython\n",
    "ipdb> ax\n",
    "array([<matplotlib.axes.AxesSubplot object at 0x290f5d0>,\n",
    "       <matplotlib.axes.AxesSubplot object at 0x2930810>], dtype=object)\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf87b100",
   "metadata": {},
   "source": [
    "It’s now very clear that `ax` is an array, which clarifies the source of the\n",
    "problem.\n",
    "\n",
    "To find out what else you can do from inside `ipdb` (or `pdb`), use the\n",
    "online help"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0d0a4a1",
   "metadata": {
    "hide-output": false
   },
   "source": [
    "```ipython\n",
    "ipdb> h\n",
    "\n",
    "Documented commands (type help <topic>):\n",
    "========================================\n",
    "EOF    bt         cont      enable  jump  pdef   r        tbreak   w\n",
    "a      c          continue  exit    l     pdoc   restart  u        whatis\n",
    "alias  cl         d         h       list  pinfo  return   unalias  where\n",
    "args   clear      debug     help    n     pp     run      unt\n",
    "b      commands   disable   ignore  next  q      s        until\n",
    "break  condition  down      j       p     quit   step     up\n",
    "\n",
    "Miscellaneous help topics:\n",
    "==========================\n",
    "exec  pdb\n",
    "\n",
    "Undocumented commands:\n",
    "======================\n",
    "retval  rv\n",
    "\n",
    "ipdb> h c\n",
    "c(ont(inue))\n",
    "Continue execution, only stop when a breakpoint is encountered.\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81965984",
   "metadata": {},
   "source": [
    "### Setting a Break Point\n",
    "\n",
    "The preceding approach is handy but sometimes insufficient.\n",
    "\n",
    "Consider the following modified version of our function above"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "76146390",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "def plot_log():\n",
    "    fig, ax = plt.subplots()\n",
    "    x = np.logspace(1, 2, 10)\n",
    "    ax.plot(x, np.log(x))\n",
    "    plt.show()\n",
    "\n",
    "plot_log()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17497307",
   "metadata": {},
   "source": [
    "Here the original problem is fixed, but we’ve accidentally written\n",
    "`np.logspace(1, 2, 10)` instead of `np.linspace(1, 2, 10)`.\n",
    "\n",
    "Now there won’t be any exception, but the plot won’t look right.\n",
    "\n",
    "To investigate, it would be helpful if we could inspect variables like `x` during execution of the function.\n",
    "\n",
    "To this end, we add a “break point” by inserting  `breakpoint()` inside the function code block"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e6a33d5",
   "metadata": {
    "hide-output": false
   },
   "source": [
    "```python3\n",
    "def plot_log():\n",
    "    breakpoint()\n",
    "    fig, ax = plt.subplots()\n",
    "    x = np.logspace(1, 2, 10)\n",
    "    ax.plot(x, np.log(x))\n",
    "    plt.show()\n",
    "\n",
    "plot_log()\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5d531aa",
   "metadata": {},
   "source": [
    "Now let’s run the script, and investigate via the debugger"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "efc4282e",
   "metadata": {
    "hide-output": false
   },
   "source": [
    "```ipython\n",
    "> <ipython-input-6-a188074383b7>(6)plot_log()\n",
    "-> fig, ax = plt.subplots()\n",
    "(Pdb) n\n",
    "> <ipython-input-6-a188074383b7>(7)plot_log()\n",
    "-> x = np.logspace(1, 2, 10)\n",
    "(Pdb) n\n",
    "> <ipython-input-6-a188074383b7>(8)plot_log()\n",
    "-> ax.plot(x, np.log(x))\n",
    "(Pdb) x\n",
    "array([ 10.        ,  12.91549665,  16.68100537,  21.5443469 ,\n",
    "        27.82559402,  35.93813664,  46.41588834,  59.94842503,\n",
    "        77.42636827, 100.        ])\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf864328",
   "metadata": {},
   "source": [
    "We used `n` twice to step forward through the code (one line at a time).\n",
    "\n",
    "Then we printed the value of `x` to see what was happening with that variable.\n",
    "\n",
    "To exit from the debugger, use `q`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8e0c99d",
   "metadata": {},
   "source": [
    "### Other Useful Magics\n",
    "\n",
    "In this lecture, we used the `%debug` IPython magic.\n",
    "\n",
    "There are many other useful magics:\n",
    "\n",
    "- `%precision 4` sets printed precision for floats to 4 decimal places  \n",
    "- `%whos` gives a list of variables and their values  \n",
    "- `%quickref` gives a list of magics  \n",
    "\n",
    "\n",
    "The full list of magics is [here](http://ipython.readthedocs.org/en/stable/interactive/magics.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "91a91e86",
   "metadata": {},
   "source": [
    "## Handling Errors\n",
    "\n",
    "\n",
    "<a id='index-2'></a>\n",
    "Sometimes it’s possible to anticipate bugs and errors as we’re writing code.\n",
    "\n",
    "For example, the unbiased sample variance of sample $ y_1, \\ldots, y_n $\n",
    "is defined as\n",
    "\n",
    "$$\n",
    "s^2 := \\frac{1}{n-1} \\sum_{i=1}^n (y_i - \\bar y)^2\n",
    "\\qquad \\bar y = \\text{ sample mean}\n",
    "$$\n",
    "\n",
    "This can be calculated in NumPy using `np.var`.\n",
    "\n",
    "But if you were writing a function to handle such a calculation, you might\n",
    "anticipate a divide-by-zero error when the sample size is one.\n",
    "\n",
    "One possible action is to do nothing — the program will just crash, and spit out an error message.\n",
    "\n",
    "But sometimes it’s worth writing your code in a way that anticipates and deals with runtime errors that you think might arise.\n",
    "\n",
    "Why?\n",
    "\n",
    "- Because the debugging information provided by the interpreter is often less useful than what can be provided by a well written error message.  \n",
    "- Because errors that cause execution to stop interrupt workflows.  \n",
    "- Because it reduces confidence in your code on the part of your users (if you are writing for others).  \n",
    "\n",
    "\n",
    "In this section, we’ll discuss different types of errors in Python and techniques to handle potential errors in our programs."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d470d28c",
   "metadata": {},
   "source": [
    "### Errors in Python\n",
    "\n",
    "We have seen `AttributeError` and `NameError` in [our previous examples](#debug-magic).\n",
    "\n",
    "In Python, there are two types of errors – syntax errors and exceptions.\n",
    "\n",
    "\n",
    "<a id='index-3'></a>\n",
    "Here’s an example of a common error type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f8db69d9",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "def f:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b37e5ec3",
   "metadata": {},
   "source": [
    "Since illegal syntax cannot be executed, a syntax error terminates execution of the program.\n",
    "\n",
    "Here’s a different kind of error, unrelated to syntax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dead4133",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "1 / 0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "035ad955",
   "metadata": {},
   "source": [
    "Here’s another"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ba8a78aa",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "x1 = y1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20a7e86f",
   "metadata": {},
   "source": [
    "And another"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f4588276",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "'foo' + 6"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ab06852",
   "metadata": {},
   "source": [
    "And another"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2b4182ff",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "X = []\n",
    "x = X[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ba7b1b7",
   "metadata": {},
   "source": [
    "On each occasion, the interpreter informs us of the error type\n",
    "\n",
    "- `NameError`, `TypeError`, `IndexError`, `ZeroDivisionError`, etc.  \n",
    "\n",
    "\n",
    "In Python, these errors are called *exceptions*."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70bbc42f",
   "metadata": {},
   "source": [
    "### Assertions\n",
    "\n",
    "\n",
    "<a id='index-4'></a>\n",
    "Sometimes errors can be avoided by checking whether your program runs as expected.\n",
    "\n",
    "A relatively easy way to handle checks is with the `assert` keyword.\n",
    "\n",
    "For example, pretend for a moment that the `np.var` function doesn’t\n",
    "exist and we need to write our own"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8b0d6bbd",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "def var(y):\n",
    "    n = len(y)\n",
    "    assert n > 1, 'Sample size must be greater than one.'\n",
    "    return np.sum((y - y.mean())**2) / float(n-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0855317",
   "metadata": {},
   "source": [
    "If we run this with an array of length one, the program will terminate and\n",
    "print our error message"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a51891e0",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "var([1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a6ede7a",
   "metadata": {},
   "source": [
    "The advantage is that we can\n",
    "\n",
    "- fail early, as soon as we know there will be a problem  \n",
    "- supply specific information on why a program is failing  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20916d7c",
   "metadata": {},
   "source": [
    "### Handling Errors During Runtime\n",
    "\n",
    "\n",
    "<a id='index-5'></a>\n",
    "The approach used above is a bit limited, because it always leads to\n",
    "termination.\n",
    "\n",
    "Sometimes we can handle errors more gracefully, by treating special cases.\n",
    "\n",
    "Let’s look at how this is done."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26d6ffd0",
   "metadata": {},
   "source": [
    "#### Catching Exceptions\n",
    "\n",
    "We can catch and deal with exceptions using `try` – `except` blocks.\n",
    "\n",
    "Here’s a simple example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9ec8052e",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "def f(x):\n",
    "    try:\n",
    "        return 1.0 / x\n",
    "    except ZeroDivisionError:\n",
    "        print('Error: division by zero.  Returned None')\n",
    "    return None"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "384acf3c",
   "metadata": {},
   "source": [
    "When we call `f` we get the following output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b058daf4",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "f(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8ec0008e",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "f(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5b66cf74",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "f(0.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c497d2e8",
   "metadata": {},
   "source": [
    "The error is caught and execution of the program is not terminated.\n",
    "\n",
    "Note that other error types are not caught.\n",
    "\n",
    "If we are worried the user might pass in a string, we can catch that error too"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7ddd537f",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "def f(x):\n",
    "    try:\n",
    "        return 1.0 / x\n",
    "    except ZeroDivisionError:\n",
    "        print('Error: Division by zero.  Returned None')\n",
    "    except TypeError:\n",
    "        print(f'Error: x cannot be of type {type(x)}.  Returned None')\n",
    "    return None"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6ec87707",
   "metadata": {},
   "source": [
    "Here’s what happens"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3fde0e53",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "f(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a86bb99b",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "f(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bbb18857",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "f('foo')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26f5ae36",
   "metadata": {},
   "source": [
    "If we feel lazy we can catch these errors together"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "faf42300",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "def f(x):\n",
    "    try:\n",
    "        return 1.0 / x\n",
    "    except:\n",
    "        print(f'Error.  An issue has occurred with x = {x} of type: {type(x)}')\n",
    "    return None"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a717c4da",
   "metadata": {},
   "source": [
    "Here’s what happens"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ebb03a94",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "f(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c66cf306",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "f(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "715170df",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "f('foo')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1110b25f",
   "metadata": {},
   "source": [
    "In general it’s better to be specific."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b93c89d",
   "metadata": {},
   "source": [
    "## Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "193ac12e",
   "metadata": {},
   "source": [
    "## Exercise 22.1\n",
    "\n",
    "Suppose we have a text file `numbers.txt` containing the following lines"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0edcbccd",
   "metadata": {
    "hide-output": false
   },
   "source": [
    "```text\n",
    "prices\n",
    "3\n",
    "8\n",
    "\n",
    "7\n",
    "21\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87d4478f",
   "metadata": {},
   "source": [
    "Using `try` – `except`, write a program to read in the contents of the file and sum the numbers, ignoring lines without numbers.\n",
    "\n",
    "You can use the `open()` function we learnt [before](https://python-programming.quantecon.org/python_advanced_features.html#iterators) to open `numbers.txt`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94d7f253",
   "metadata": {},
   "source": [
    "## Solution to[ Exercise 22.1](https://python-programming.quantecon.org/#debug_ex1)\n",
    "\n",
    "Let’s save the data first"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "81180ca4",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "%%file numbers.txt\n",
    "prices\n",
    "3\n",
    "8\n",
    "\n",
    "7\n",
    "21"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b3354551",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "f = open('numbers.txt')\n",
    "\n",
    "total = 0.0\n",
    "for line in f:\n",
    "    try:\n",
    "        total += float(line)\n",
    "    except ValueError:\n",
    "        pass\n",
    "\n",
    "f.close()\n",
    "\n",
    "print(total)"
   ]
  }
 ],
 "metadata": {
  "date": 1732936631.113383,
  "filename": "debugging.md",
  "kernelspec": {
   "display_name": "Python",
   "language": "python3",
   "name": "python3"
  },
  "title": "Debugging and Handling Errors"
 },
 "nbformat": 4,
 "nbformat_minor": 5
}