Exceptional handling file-1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Modules and Packages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Modules in Python are simply Python files with the .py extension, which implement a set of functions. Modules are imported from other modules using the import command. Before you go ahead and import modules, check out the full list of built-in modules in the Python Standard library.\n",
    "\n",
    "When a module is loaded into a running script for the first time, it is initialized by executing the code in the module once. If another module in your code imports the same module again, it will not be loaded twice but once only - so local variables inside the module act as a \"singleton\" - they are initialized only once.\n",
    "\n",
    "If we want to import module math,  we simply import the module:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# import the library\n",
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# use it (ceiling rounding)\n",
    "math.ceil(2.4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exploring built-in modules\n",
    "\n",
    "While exploring modules in Python, two important functions come in handy - the dir and help functions. dir functions show which functions are implemented in each module. Let us see the below example and understand better."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc']\n"
     ]
    }
   ],
   "source": [
    "print(dir(math))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we find the function in the module we want to use, we can read about it more using the help function, inside the Python interpreter:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function ceil in module math:\n",
      "\n",
      "ceil(...)\n",
      "    ceil(x)\n",
      "    \n",
      "    Return the ceiling of x as an Integral.\n",
      "    This is the smallest integer >= x.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(math.ceil)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Writing modules\n",
    "Writing Python modules is very simple. To create a module of your own, simply create a new .py file with the module name, and then import it using the Python file name (without the .py extension) using the import command.\n",
    "\n",
    "## Writing packages\n",
    "Packages are name-spaces which contain multiple packages and modules themselves. They are simply directories, but with a twist.\n",
    "\n",
    "The twist is, each package in Python is a directory which MUST contain a special file called **\\__init\\__.py**. This file can be empty, and it indicates that the directory it contains is a Python package, so it can be imported the same way a module can be imported.\n",
    "\n",
    "If we create a directory called foo, which marks the package name, we can then create a module inside that package called bar. We also must not forget to add the **\\__init\\__.py** file inside the foo directory.\n",
    "\n",
    "To use the module bar, we can import it in two ways:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Just an example, this won't work\n",
    "import foo.bar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# OR could do it this way\n",
    "from foo import bar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the first method, we must use the foo prefix whenever we access the module bar. In the second method, we don't, because we import the module to our module's name-space.\n",
    "\n",
    "The **\\__init\\__.py** file can also decide which modules the package exports as the API, while keeping other modules internal, by overriding the **\\__all\\__** variable, like so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "__init__.py:\n",
    "\n",
    "__all__ = [\"bar\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Errors and Exception Handling\n",
    "\n",
    "In this section, we will learn about Errors and Exception Handling in Python. You've might have definitely encountered errors by this point in the course. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "EOL while scanning string literal (<ipython-input-1-db8c9988558c>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-1-db8c9988558c>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    print('Hello)\u001b[0m\n\u001b[0m                 ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m EOL while scanning string literal\n"
     ]
    }
   ],
   "source": [
    "print('Hello)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note how we get a SyntaxError, with the further description that it was an End of Line Error (EOL) while scanning the string literal. This is specific enough for us to see that we forgot a single quote at the end of the line. Understanding of these various error types will help you debug your code much faster. \n",
    "\n",
    "This type of error and description is known as an Exception. Even if a statement or expression is syntactically correct, it may cause an error when an attempt is made to execute it. Errors detected during execution are called exceptions and are not unconditionally fatal.\n",
    "\n",
    "You can check out the full list of built-in exceptions [here](https://docs.python.org/2/library/exceptions.html). Now, let's learn how to handle errors and exceptions in our own code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## try and except\n",
    "\n",
    "The basic terminology and syntax used to handle errors in Python is the **try** and **except** statements. The code which can cause an exception to occur is put in the *try* block and the handling of the exception are the implemented in the *except* block of code. The syntax form is:\n",
    "\n",
    "    try:\n",
    "       You do your operations here...\n",
    "       ...\n",
    "    except ExceptionI:\n",
    "       If there is ExceptionI, then execute this block.\n",
    "    except ExceptionII:\n",
    "       If there is ExceptionII, then execute this block.\n",
    "       ...\n",
    "    else:\n",
    "       If there is no exception then execute this block. \n",
    "\n",
    "Using just except, we can check for any exception: To understand better let's check out a sample code that opens and writes a file:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Content written successfully\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    f = open('testfile','w')\n",
    "    f.write('Test write this')\n",
    "except IOError:\n",
    "    # This will only check for an IOError exception and then execute this print statement\n",
    "   print(\"Error: Could not find file or read data\")\n",
    "else:\n",
    "   print(\"Content written successfully\")\n",
    "   f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's see what happens when we don't have write permission? (opening only with 'r'):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "ename": "UnsupportedOperation",
     "evalue": "not writable",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mUnsupportedOperation\u001b[0m                      Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-5-7498bff3140a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mf\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'testfile'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m'r'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwrite\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Test write this'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"fsfsfsfsf\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mUnsupportedOperation\u001b[0m: not writable"
     ]
    }
   ],
   "source": [
    "f = open('testfile','r')\n",
    "f.write('Test write this')\n",
    "print(\"fsfsfsfsf\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error: Could not find file or read data\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    f = open('testfile','r')\n",
    "    f.write('Test write this')\n",
    "except IOError:\n",
    "    # This will only check for an IOError exception and then execute this print statement\n",
    "   print(\"Error: Could not find file or read data\")\n",
    "else:\n",
    "   print(\"Content written successfully\")\n",
    "   f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice, how we only printed a statement! The code still ran and we were able to continue doing actions and running code blocks. This is extremely useful when you have to account for possible input errors in your code. You can be prepared for the error and keep running code, instead of your code just breaking as we saw above.\n",
    "\n",
    "We could have also just said except: if we weren't sure what exception would occur. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error: Could not find file or read data\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    f = open('testfile','r')\n",
    "    f.write('Test write this')\n",
    "except:\n",
    "    # This will check for any exception and then execute this print statement\n",
    "   print(\"Error: Could not find file or read data\")\n",
    "else:\n",
    "   print(\"Content written successfully\")\n",
    "   f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we don't actually need to memorize the list of exception types! Now what if we keep wanting to run code after the exception occurred? This is where **finally** comes in.\n",
    "##finally\n",
    "The finally: Block of code will always be run regardless if there was an exception in the try code block. The syntax is:\n",
    "\n",
    "    try:\n",
    "       Code block here\n",
    "       ...\n",
    "       Due to any exception, this code may be skipped!\n",
    "    finally:\n",
    "       This code block would always be executed.\n",
    "\n",
    "For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Always execute finally code blocks\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "   f = open(\"testfile\", \"w\")\n",
    "   f.write(\"Test write statement\")\n",
    "finally:\n",
    "   print(\"Always execute finally code blocks\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use this in conjunction with except. Let's see a new example that will take into account a user putting in the wrong input:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def askint():\n",
    "        try:\n",
    "            val = int(input(\"Please enter an integer: \"))\n",
    "        except:\n",
    "            print(\"Looks like you did not enter an integer!\")\n",
    "            \n",
    "        finally:\n",
    "            print(\"Finally, I executed!\")\n",
    "        print(val)       "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please enter an integer: 43\n",
      "Finally, I executed!\n",
      "43\n"
     ]
    }
   ],
   "source": [
    "askint()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please enter an integer: five\n",
      "Looks like you did not enter an integer!\n",
      "Finally, I executed!\n"
     ]
    },
    {
     "ename": "UnboundLocalError",
     "evalue": "local variable 'val' referenced before assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mUnboundLocalError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-22-6ee53d339e7e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0maskint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-20-5d8fc6d41fa3>\u001b[0m in \u001b[0;36maskint\u001b[0;34m()\u001b[0m\n\u001b[1;32m      7\u001b[0m         \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      8\u001b[0m             \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Finally, I executed!\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m         \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mval\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mUnboundLocalError\u001b[0m: local variable 'val' referenced before assignment"
     ]
    }
   ],
   "source": [
    "askint()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check how we got an error when trying to print val (because it was properly assigned). Let's find the right solution by asking the user and checking to make sure the input type is an integer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def askint():\n",
    "        try:\n",
    "            val = int(input(\"Please enter an integer: \"))\n",
    "        except:\n",
    "            print(\"Looks like you did not enter an integer!\")\n",
    "            try:\n",
    "                val = int(input(\"Try again-Please enter an integer: \"))\n",
    "            except:\n",
    "                print(\"handle it \")\n",
    "        finally:\n",
    "            print(\"Finally, I executed!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please enter an integer: fdgd\n",
      "Looks like you did not enter an integer!\n",
      "Try again-Please enter an integer: hgh\n",
      "handle it \n",
      "Finally, I executed!\n"
     ]
    }
   ],
   "source": [
    "askint()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hmmm...that only did one check. How can we continually keep checking? We can use a while loop!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "def askint():\n",
    "    while True:\n",
    "        try:\n",
    "            val = int(input(\"Please enter an integer: \"))\n",
    "        except:\n",
    "            print(\"Looks like you did not enter an integer!\")\n",
    "            break\n",
    "        else:\n",
    "            print('Yep thats an integer!')\n",
    "            break\n",
    "        finally:\n",
    "            print(\"Finally, I executed!\")\n",
    "            print(val) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please enter an integer: ytt\n",
      "Looks like you did not enter an integer!\n",
      "Finally, I executed!\n"
     ]
    },
    {
     "ename": "UnboundLocalError",
     "evalue": "local variable 'val' referenced before assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mUnboundLocalError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-38-cc291aa76c10>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0maskint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-37-9682f0bcb1dc>\u001b[0m in \u001b[0;36maskint\u001b[0;34m()\u001b[0m\n\u001b[1;32m     11\u001b[0m         \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     12\u001b[0m             \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Finally, I executed!\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 13\u001b[0;31m             \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mval\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mUnboundLocalError\u001b[0m: local variable 'val' referenced before assignment"
     ]
    }
   ],
   "source": [
    "askint()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Database connectivity and operations using Python.\n",
    "\n",
    "For Example, the following is the example of connecting with MySQL database \"my_database1\" and creating table grades1 and inserting values inside it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<sqlite3.Cursor at 0x1112e57a0>"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#!/usr/bin/python\n",
    "\n",
    "import sqlite3\n",
    "#connecting with the database.\n",
    "db = sqlite3.connect(\"my_database3.db\")\n",
    "# Drop table if it already exist using execute() method.\n",
    "db.execute(\"drop table if exists grades1\")\n",
    "# Create table as per requirement\n",
    "db.execute(\"create table grades1(id int, name text, score int)\")\n",
    "#inserting values inside the created table\n",
    "db.execute(\"insert into grades1(id, name, score) values(101, 'John',99 )\")\n",
    "db.execute(\"insert into grades1(id, name, score) values(102, 'Gary',90 )\")\n",
    "db.execute(\"insert into grades1(id, name, score) values(103, 'James', 80 )\")\n",
    "db.execute(\"insert into grades1(id, name, score) values(104, 'Cathy', 85 )\")\n",
    "db.execute(\"insert into grades1(id, name, score) values(105, 'Kris',95 )\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "db.commit()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(101, 'John', 99)\n",
      "(102, 'Gary', 90)\n",
      "(103, 'James', 80)\n",
      "(104, 'Cathy', 85)\n",
      "(105, 'Kris', 95)\n",
      "------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "results = db.execute(\"select * from grades1 order by id\")\n",
    "for row in results:\n",
    "    print(row)\n",
    "print(\"-\" * 60 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(102, 'Gary', 90)\n",
      "------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "results = db.execute(\"select * from grades1 where name = 'Gary' \")\n",
    "for row in results: print(row)\n",
    "print(\"-\" * 60 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(101, 'John', 99)\n",
      "(102, 'Gary', 90)\n",
      "(105, 'Kris', 95)\n",
      "------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "results = db.execute(\"select * from grades1 where score >= 90 \")\n",
    "for row in results:\n",
    "    print(row)\n",
    "print(\"-\" * 60 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('John', 99)\n",
      "('Kris', 95)\n",
      "('Gary', 90)\n",
      "('Cathy', 85)\n",
      "('James', 80)\n",
      "------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "results = db.execute(\"select name, score from grades1 order by score desc \")\n",
    "for row in results:\n",
    "    print(row)\n",
    "print(\"-\" * 60 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('James', 80)\n",
      "('Cathy', 85)\n",
      "('Gary', 90)\n",
      "('Kris', 95)\n",
      "('John', 99)\n",
      "------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "results = db.execute(\"select name, score from grades1 order by score\")\n",
    "for row in results:\n",
    "    print(row)\n",
    "print(\"-\" * 60 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('James', 80)\n",
      "('Cathy', 85)\n",
      "('Gary', 90)\n",
      "('Kris', 95)\n",
      "('John', 99)\n"
     ]
    }
   ],
   "source": [
    "results = db.execute(\"select name, score from grades1 order by score\")\n",
    "for row in results:\n",
    "    print(row)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "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.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}