Python - Exceptions

Exceptions in Python

Introduction

In Python, an exception is an event that occurs during the execution of a program and disrupts its normal flow. Exception handling is an essential part of robust software development. Python provides powerful tools to handle exceptions gracefully and ensure programs continue or terminate cleanly without crashing abruptly.

This document covers various aspects of Python exceptions including built-in exceptions, custom exceptions, the try-except block, else and finally clauses, nested exceptions, exception propagation, exception hierarchy, and best practices.

What is an Exception?

An exception is an error that occurs at runtime, not at compilation. When an error occurs, Python creates an object representing that error and stops the current execution flow unless handled explicitly. If not handled, the program crashes and displays an error traceback.

print(10 / 0)  # Raises ZeroDivisionError

Types of Errors

1. Syntax Errors

Detected at compile-time (before execution). These are errors in code syntax.

if True
    print("Missing colon")

2. Exceptions (Runtime Errors)

These occur during execution. Python stops execution and raises an exception object.

int("abc")  # Raises ValueError

Common Built-in Exceptions

• ZeroDivisionError – Division by zero.
• ValueError – Invalid value.
• TypeError – Invalid operation on data types.
• IndexError – Index out of range in lists or sequences.
• KeyError – Accessing non-existent dictionary key.
• FileNotFoundError – File not found on disk.
• AttributeError – Calling a non-existing attribute.
• ImportError – Issues with importing a module.
• IndentationError – Incorrect indentation.

Basic Exception Handling Using try-except

Syntax

try:
    # Code that might raise an exception
except ExceptionType:
    # Handling code

Example

try:
    result = 10 / 0
except ZeroDivisionError:
    print("You cannot divide by zero!")

Handling Multiple Exceptions

Example

try:
    num = int(input("Enter a number: "))
    result = 100 / num
except ValueError:
    print("Invalid input, not an integer.")
except ZeroDivisionError:
    print("Division by zero is not allowed.")

Using Else Clause

The else block is executed if no exception is raised.

try:
    value = int(input("Enter a number: "))
except ValueError:
    print("Invalid input.")
else:
    print("Valid input:", value)

Using Finally Clause

The finally block always executes, whether an exception is raised or not. It's useful for cleanup actions like closing files or releasing resources.

try:
    file = open("demo.txt", "r")
    content = file.read()
except FileNotFoundError:
    print("File not found.")
finally:
    print("Executing finally block")
    if 'file' in locals():
        file.close()

Nested try-except Blocks

Example

try:
    try:
        print(10 / 0)
    except ZeroDivisionError:
        print("Handled inner division error.")
except:
    print("Handled outer error.")

Raising Exceptions

Using raise

You can raise exceptions manually using the raise keyword.

def set_age(age):
    if age < 0:
        raise ValueError("Age cannot be negative")
    print("Age is valid.")

set_age(-5)  # Raises ValueError

Creating Custom Exceptions

Why Create Custom Exceptions?

Built-in exceptions may not cover all error scenarios in your application. Custom exceptions let you define application-specific errors.

How to Create

class MyCustomError(Exception):
    pass

raise MyCustomError("A custom error occurred")

Example with Class Inheritance

class InvalidInputError(Exception):
    def __init__(self, message):
        self.message = message
        super().__init__(self.message)

try:
    raise InvalidInputError("Invalid input provided!")
except InvalidInputError as e:
    print("Error:", e.message)

Exception Object and Arguments

Accessing Exception Info

try:
    1 / 0
except ZeroDivisionError as e:
    print("Exception:", e)

Using sys.exc_info()

import sys

try:
    raise ValueError("Invalid value!")
except:
    exc_type, exc_value, exc_traceback = sys.exc_info()
    print("Type:", exc_type)
    print("Value:", exc_value)

Exception Chaining

Using from keyword

try:
    raise KeyError("Key missing")
except KeyError as e:
    raise ValueError("Incorrect value") from e

Built-in Exception Hierarchy

• BaseException
  • SystemExit
  • KeyboardInterrupt
  • Exception
    • ArithmeticError
      • ZeroDivisionError
    • LookupError
      • IndexError
      • KeyError
    • ValueError
    • TypeError
    • ImportError

Suppressing Exceptions with contextlib

from contextlib import suppress

with suppress(FileNotFoundError):
    open("missing_file.txt")

Logging Exceptions

Using logging Module

import logging

logging.basicConfig(filename="error.log", level=logging.ERROR)

try:
    1 / 0
except ZeroDivisionError as e:
    logging.error("Exception occurred", exc_info=True)

Best Practices for Exception Handling

• Catch specific exceptions, not generic ones.
• Use finally for cleanup (closing files, connections).
• Don't use bare except unless absolutely necessary.
• Raise exceptions where appropriate to maintain control flow.
• Document exceptions using docstrings.
• Use custom exceptions for application-specific logic.

Use Case: File Handling with Exception Safety

def read_file(file_name):
    try:
        with open(file_name, "r") as f:
            return f.read()
    except FileNotFoundError:
        return "File not found."
    except IOError:
        return "I/O error occurred"

Use Case: User Input Validation

def get_positive_number():
    while True:
        try:
            num = int(input("Enter a positive number: "))
            if num <= 0:
                raise ValueError("Number must be positive.")
            return num
        except ValueError as e:
            print("Error:", e)

print("You entered:", get_positive_number())

Exception handling in Python is a powerful feature that allows developers to handle unexpected situations gracefully and ensure program stability. By understanding how to use try-except blocks, else and finally clauses, raise custom exceptions, and follow best practices, you can write more robust and maintainable Python code.

Proper exception management not only improves code readability but also aids in debugging, error logging, and better application design. With great tools and flexibility offered by Python’s exception framework, mastering this area is essential for any serious Python developer.