07 - Files and Exceptions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook is based on [Python Cheat Sheet](http://ehmatthes.github.io/pcc/cheatsheets/README.html) by [Eric Matthes](https://github.com/ehmatthes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Files and Exceptions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What are files? What are exceptions?\n",
    "Your programs can read information in from files, and they can write data to files. Reading from files allows you to work with a wide variety of information; writing to files allows users to pick up where they left off the next time they run your program. You can write text to files, and you can store Python structures such as lists in data files.\n",
    "\n",
    "Exceptions are special objects that help your programs respond to errors in appropriate ways. For example if your program tries to open a file that doesn’t exist, you can use exceptions to display an informative error message instead of having the program crash."
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Reading from a file\n",
    "To read from a file your program needs to open the file and then read the contents of the file. You can read the entire contents of the file at once, or read the file line by line. The `with` statement makes sure the file is closed properly when the program has finished accessing the file."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "##### Reading an entire file at once"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is Line 1\n",
      "This is Line 2\n",
      "This is Line 3\n"
     ]
    }
   ],
   "source": [
    "filename = 'siddhartha.txt'\n",
    "\n",
    "with open(filename) as f_obj:\n",
    "    contents = f_obj.read()\n",
    "\n",
    "print(contents)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-22T06:28:21.574875Z",
     "start_time": "2024-03-22T06:28:21.572480Z"
    }
   },
   "execution_count": 138
  },
  {
   "cell_type": "markdown",
   "source": [
    "##### Reading line by line"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is Line 1\n",
      "This is Line 2\n",
      "This is Line 3\n"
     ]
    }
   ],
   "source": [
    "filename = 'siddhartha.txt'\n",
    "\n",
    "with open(filename) as f_obj:\n",
    "    for line in f_obj:\n",
    "        print(line.rstrip())"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-22T06:28:21.633007Z",
     "start_time": "2024-03-22T06:28:21.630418Z"
    }
   },
   "execution_count": 139
  },
  {
   "cell_type": "markdown",
   "source": [
    "##### Storing the lines in a list"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is Line 1\n",
      "This is Line 2\n",
      "This is Line 3\n"
     ]
    }
   ],
   "source": [
    "filename = 'siddhartha.txt'\n",
    "\n",
    "with open(filename) as f_obj:\n",
    "    lines = f_obj.readlines()\n",
    "    \n",
    "for line in lines:\n",
    "    print(line.rstrip())"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-22T06:28:21.636158Z",
     "start_time": "2024-03-22T06:28:21.634090Z"
    }
   },
   "execution_count": 140
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Writing to a file\n",
    "Passing the 'w' argument to open() tells Python you want to write to the file. Be careful; this will erase the contents of the file if it already exists. Passing the 'a' argument tells Python you want to append to the end of an existing file."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "##### Writing to an empty file"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "outputs": [],
   "source": [
    "filename = 'programming.txt'\n",
    "\n",
    "with open(filename, 'w') as f:\n",
    "    f.write(\"I love programming!\")"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-22T06:28:21.639034Z",
     "start_time": "2024-03-22T06:28:21.637181Z"
    }
   },
   "execution_count": 141
  },
  {
   "cell_type": "markdown",
   "source": [
    "##### Writing multiple lines to an empty file"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "outputs": [],
   "source": [
    "filename = 'programming.txt'\n",
    "\n",
    "with open(filename, 'w') as f:\n",
    "    f.write(\"I love programming!\\n\")\n",
    "    f.write(\"I love creating new games.\\n\")"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-22T06:28:21.642438Z",
     "start_time": "2024-03-22T06:28:21.640090Z"
    }
   },
   "execution_count": 142
  },
  {
   "cell_type": "markdown",
   "source": [
    "##### Appending to a file"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "outputs": [],
   "source": [
    "filename = 'programming.txt'\n",
    "\n",
    "with open(filename, 'a') as f:\n",
    "    f.write(\"I also love working with data.\\n\")\n",
    "    f.write(\"I love making apps as well.\\n\")"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-22T06:28:21.646679Z",
     "start_time": "2024-03-22T06:28:21.644485Z"
    }
   },
   "execution_count": 143
  },
  {
   "cell_type": "markdown",
   "source": [
    "### File paths\n",
    "When Python runs the open() function, it looks for the file in the same directory where the program that's being excuted is stored. You can open a file from a subfolder using a relative path. You can also use an absolute path to open any file on your system."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "##### Opening a file from a subfolder"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is Alice\n",
      "I love working with data\n"
     ]
    }
   ],
   "source": [
    "f_path = \"text_files/alice.txt\"\n",
    "\n",
    "with open(f_path) as f_obj:\n",
    "    lines = f_obj.readlines()\n",
    "    \n",
    "for line in lines:\n",
    "    print(line.rstrip())"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-22T06:28:21.649965Z",
     "start_time": "2024-03-22T06:28:21.647677Z"
    }
   },
   "execution_count": 144
  },
  {
   "cell_type": "markdown",
   "source": [
    "##### Opening a file using an absolute path"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "outputs": [],
   "source": [
    "# f_path = \"/home/ehmatthes/books/alice.txt\"\n",
    "# \n",
    "# with open(f_path) as f_obj:\n",
    "#     lines = f_obj.readlines()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-22T06:28:21.652628Z",
     "start_time": "2024-03-22T06:28:21.651087Z"
    }
   },
   "execution_count": 145
  },
  {
   "cell_type": "markdown",
   "source": [
    "##### Opening a file on Windows\n",
    "Windows will sometimes interpret forward slashes incorrectly. If you run into this, use backslashes in your file paths."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "outputs": [],
   "source": [
    "# f_path = \"C:\\Users\\ehmatthes\\books\\alice.txt\"\n",
    "# \n",
    "# with open(f_path) as f_obj:\n",
    "#     lines = f_obj.readlines()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-22T06:28:21.691628Z",
     "start_time": "2024-03-22T06:28:21.689906Z"
    }
   },
   "execution_count": 146
  },
  {
   "cell_type": "markdown",
   "source": [
    "### The try-except block\n",
    "When you think an error may occur, you can write a try-except block to handle the exception that might be raised. The try block tells Python to try running some code, and the except block tells Python what to do if the code results in a particular kind of error."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "##### Handling the ZeroDivisionError exception"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You can't divide by zero!\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    print(5/0)\n",
    "except ZeroDivisionError:\n",
    "    print(\"You can't divide by zero!\")"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-22T06:28:21.702945Z",
     "start_time": "2024-03-22T06:28:21.700880Z"
    }
   },
   "execution_count": 147
  },
  {
   "cell_type": "markdown",
   "source": [
    "##### Handling the FileNotFoundError exception"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Can't find file secret.txt.\n"
     ]
    }
   ],
   "source": [
    "f_name = 'secret.txt'\n",
    "\n",
    "try:\n",
    "    with open(f_name) as f_obj:\n",
    "        lines = f_obj.readlines()\n",
    "except FileNotFoundError:\n",
    "    msg = \"Can't find file {0}.\".format(f_name)\n",
    "    print(msg)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-22T06:28:21.707199Z",
     "start_time": "2024-03-22T06:28:21.704853Z"
    }
   },
   "execution_count": 148
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Knowing which exception to handle\n",
    "It can be hard to know what kind of exception to handle when writing code. Try writing your code without a try block, and make it generate an error. The traceback will tell you what kind of exception your program needs to handle."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### The else block\n",
    "The try block should only contain code that may cause an error. Any code that depends on the try block running successfully should be placed in the else block."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "##### Using an else block"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter two numbers. I'll divide them.\n",
      "4.0\n"
     ]
    }
   ],
   "source": [
    "print(\"Enter two numbers. I'll divide them.\")\n",
    "\n",
    "x = input(\"First number: \")\n",
    "y = input(\"Second number: \")\n",
    "\n",
    "try:\n",
    "    result = int(x) / int(y)\n",
    "except ZeroDivisionError:\n",
    "    print(\"You can't divide by zero!\")\n",
    "else:\n",
    "    print(result)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-22T06:28:25.199733Z",
     "start_time": "2024-03-22T06:28:21.708762Z"
    }
   },
   "execution_count": 149
  },
  {
   "cell_type": "markdown",
   "source": [
    "##### Preventing crashes from user input\n",
    "Without the except block in the following example, the program would crash if the user tries to divide by zero. As written, it will handle the error gracefully and keep running"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter two numbers. I'll divide them.\n",
      "Enter 'q' to quit.\n",
      "You can't divide by zero!\n",
      "2.0\n"
     ]
    }
   ],
   "source": [
    "\"\"\"A simple calculator for division only.\"\"\"\n",
    "\n",
    "print(\"Enter two numbers. I'll divide them.\")\n",
    "print(\"Enter 'q' to quit.\")\n",
    "\n",
    "while True:\n",
    "    x = input(\"\\nFirst number: \")\n",
    "    if x == 'q':\n",
    "        break\n",
    "    y = input(\"Second number: \")\n",
    "    if y == 'q':\n",
    "        break\n",
    "        \n",
    "    try:\n",
    "        result = int(x) / int(y)\n",
    "    except ZeroDivisionError:\n",
    "        print(\"You can't divide by zero!\")\n",
    "    else:\n",
    "        print(result)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-22T06:28:33.859648Z",
     "start_time": "2024-03-22T06:28:25.202264Z"
    }
   },
   "execution_count": 150
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Deciding which errors to report\n",
    "Well-written, properly tested code is not very prone to internal errors such as syntax or logical errors. But every time your program depends on something external such as\n",
    "user input or the existence of a file, there's a possibility of an exception being raised.\n",
    "\n",
    "It's up to you how to communicate errors to your users. Sometimes users need to know if a file is missing; sometimes it's better to handle the error silently. A little\n",
    "experience will help you know how much to report."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Failing silently\n",
    "Sometimes you want your program to just continue running when it encounters an error, without reporting the error to the user. Using the pass statement in an else block allows you to do this."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "##### Using the pass statement in an else block"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "text_files/alice.txt has 2 lines.\n",
      "siddhartha.txt has 3 lines.\n"
     ]
    }
   ],
   "source": [
    "f_names = ['john.txt', 'text_files/alice.txt', 'siddhartha.txt', 'jane.txt']\n",
    "\n",
    "for f_name in f_names:\n",
    "    # Report the length of each file found.\n",
    "    try:\n",
    "        with open(f_name) as f_obj:\n",
    "            lines = f_obj.readlines()\n",
    "    except FileNotFoundError:\n",
    "        # Just move on to the next file.\n",
    "        pass\n",
    "    else:\n",
    "        num_lines = len(lines)\n",
    "        msg = \"{0} has {1} lines.\".format(f_name, num_lines)\n",
    "        print(msg)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-22T06:28:33.865712Z",
     "start_time": "2024-03-22T06:28:33.861177Z"
    }
   },
   "execution_count": 151
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Avoid bare except blocks\n",
    "Exception-handling code should catch specific exceptions that you expect to happen during your program's execution. A bare except block will catch all exceptions, including keyboard interrupts and system exits you might need when forcing a program to close.\n",
    "\n",
    "If you want to use a try block and you're not sure which exception to catch, use Exception. It will catch most exceptions, but still allow you to interrupt programs intentionally."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "##### Don’t use bare except blocks"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Done\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    # Do something\n",
    "    print(\"Done\")\n",
    "except:\n",
    "    pass"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-22T06:28:33.869313Z",
     "start_time": "2024-03-22T06:28:33.867386Z"
    }
   },
   "execution_count": 152
  },
  {
   "cell_type": "markdown",
   "source": [
    "##### Use Exception instead"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Done\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    # Do something\n",
    "    print(\"Done\")\n",
    "except Exception:\n",
    "    pass"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-22T06:28:33.873259Z",
     "start_time": "2024-03-22T06:28:33.870874Z"
    }
   },
   "execution_count": 153
  },
  {
   "cell_type": "markdown",
   "source": [
    "##### Printing the exception"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "division by zero <class 'ZeroDivisionError'>\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    # Do something\n",
    "    print(1/0)\n",
    "except Exception as e:\n",
    "    print(e, type(e))"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-22T06:28:33.877506Z",
     "start_time": "2024-03-22T06:28:33.874483Z"
    }
   },
   "execution_count": 154
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Storing data with json\n",
    "The json module allows you to dump simple Python data structures into a file, and load the data from that file the next time the program runs. The JSON data format is not\n",
    "specific to Python, so you can share this kind of data with people who work in other languages as well.\n",
    "\n",
    "Knowing how to manage exceptions is important when working with stored data. You'll usually want to make sure the data you're trying to load exists before working with it."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "##### Using json.dump() to store data"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "outputs": [],
   "source": [
    "\"\"\"Store some numbers.\"\"\"\n",
    "\n",
    "import json\n",
    "\n",
    "numbers = [2, 3, 5, 7, 11, 13]\n",
    "\n",
    "filename = 'numbers.json'\n",
    "with open(filename, 'w') as f_obj:\n",
    "    json.dump(numbers, f_obj)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-22T06:28:33.880984Z",
     "start_time": "2024-03-22T06:28:33.878430Z"
    }
   },
   "execution_count": 155
  },
  {
   "cell_type": "markdown",
   "source": [
    "##### Using json.load() to read data"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 5, 7, 11, 13]\n"
     ]
    }
   ],
   "source": [
    "\"\"\"Load some previously stored numbers.\"\"\"\n",
    "\n",
    "import json\n",
    "\n",
    "filename = 'numbers.json'\n",
    "with open(filename) as f_obj:\n",
    "    numbers = json.load(f_obj)\n",
    "    \n",
    "print(numbers)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-22T06:28:33.883896Z",
     "start_time": "2024-03-22T06:28:33.881750Z"
    }
   },
   "execution_count": 156
  },
  {
   "cell_type": "markdown",
   "source": [
    "##### Making sure the stored data exists"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 5, 7, 11, 13]\n"
     ]
    }
   ],
   "source": [
    "import json\n",
    "\n",
    "f_name = 'numbers.json'\n",
    "\n",
    "try:\n",
    "    with open(f_name) as f_obj:\n",
    "        numbers = json.load(f_obj)\n",
    "except FileNotFoundError:\n",
    "    msg = \"Can’t find {0}.\".format(f_name)\n",
    "    print(msg)\n",
    "else:\n",
    "    print(numbers)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-22T06:28:33.886917Z",
     "start_time": "2024-03-22T06:28:33.884560Z"
    }
   },
   "execution_count": 157
  },
  {
   "cell_type": "markdown",
   "source": [
    "##### Practice with exceptions\n",
    "Take a program you've already written that prompts for user input, and add some error-handling code to the program."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "##### Notebook created by [Sujeevan Nagarajah](https://github.com/sujee81)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "outputs": [],
   "source": [],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-22T06:28:33.889705Z",
     "start_time": "2024-03-22T06:28:33.888499Z"
    }
   },
   "execution_count": 157
  }
 ],
 "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}