Testing, Debugging & Exceptions

Three Types of Errors

try-except — Catching Exceptions

Wrap risky code in a try block. If an exception occurs, execution jumps to the matching except block — the program doesn't crash.

try:
    x = int(input("Enter a number: "))
    result = 100 / x
    print("Result:", result)
except ZeroDivisionError:
    print("Cannot divide by zero!")
except ValueError:
    print("That is not a valid number!")

Common Exception Types

except with else and finally

try:
    f = open("data.txt")
    data = f.read()
except FileNotFoundError:
    print("File not found.")
else:
    print("File read successfully!")   # runs if NO exception
finally:
    print("This always runs.")         # runs always (cleanup)

• else: runs only if the try block succeeded without exception
• finally: always runs — good for cleanup (closing files)

Catching Any Exception + Getting the Message

try:
    risky_operation()
except Exception as e:
    print("Error:", e)     # prints the error message

raise — Throwing an Exception

You can deliberately trigger an exception to signal an error condition.

def set_age(age):
    if age < 0 or age > 150:
        raise ValueError(f"Invalid age: {age}")
    return age

try:
    set_age(-5)
except ValueError as e:
    print(e)   # Invalid age: -5

assert — Testing Assumptions

assert condition, message — raises AssertionError if condition is False. Used for testing.

def square(n):
    return n * n

# Test the function
assert square(4) == 16, "square(4) should be 16"
assert square(0) == 0,  "square(0) should be 0"
assert square(-3) == 9, "square(-3) should be 9"

print("All tests passed!")   # runs if all asserts pass

Defensive Programming

Anticipate errors before they happen. Validate user input and check preconditions.

def divide(a, b):
    if b == 0:
        print("Error: cannot divide by zero")
        return None
    return a / b

# Or use raise:
def divide(a, b):
    if b == 0:
        raise ValueError("Divisor cannot be zero")
    return a / b

Debugging Strategies

• Print statements: add print() to trace variable values.
• Trace by hand: simulate the code step by step on paper.
• Rubber duck debugging: explain your code out loud — you'll spot the bug.
• Simplify: isolate the failing part with a minimal test case.
• Read the error message: Python tells you the type and line number.