Python - Exception Handling

In any programming language, there are two types of errors possible.

1. Syntax Errors
2. Runtime Errors

The errors which occur because of invalid syntax are called Syntax Errors.

Here are two common examples:

Python 2 print syntax — shown for comparison, not runnable here.

print "Hello"

In the first example, the if statement is missing the colon (:).

In the second example, the print() function is called without parentheses, which is Python 2 syntax.

Because the syntax is incorrect, Python raises a SyntaxError before executing the program.

The programmer is responsible for correcting syntax errors.

Only after all syntax errors are corrected will program execution start.

Runtime Errors are also known as Exceptions.

While executing the program, if something goes wrong because of:

• End user input
• Programming logic
• Memory problems
• etc.

then we will get Runtime Errors.

If the user enters ten instead of a number:

Division by zero raises a ZeroDivisionError, dividing by an incompatible type raises a TypeError, and passing a non-numeric value to int() raises a ValueError.

The Exception Handling concept is applicable only for Runtime Errors.

It is not applicable for Syntax Errors.

An unwanted and unexpected event that disturbs the normal flow of the program is called an Exception.

Examples of exceptions:

• ZeroDivisionError
• TypeError
• ValueError
• FileNotFoundError
• EOFError

It is highly recommended to handle exceptions.

The main objective of Exception Handling is Graceful Termination of the program.

Exception Handling does not mean repairing the exception. We have to define an alternative way to continue the remaining part of the program normally.

Suppose our programming requirement is to read data from a remote file located in London.

If, at runtime, the London file is not available, then the program should not terminate abnormally.

Instead, we should provide a local file and continue the remaining program normally.

• The risky code is placed inside the try block.
• If the remote file is not available, a FileNotFoundError occurs.
• The except block provides an alternative solution by using the local file.
• The remaining program continues normally instead of terminating abnormally.

Every exception in Python is an object, and for every exception type, the corresponding exception class is already available.

Whenever an exception occurs, the PVM (Python Virtual Machine) creates the corresponding exception object and checks whether exception handling code is available.

• If handling code is available, the exception is handled and the program continues normally.
• If handling code is not available, the Python Interpreter terminates the program abnormally, prints the exception information on the console, and the remaining statements are not executed.

Program Starts
       │
       ▼
Execute Statements
       │
       ▼
Exception Occurs
       │
       ▼
PVM Creates Exception Object
       │
       ▼
Search for Handling Code
       │
 ┌─────┴─────────┐
 │               │
 ▼               ▼
Handling      No Handling
Available       Code
 │               │
 ▼               ▼
Execute      Abnormal
Handling     Termination
Code             │
 │               ▼
 ▼        Print Exception
Continue     Information
Program
      

1. print("Hello") executes successfully and prints Hello.
2. print(10/0) raises a ZeroDivisionError. The PVM creates a ZeroDivisionError object and searches for handling code, but none is available.
3. The Python Interpreter terminates the program abnormally and prints the exception information.
4. print("Hi") is never executed.

Whenever an exception occurs, the Python Virtual Machine creates the corresponding exception object:

10 / 0

↓

ZeroDivisionError Object

For every exception type, Python already provides a corresponding exception class:

Every exception in Python is a class, and all exception classes are child classes of BaseException — either directly or indirectly.

Hence, BaseException acts as the root class of the Python Exception Hierarchy.

BaseException
│
├── Exception
│   │
│   ├── ArithmeticError
│   │   ├── ZeroDivisionError
│   │   ├── FloatingPointError
│   │   └── OverflowError
│   │
│   ├── AttributeError
│   │
│   ├── EOFError
│   │
│   ├── NameError
│   │
│   ├── LookupError
│   │   ├── IndexError
│   │   └── KeyError
│   │
│   ├── OSError
│   │   ├── FileNotFoundError
│   │   ├── InterruptedError
│   │   ├── PermissionError
│   │   └── TimeoutError
│   │
│   ├── TypeError
│   │
│   └── ValueError
│
├── SystemExit
├── GeneratorExit
└── KeyboardInterrupt
      

Most of the time, as a programmer, we concentrate on the Exception class and its child classes:

• Exception is the parent class for most runtime exceptions.
• ArithmeticError covers arithmetic-related errors. Its child ZeroDivisionError is raised by print(10/0).
• LookupError covers lookup-related errors. Its children IndexError (list index out of range) and KeyError are common.
• OSError covers operating-system-related errors. Its child FileNotFoundError is raised when a file is missing.

Apart from the Exception class, BaseException also contains the following direct child classes:

• SystemExit
• GeneratorExit
• KeyboardInterrupt

These classes are not commonly used for normal application-level exception handling.