Exception Handling & Data Handling

In real-world applications, systems must be robust against failures. Exception Handling allows you to gracefully recover from runtime errors. Furthermore, backend applications frequently exchange and process data stored in Text, CSV, and JSON formats.

Topics Covered

In this module, you’ll learn:

Exception Handling: The try-except-else-finally block.
Custom Exceptions: Inheriting from the base Exception class for domain-specific errors.
Data Handling (File I/O)

Try Yourself: 💻 VS Code | 🚀 Colab | 📥 Download
Verify Solutions: 💻 VS Code | 🚀 Colab | 📥 Download

1. Exception Handling

An exception is an error that occurs during the execution of a program. If not handled, the program will terminate abruptly (crash). Exception handling allows you to catch these errors and respond gracefully.

The `try-except-else-finally` Block

try:
    # Code that might raise an exception
    num = int(input("Enter a number: "))
    result = 100 / num
except ZeroDivisionError:
    # Runs only if ZeroDivisionError occurs
    print("Error: You cannot divide by zero!")
except ValueError:
    # Runs only if ValueError occurs (e.g. invalid string input)
    print("Error: Please enter a valid integer!")
else:
    # Runs only if NO exceptions were raised in the try block
    print(f"Success! Result is {result}")
finally:
    # Always runs, regardless of whether an exception occurred
    print("Execution of block completed.")

Raising Exceptions (`raise`)

You can trigger exceptions intentionally in your code using the raise keyword.

def check_positive(value):
    if value < 0:
        raise ValueError("Negative values are not allowed!")
    return value

Exercise 1

Write a function safe_divide(a, b) that performs division. If a ZeroDivisionError or TypeError occurs, catch it and return None along with a descriptive print message.

Solution

def safe_divide(a, b):
    try:
        return a / b
    except ZeroDivisionError:
        print("Warning: Division by zero attempted!")
        return None
    except TypeError:
        print("Warning: Division requires numeric values!")
        return None

print(safe_divide(10, 0))
print(safe_divide(10, "two"))

2. Custom Exceptions

When building complex applications (like APIs), Python’s built-in exceptions (like ValueError or KeyError) might not be expressive enough. You can create your own custom exceptions by inheriting from the base Exception class.

class InsufficientFundsError(Exception):
    """Exception raised when an account balance is too low for a transaction."""
    def __init__(self, balance, amount):
        self.balance = balance
        self.amount = amount
        super().__init__(f"Attempted to withdraw ${amount} but balance is only ${balance}.")

# Using the Custom Exception
def withdraw(balance, amount):
    if amount > balance:
        raise InsufficientFundsError(balance, amount)
    return balance - amount

try:
    withdraw(50, 100)
except InsufficientFundsError as e:
    print(f"Transaction Declined: {e}")

Exercise 2

Define a custom exception InvalidAgeError. Write a function verify_age(age) that raises this exception with the message "Age must be between 0 and 120" if the age is outside this range.

Solution

class InvalidAgeError(Exception):
    pass

def verify_age(age):
    if age < 0 or age > 120:
        raise InvalidAgeError("Age must be between 0 and 120")
    print(f"Age {age} is valid.")

try:
    verify_age(150)
except InvalidAgeError as e:
    print("Error caught:", e)

3. Data Handling (File I/O)

Backend services constantly read configurations, import CSV logs, or exchange JSON payloads.

Text Files

Always use the context manager (with statement) when working with files. It ensures that the file is closed automatically after execution, preventing memory leaks.

# Writing to a text file
with open("note.txt", "w") as file:
    file.write("Hello World!\nWelcome to data handling.")

# Reading from a text file
with open("note.txt", "r") as file:
    content = file.read()
    print(content)

CSV Data (Comma Separated Values)

Python’s built-in csv module provides simple utilities to read and write rows of tabular data.

Writing CSV

import csv

data = [
    ["Name", "Age", "Role"],
    ["Alice", 25, "Developer"],
    ["Bob", 30, "Manager"]
]

with open("users.csv", "w", newline="") as file:
    writer = csv.writer(file)
    writer.writerows(data)

Reading CSV

import csv

with open("users.csv", "r") as file:
    reader = csv.reader(file)
    for row in reader:
        print(row)  # row is a list of strings

Reading CSV as Dictionaries (`DictReader`)

DictReader maps the header row to keys, turning each row into a dictionary.

import csv

with open("users.csv", "r") as file:
    reader = csv.DictReader(file)
    for row in reader:
        print(row["Name"], "is a", row["Role"])

JSON Data (JavaScript Object Notation)

JSON (JavaScript Object Notation) is a lightweight, text-based data interchange format. It is the standard format for exchanging data in modern web APIs because it is easy for both humans to read and machines to parse.

JSON Data Types & Type Mapping

JSON supports a limited set of data types. When you load a JSON payload into Python or convert Python objects to JSON, Python handles the conversions automatically based on the following type mapping:

Python Type	JSON equivalent	Example
`dict`	`object`	`{"name": "Alice", "role": "admin"}`
`list`, `tuple`	`array`	`[1, 2, "three"]`
`str`	`string`	`"hello"`
`int`, `float`	`number`	`42` or `3.14`
`True`	`true`	`true`
`False`	`false`	`false`
`None`	`null`	`null`

Python’s built-in json module provides four primary functions to translate between these types:

json.dumps() / json.loads(): Convert between Python objects and JSON strings.
json.dump() / json.load(): Read and write JSON files.

import json

student = {
    "name": "Alice",
    "age": 25,
    "courses": ["Python", "FastAPI"]
}

# 1. Convert Dict to JSON String (Serialization)
json_string = json.dumps(student, indent=2)
print("JSON String:\n", json_string)

# 2. Convert JSON String to Dict (Deserialization)
parsed_dict = json.loads(json_string)
print("Parsed age:", parsed_dict["age"])

# 3. Writing to a JSON File
with open("data.json", "w") as file:
    json.dump(student, file, indent=4)

# 4. Reading from a JSON File
with open("data.json", "r") as file:
    loaded_data = json.load(file)
    print("Loaded Name:", loaded_data["name"])

Exercise 3

Create a JSON file named config.json containing {"debug": true, "version": "1.0"}. Write a Python script to read this file, set "debug" to false, add a new key "updated": true, and save it back to the file.

Solution

import json

# Setup starting file
initial_data = {"debug": True, "version": "1.0"}
with open("config.json", "w") as file:
    json.dump(initial_data, file)

# Read, modify, and write back
with open("config.json", "r") as file:
    config = json.load(file)

config["debug"] = False
config["updated"] = True

with open("config.json", "w") as file:
    json.dump(config, file, indent=4)

# Verify
with open("config.json", "r") as file:
    print(file.read())

Practice

To reinforce what you’ve learned in this section, practice with the interactive follow-along notebook:

Follow-Along Practice

Practice exception handling (try-except-else-finally), raising custom exceptions, and reading/writing text, CSV, and JSON files.💻 VS Code | 🚀 Colab | 📥 Download

Summary

In this module, you learned how to handle runtime errors using try-except blocks, build custom exceptions to represent business logic failures, and parse/generate files in Text, CSV, and JSON formats.

Adv. Python & FastAPI Workshop

06b-Exceptions & Data Handling

Exception Handling & Data Handling

Topics Covered

1. Exception Handling

The `try-except-else-finally` Block

Raising Exceptions (`raise`)

Exercise 1

2. Custom Exceptions

Exercise 2

3. Data Handling (File I/O)

Text Files

CSV Data (Comma Separated Values)

Writing CSV

Reading CSV

Reading CSV as Dictionaries (`DictReader`)

JSON Data (JavaScript Object Notation)

JSON Data Types & Type Mapping

Exercise 3

Practice

Follow-Along Practice

Summary

​Exception Handling & Data Handling

​Topics Covered

​1. Exception Handling

​The try-except-else-finally Block

​Raising Exceptions (raise)

​Exercise 1

​2. Custom Exceptions

​Exercise 2

​3. Data Handling (File I/O)

​Text Files

​CSV Data (Comma Separated Values)

​Writing CSV

​Reading CSV

​Reading CSV as Dictionaries (DictReader)

​JSON Data (JavaScript Object Notation)

​JSON Data Types & Type Mapping

​Exercise 3

​Practice

Follow-Along Practice

​Summary

Exception Handling & Data Handling

Topics Covered

1. Exception Handling

The `try-except-else-finally` Block

Raising Exceptions (`raise`)

Exercise 1

2. Custom Exceptions

Exercise 2

3. Data Handling (File I/O)

Text Files

CSV Data (Comma Separated Values)

Writing CSV

Reading CSV

Reading CSV as Dictionaries (`DictReader`)

JSON Data (JavaScript Object Notation)

JSON Data Types & Type Mapping

Exercise 3

Practice

Summary