Exception Handling Basics

Exception handling is a programming technique that lets you manage errors (called 'exceptions') that happen while your program is running, without the program crashing. Think of it like building an airbag system into your code. When your program hits a problem, instead of exploding, it deploys the airbag — a block of code you wrote specifically for that situation.

First, let's define the key terms. An 'exception' is an event that occurs during the execution of a program that disrupts the normal flow of instructions. For example, trying to divide by zero, or trying to open a file that doesn't exist. When an exception occurs, Python creates an 'exception object' that contains information about the error, like what went wrong and where.

A 'try-except block' is the structure you use to handle exceptions. You put the code that might cause an exception inside the 'try' block. Then you write one or more 'except' blocks immediately after, each one designed to catch a specific type of exception and run some rescue code.

Here's how it works step by step:

Let's look at a real example. Suppose you ask the user to enter a number, and they type 'hello'.

Without exception handling:

user_input = input("Enter a number: ")
number = int(user_input)  # If user types 'hello', this line crashes the program
print("You entered:", number)

With exception handling:

try:
    user_input = input("Enter a number: ")
    number = int(user_input)
    print("You entered:", number)
except ValueError:
    print("That wasn't a valid number. Please try again.")

In the second version, if the user types 'hello', the program prints "That wasn't a valid number" and keeps running. It doesn't crash.

The 'ValueError' after the word 'except' is the type of exception you're catching. Python has many built-in exception types. Here are the ones you need for the PCEP-30-02 exam:

You can write multiple 'except' blocks for one 'try' block to handle different types of errors differently:

try:
    number = int(input("Enter a number: "))
    result = 10 / number
    print("Result:", result)
except ValueError:
    print("That's not a valid number.")
except ZeroDivisionError:
    print("You can't divide by zero.")
except Exception:
    print("Something unexpected happened.")

Notice the last 'except Exception:' line. 'Exception' is the base class for all built-in exceptions. So 'except Exception:' catches any exception that didn't match a previous except block. Use this carefully — it's a catch-all that can hide bugs you didn't expect.

There's also an 'else' clause you can add after all the 'except' blocks. The 'else' block runs only if no exception occurred in the 'try' block. And a 'finally' block runs no matter what — whether an exception occurred or not. The 'finally' block is great for cleanup actions, like closing a file.

The key reason exception handling exists is that it separates the normal flow of your program from the error-handling logic. Without it, you'd have to check for every possible error after every single operation, making your code hard to read and maintain. Exception handling lets you write the happy path first, then add safety nets separately.

Imagine you work as a junior IT support analyst for a company that runs a customer booking system. Your colleague built a Python script that reads a CSV file of customer names and their booking dates, then sends them a reminder email. The script works perfectly in testing with clean data. But in production, the file sometimes has blank rows, or dates in the wrong format, or names with special characters. Before exception handling, the script would crash on the first bad row and stop processing all the remaining customers. Your boss would be furious because hundreds of customers never got their reminder.

Here's what you do to fix it. You wrap the part of the script that processes each row inside a 'try' block. Then you write specific 'except' blocks for the errors you know can happen.

Step by step, here's the real-world process:

Here's what the code structure looks like:

import csv

file = open("customers.csv", "r")
try:
    reader = csv.reader(file)
    for row in reader:
        try:
            name = row[0]
            date_str = row[1]
            from datetime import datetime
            booking_date = datetime.strptime(date_str, "%Y-%m-%d")
            # send email logic here
        except (ValueError, IndexError) as e:
            print(f"Skipping bad row: {e}")
            continue
except FileNotFoundError:
    print("The customer file is missing. Contact the data team.")
finally:
    file.close()

Notice the structure: there's an outer try-except-finally for file-level errors, and an inner try-except for per-row errors. This nested approach is common in real code.

The practical outcome: the script now processes 99% of customers successfully, logs the problematic rows for later manual review, and doesn't crash. You've saved the company from a PR disaster. This is exactly how exception handling is used in production systems — not just for academic examples, but to build robust, fault-tolerant software that can survive real-world messy data.

In your daily work, you'll also use exception handling to debug problems. When an error occurs, you can catch the exception, print its traceback (the trail of function calls that led to the error), and understand exactly what went wrong. The traceback is Python's way of saying "Here's the path the program took before it hit the error." Reading tracebacks becomes second nature with practice.