06 - Python Exceptions

Python Exceptions

Built in Exception hierarchy

In Python, exceptions act as predefined responses to unforeseen errors during code execution. This enables graceful management: we can customize functions to automatically detect and respond to errors, enhancing code stability.

How to use the BaseException Function

The BaseException is a generic, catch-all error exception in Python, returning whatever error occurred.

Example:

def division_function(a, b):
  try:
    value = int(a / b)
    return(value)
  except BaseException as e:
    return(f"The following error occurred: {e}")

This example will catch and report division by zero, invalid input, and other errors.

The Exception class in Python

While the BaseException is atop the Python Exception Hierarchy, the Exception class is typically used instead of it. That's because the BaseException interferes with system-exiting exceptions, such as SystemExit and KeyboardInterrupt.

From a coding standpoint use of the Exception class is the same.

SystemExit Exception

System Exit is a Python exception that signifies the interpreter should stop gracefully. It's usually left unhandled to let Python close smoothly. To use it, call the sys.exit method, which triggers the SystemExit exception.

Example:

import sys
import time

def run_theme_part():
  try:
    print("The theme park will close in 5 seconds....")
    time.sleep(5)
    sys.exit() # This triggers the system exit exception
  except SystemExit:

KeyboardInterrupt Exception

KeyboardInterrupt is a built-in Python exception that is raised when a user interrupts a program, typically by pressing Ctrl+C. It provides control for users to pause or halt a process, vital for scenarios requiring immediate human intervention. Use the raise keyword to trigger the exception.

Example:

def run_theme_park_ride():
  try:
    while True:
      user_input = input("Type 'stop' to stop the ride: ")
      if user_input.lower() == "stop":
        raise KeyboardInterrupt
  except KeyboardInterrupt:
    print("You stopped the ride!")

Abstract Exceptions

Abstract exceptions or parent exceptions serve as fundamental guidelines for developing specific error types in Python coding.

• Purpose:
  • They provide a foundational framework for more detailed error classes.
• Usage:
  • Abstract exceptions aren't usually triggered by themselves. This can handle several related exceptions.

Some examples of abstract exceptions and related specific types:

• ArithmeticError:
  • Deals with numeric calculation issues.
• LookupError:
  • Occurs when accessing non-existent items such as indices or dictionary keys. LookupError is a common base class where the specific subclasses are IndexError and KeyError.
• IndexError:
  • Occurs when an index is not found in a sequence.
• KeyError:
  • Happens when accessing a missing key in a dictionary or mapping.

ArithmeticError Exception

ArithmeticError is a built-in Python base exception class. The specific subclasses for ArithmeticError include ZeroDivisionError, OverflowError and FloatingPointError.

Zero Division Error: Occurs when attempting to divide a number by zero.

try:
result = 10 / 0
except ZeroDivisionError as e:
print(f"ZeroDivisionError: {e}")

Overflow Error: Happens when calculations exceed a system's storage limitation, causing an incorrect result.

try:
result = math.exp(1000)
except OverflowError as e:
print(f"OverflowError: {e}")

Floating Point Error: Arises when Python performs a calculation using decimal (floating-point) numbers and the result is not mathematically possible or cannot be represented precisely in memory.

LookupError Exception

LookupError is a general base class error in Python indicating the inability to find an anticipated item. It triggers when accessing an index that does not exist inside a dictionary.

Exceptions Under LookupError:

• IndexError:
  • Raised when an attempt to access an index that doesn't exist in a list.
• KeyError:
  • Raised when trying to access a dictionary key that isn't present.

IndexError Exception