Exception Handling

Learning Objectives

By the end of this lesson, you will be able to:

Understand what exception handling is and why it's important
Write TRY-EXCEPT blocks in pseudocode to handle exceptions
Handle division by zero errors gracefully in programs
Manage file handling exceptions when files don't exist or can't be read
Validate user input to prevent invalid data from crashing programs
Combine multiple exception handling techniques in a single program
Write Python code that implements exception handling using try-except blocks
Differentiate between different types of exceptions and handle them appropriately

Key Terms

Exception

An error that occurs while a program is running

Ensuring the program deals with errors gracefully instead of crashing

TRY Block

Contains code that might generate an exception

EXCEPT Block

Catches errors and handles them when they occur

Division by Zero

Common mathematical error when dividing a number by zero

File Handling Exception

Error that occurs when trying to open or read a file that doesn't exist

Input Validation

Checking user input to ensure it's valid before processing

Graceful Degradation

Program continues working even when an error occurs

Pseudocode

Simple language-agnostic code used to design algorithms

What is Exception Handling?

An exception is an error that occurs while a program is running. If not handled, the program will stop and show an error message. Exception handling ensures the program deals with the error gracefully instead of crashing.

Real-Life Example: Calculator App

Think of a calculator app on your phone:

What happens if you try to divide by zero?
Without exception handling: App crashes with error message
With exception handling: Shows "Cannot divide by zero" and continues working
This is graceful degradation - the app doesn't crash!

Exception handling makes apps more robust and user-friendly!

Common Examples of Exceptions

Division by Zero

Trying to divide a number by zero (mathematically impossible)

File Not Found

Reading a file that doesn't exist or can't be accessed

Invalid Input

User enters letters when a number is expected

Exception Handling Flow Visualization

Program Starts Normally

Code executes line by line

TRY Block Begins

Risky code that might cause errors

Exception Occurs!

Error happens during execution

Without Exception Handling

Program crashes with error message

Why is Exception Handling Important?

Prevents Crashes

Ensures the program continues to work even when an error occurs

Improves User Experience

Users see clear error messages instead of unexpected program crashes

Handles Common Issues

Problems like invalid input, missing files, or hardware failures are managed effectively

Pseudocode Structure for Exception Handling

Exception handling uses a TRY-EXCEPT block. Here's how it works in Cambridge Pseudocode:

                        
                        TRY
                    
                            <statements that might cause an error>
                    
                        EXCEPT
                    
                            <statements to handle the error>
                    
                        ENDTRY

TRY Block

Contains the code that might generate an exception

Example: Division operation, file opening

EXCEPT Block

Catches the error and handles it

Example: Show error message, use default value

Key Point: The program continues running after the error is handled in the EXCEPT block.

Activity 1: Identifying Exceptions

For each scenario below, identify:

What type of exception would occur?
How could exception handling prevent the program from crashing?

Scenario A: Calculator Division

A calculator program asks for two numbers and divides the first by the second. The user enters 10 and 0.

Scenario B: File Reader

A program tries to open a file called "data.txt" but the file was accidentally deleted.

Solution:

Scenario A: Calculator Division

Exception type: Division by zero error
Exception handling: Use TRY-EXCEPT block around division operation. In EXCEPT block, show message "Cannot divide by zero" and ask for new number or use default value.

Scenario B: File Reader

Exception type: File not found error
Exception handling: Use TRY-EXCEPT block around file opening. In EXCEPT block, show message "File not found" and either create new file or ask for different filename.

Check Your Understanding: What is Exception Handling?

1. What is an exception in programming? [2 marks]

Answer

[1 mark] An exception is an error that occurs while a program is running
[1 mark] If not handled, the program will stop and show an error message
[Additional] Examples include division by zero, file not found, invalid input

2. Why is exception handling important? Give three reasons. [3 marks]

Answer

[1 mark] Prevents crashes: ensures program continues working even when errors occur
[1 mark] Improves user experience: users see clear error messages instead of unexpected crashes
[1 mark] Handles common issues: problems like invalid input, missing files are managed effectively

3. Describe the structure of a TRY-EXCEPT block in pseudocode. [3 marks]

Answer

[1 mark] TRY keyword followed by statements that might cause an error
[1 mark] EXCEPT keyword followed by statements to handle the error
[1 mark] ENDTRY keyword to mark the end of the exception handling block
[Additional] The TRY block contains risky code, EXCEPT block contains error handling code

4. Give two examples of situations that could cause exceptions. [2 marks]

Answer

[1 mark] Trying to divide a number by zero
[1 mark] Reading a file that doesn't exist
[Additional] Reaching the end of a file unexpectedly, invalid user input (letters instead of numbers)

5. What happens to a program when an exception occurs without exception handling? [2 marks]

Answer

[1 mark] The program will stop/crash immediately
[1 mark] It will show an error message to the user
[Additional] This creates a poor user experience and may cause data loss

Step 1: Handling Division by Zero

One common error is dividing a number by zero, which is not allowed in mathematics. Without exception handling, this will cause the program to crash.

Real-Life Example: Recipe Calculator

Imagine a recipe app that calculates ingredient amounts:

Recipe needs 200g flour for 4 servings
User wants to calculate for 0 servings (mistake!)
App tries: 200 ÷ 0 = ERROR!
Without exception handling: App crashes
With exception handling: Shows "Cannot calculate for 0 servings"

Exception handling makes the app resilient to user mistakes!

Why Division by Zero is a Problem

Mathematically Impossible

Dividing by zero is undefined in mathematics

Causes Runtime Error

Program tries impossible calculation and crashes

Need for Validation

Must check divisor isn't zero before dividing

Pseudocode Example

Division by Zero Code Simulation

                            
                            DECLARE firstNumber, secondNumber, result AS INTEGER
                        
                            TRY
                        
                                OUTPUT "Enter the first number:"
                        
                                INPUT firstNumber
                        
                                OUTPUT "Enter the second number:"
                        
                                INPUT secondNumber
                        
                                result ← firstNumber DIV secondNumber
                        
                                OUTPUT "Result: ", result
                        
                            EXCEPT
                        
                                OUTPUT "Error: Division by zero is not allowed."
                        
                            ENDTRY

How it works: The division operation (line 7) is inside the TRY block. If secondNumber is 0, an exception occurs. Instead of crashing, the EXCEPT block runs and shows a friendly error message.

Python Example

def divide_numbers():
    try:
        first_number = int(input("Enter the first number: "))
        second_number = int(input("Enter the second number: "))
        result = first_number // second_number
        print(f"Result: {result}")
    except ZeroDivisionError:
        print("Error: Division by zero is not allowed.")

# Test the function
divide_numbers()

Key Points to Remember

Always put division operations inside TRY blocks when the divisor comes from user input
In Python, division by zero raises a ZeroDivisionError exception
The EXCEPT block should provide helpful feedback to the user
After handling the exception, the program continues running normally
You can use specific exception types (like ZeroDivisionError) to handle different errors differently

Activity 2: Division by Zero Program

Write a program that:

Asks the user to enter two numbers
Divides the first number by the second number
Uses exception handling to catch division by zero errors
Shows the result or an appropriate error message
Allows the user to try again if they want

Task: Write the pseudocode for this program, then convert it to Python.

Solution:

Pseudocode:

DECLARE firstNum, secondNum, result AS INTEGER
DECLARE choice AS STRING
REPEAT
    TRY
        OUTPUT "Enter the first number: "
        INPUT firstNum
        OUTPUT "Enter the second number: "
        INPUT secondNum
        result ← firstNum DIV secondNum
        OUTPUT "Result: ", result
    EXCEPT
        OUTPUT "Error: Division by zero is not allowed."
    ENDTRY
    OUTPUT "Do you want to try again? (yes/no): "
    INPUT choice
UNTIL choice = "no"

Python Code:

def division_program():
    choice = "yes"
    
    while choice.lower() == "yes":
        try:
            first_num = int(input("Enter the first number: "))
            second_num = int(input("Enter the second number: "))
            result = first_num // second_num
            print(f"Result: {result}")
        except ZeroDivisionError:
            print("Error: Division by zero is not allowed.")
        
        choice = input("Do you want to try again? (yes/no): ")

# Run the program
division_program()

Step 2: File Handling Exceptions

Errors in file handling occur when:

The file you're trying to open doesn't exist
You reach the end of the file unexpectedly

Exception handling ensures the program can detect and respond to these errors.

Real-Life Example: Document Editor

Think of Microsoft Word or Google Docs:

You try to open "essay.docx" but it was deleted
Without exception handling: Program crashes with technical error
With exception handling: Shows "File not found. Create new file?"
Program continues working instead of crashing

This is how professional software handles missing files!

Common File Handling Errors

File Not Found

The specified file doesn't exist at the given path

Permission Denied

Program doesn't have permission to access the file

Disk Full

No space left to write to the file

Pseudocode Example

File Handling Code Simulation

                            
                            DECLARE filename AS STRING
                        
                            TRY
                        
                                OUTPUT "Enter the file name:"
                        
                                INPUT filename
                        
                                OPEN filename FOR READING
                        
                                WHILE NOT EOF(filename)
                        
                                    OUTPUT READ(filename)
                        
                                ENDWHILE
                        
                                CLOSE filename
                        
                            EXCEPT
                        
                                OUTPUT "Error: File not found or unable to read file."
                        
                            ENDTRY

How it works: The file opening operation (line 5) is inside the TRY block. If the file doesn't exist or can't be read, an exception occurs. The EXCEPT block runs and shows a friendly error message instead of crashing.

Python Example

def read_file():
    try:
        filename = input("Enter the file name: ")
        with open(filename, 'r') as file:
            for line in file:
                print(line.strip())
    except FileNotFoundError:
        print("Error: File not found.")
    except IOError:
        print("Error: Unable to read the file.")

# Test the function
read_file()

Key Points to Remember

In Python, FileNotFoundError occurs when a file doesn't exist
IOError (Input/Output Error) covers various file access problems
The with statement automatically closes the file after use
You can have multiple EXCEPT blocks to handle different types of file errors
Always provide clear error messages so users know what went wrong

Check Your Understanding: File Handling Exceptions

1. What are two common file handling exceptions? [2 marks]

Answer

[1 mark] The file you're trying to open doesn't exist
[1 mark] You reach the end of the file unexpectedly
[Additional] Other exceptions: permission denied, disk full, file in use by another program

2. Write pseudocode for a program that reads a file with exception handling. [4 marks]

Answer

DECLARE filename AS STRING
TRY
    OUTPUT "Enter the file name:"
    INPUT filename
    OPEN filename FOR READING
    WHILE NOT EOF(filename)
        OUTPUT READ(filename)
    ENDWHILE
    CLOSE filename
EXCEPT
    OUTPUT "Error: File not found or unable to read file."
ENDTRY

3. What is the difference between FileNotFoundError and IOError in Python? [2 marks]

Answer

[1 mark] FileNotFoundError occurs specifically when a file doesn't exist at the given path
[1 mark] IOError is more general and covers various input/output problems like permission issues, disk full, or file corruption

4. Why should file operations be placed inside TRY blocks? [2 marks]

Answer

[1 mark] File operations can fail for many reasons outside the program's control (file deleted, no permission, disk full)
[1 mark] Placing them in TRY blocks allows the program to handle these failures gracefully instead of crashing

Step 3: Validating User Input

Programs often need to validate user input. For example:

Ensuring the user enters a number instead of a letter
Checking that the input is within an acceptable range

Exception handling allows you to catch errors if the input is invalid.

Real-Life Example: Online Form

Think of an online shopping checkout form:

Age field expects a number
User accidentally enters "twenty" instead of "20"
Without validation: Program crashes or processes incorrectly
With validation: Shows "Please enter a valid number"
User can correct their mistake and continue

Input validation prevents errors before they happen!

Common Input Validation Scenarios

Wrong Data Type

Entering text when a number is expected

Out of Range

Entering age as 150 when valid range is 0-120

Invalid Format

Entering phone number without digits

Pseudocode Example

Input Validation Code Simulation

                            
                            DECLARE userInput, userNumber AS INTEGER
                        
                            TRY
                        
                                OUTPUT "Enter a number:"
                        
                                INPUT userInput
                        
                                userNumber ← CONVERT_TO_INTEGER(userInput)
                        
                                OUTPUT "You entered: ", userNumber
                        
                            EXCEPT
                        
                                OUTPUT "Error: Invalid input. Please enter a valid number."
                        
                            ENDTRY

How it works: The CONVERT_TO_INTEGER function (line 5) will fail if userInput contains non-numeric characters. This failure triggers the EXCEPT block, which shows a helpful error message instead of crashing.

Python Example

def validate_input():
    try:
        user_input = input("Enter a number: ")
        user_number = int(user_input)
        print(f"You entered: {user_number}")
    except ValueError:
        print("Error: Invalid input. Please enter a valid number.")

# Test the function
validate_input()

Key Points to Remember

In Python, int() conversion raises ValueError if the input isn't a valid number
Always validate user input - never trust that users will enter correct data
You can combine input validation with loops to allow multiple attempts
Consider using validation functions for complex validation rules
Provide clear, specific error messages to help users correct their input

Check Your Understanding: Input Validation

1. Why is input validation important in programs? [2 marks]

Answer

[1 mark] Users often make mistakes when entering data (typos, wrong format)
[1 mark] Without validation, programs may crash or produce incorrect results from bad input
[Additional] Validation ensures data integrity and prevents security vulnerabilities

2. What exception occurs in Python when trying to convert non-numeric text to an integer? [1 mark]

Answer

[1 mark] ValueError exception

3. Write a Python program that asks for age and handles invalid input. [4 marks]

Answer

def get_age():
    try:
        age = int(input("Enter your age: "))
        print(f"Your age is: {age}")
    except ValueError:
        print("Error: Please enter a valid number for age.")

# Test the function
get_age()

4. How can you make an input validation program allow multiple attempts? [2 marks]

Answer

[1 mark] Use a loop (WHILE or REPEAT-UNTIL) that continues until valid input is received
[1 mark] Place the TRY-EXCEPT block inside the loop to catch errors on each attempt
[Additional] Example: REPEAT...TRY...EXCEPT...UNTIL valid input received

Step 4: Combining Exception Handling Techniques

You can use multiple EXCEPT blocks to handle different types of errors in the same program. This allows you to provide specific error messages for different problems.

Real-Life Example: Bank App

Imagine a banking application that:

Reads account data from a file
Performs calculations on balances
Accepts user input for transactions
Multiple things can go wrong!
File might be missing
User might enter invalid amounts
Calculations might have issues

Professional apps handle ALL possible errors gracefully!

Benefits of Multiple EXCEPT Blocks

Specific Error Messages

Different errors get different, helpful messages

Different Recovery Actions

Each error type can have appropriate recovery

Better Debugging

Easier to identify which type of error occurred

Pseudocode Example

Combined Exception Handling Simulation

                            
                            DECLARE filename AS STRING
                        
                            DECLARE firstNumber, secondNumber, result AS INTEGER
                        
                            TRY
                        
                                OUTPUT "Enter the file name:"
                        
                                INPUT filename
                        
                                OPEN filename FOR READING
                        
                                OUTPUT "Enter the first number:"
                        
                                INPUT firstNumber
                        
                                OUTPUT "Enter the second number:"
                        
                                INPUT secondNumber
                        
                                result ← firstNumber DIV secondNumber
                        
                                OUTPUT "Result: ", result
                        
                                CLOSE filename
                        
                            EXCEPT // File not found
                        
                                OUTPUT "Error: File not found."
                        
                            EXCEPT // Division by zero
                        
                                OUTPUT "Error: Division by zero is not allowed."
                        
                            EXCEPT // Invalid input
                        
                                OUTPUT "Error: Invalid input."
                        
                            ENDTRY

How it works: This program combines file handling, division, and input validation. Multiple EXCEPT blocks handle different error types: file not found, division by zero, and invalid input. Each provides a specific error message.

Python Example

def combined_example():
    try:
        filename = input("Enter the file name: ")
        with open(filename, 'r') as file:
            print("File content:")
            print(file.read())
        
        first_number = int(input("Enter the first number: "))
        second_number = int(input("Enter the second number: "))
        result = first_number // second_number
        print(f"Result: {result}")
    
    except FileNotFoundError:
        print("Error: File not found.")
    except ZeroDivisionError:
        print("Error: Division by zero is not allowed.")
    except ValueError:
        print("Error: Invalid input.")

# Test the function
combined_example()

Key Points to Remember

Multiple EXCEPT blocks allow specific handling of different exception types
The order of EXCEPT blocks matters - more specific exceptions should come first
In Python, you can catch multiple exceptions in one EXCEPT block: except (Type1, Type2):
A generic EXCEPT block without specifying exception type catches all exceptions
Always close files in a FINALLY block or use with statement for automatic cleanup

Activity 3: Complete Exception Handling Program

Write a complete program that:

Asks the user for a filename and tries to open it
Asks for two numbers and divides them
Handles these specific exceptions:
- File not found
- Division by zero
- Invalid number input
- Any other unexpected errors
Provides appropriate error messages for each case
Always closes the file properly, even if an error occurs

Solution:

Python Code:

def complete_program():
    filename = input("Enter the file name: ")
    file = None  # Initialize file variable
    
    try:
        # Try to open and read the file
        file = open(filename, 'r')
        content = file.read()
        print("File content:")
        print(content)
        
        # Get numbers from user
        first_num = int(input("Enter the first number: "))
        second_num = int(input("Enter the second number: "))
        
        # Perform division
        result = first_num / second_num
        print(f"Result of division: {result}")
        
    except FileNotFoundError:
        print("Error: The specified file was not found.")
    except ZeroDivisionError:
        print("Error: Cannot divide by zero.")
    except ValueError:
        print("Error: Please enter valid numbers only.")
    except Exception as e:
        print(f"An unexpected error occurred: {e}")
    finally:
        # Always close the file if it was opened
        if file:
            file.close()
            print("File closed successfully.")

# Run the program
complete_program()

Check Your Understanding: Combining Techniques

1. Why use multiple EXCEPT blocks instead of one general EXCEPT block? [2 marks]

Answer

[1 mark] Allows specific error messages for different types of errors
[1 mark] Enables different recovery actions for different error types
[Additional] Makes debugging easier by identifying exactly which error occurred

2. What is the purpose of a FINALLY block in exception handling? [2 marks]

Answer

[1 mark] Code in the FINALLY block always executes, whether an exception occurs or not
[1 mark] Used for cleanup operations like closing files or releasing resources
[Additional] Ensures important cleanup happens even if an error occurs

3. Write Python code with multiple exception handlers for file reading and calculation. [5 marks]

Answer

def process_data():
    try:
        filename = input("Enter filename: ")
        with open(filename) as f:
            data = f.read()
        
        num1 = int(input("Enter first number: "))
        num2 = int(input("Enter second number: "))
        result = num1 / num2
        print(f"Result: {result}")
        
    except FileNotFoundError:
        print("Error: File not found")
    except ZeroDivisionError:
        print("Error: Cannot divide by zero")
    except ValueError:
        print("Error: Invalid number entered")
    except Exception as e:
        print(f"Unexpected error: {e}")

4. What happens if a general EXCEPT block comes before specific EXCEPT blocks? [2 marks]

Answer

[1 mark] The general EXCEPT block will catch all exceptions
[1 mark] The specific EXCEPT blocks that come after will never be reached/executed
[Additional] Always put specific exception handlers before general ones

Key Takeaways

Exception handling prevents program crashes by gracefully managing errors during runtime
TRY-EXCEPT blocks are the fundamental structure for exception handling in pseudocode and Python
Division by zero is a common mathematical error that must be caught and handled
File handling exceptions occur when files don't exist, can't be read, or have permission issues
Input validation is essential to handle invalid user input before it causes errors
Multiple EXCEPT blocks allow specific handling of different exception types with appropriate error messages
In Python, common exceptions include ZeroDivisionError, FileNotFoundError, ValueError, and IOError
The order of EXCEPT blocks matters - specific exceptions should come before general ones
Always provide clear error messages that help users understand what went wrong and how to fix it
Programs with good exception handling are more robust, user-friendly, and professional
Real-world applications use exception handling everywhere - from calculator apps to banking software
Practice is essential - write programs that intentionally cause exceptions to learn how to handle them properly

Question Bank

1. Explain what exception handling is and why it's important in programming. [4 marks]

Marking Scheme & Answer

[1 mark] Exception handling is a way to catch and respond to errors that occur during program execution
[1 mark] It prevents programs from crashing when unexpected situations occur
[1 mark] Improves user experience by providing clear error messages instead of technical crash reports
[1 mark] Allows programs to handle common issues like invalid input, missing files, or mathematical errors gracefully

2. Write pseudocode for a program that handles division by zero using TRY-EXCEPT blocks. [5 marks]

Marking Scheme & Answer

DECLARE firstNumber, secondNumber, result AS INTEGER
TRY
    OUTPUT "Enter the first number:"
    INPUT firstNumber
    OUTPUT "Enter the second number:"
    INPUT secondNumber
    result ← firstNumber DIV secondNumber
    OUTPUT "Result: ", result
EXCEPT
    OUTPUT "Error: Division by zero is not allowed."
ENDTRY

Mark allocation: 1 mark for variable declaration, 1 mark for TRY block start, 2 marks for correct division logic inside TRY, 1 mark for EXCEPT block with error message.

3. Convert the following pseudocode to Python, handling file not found exceptions. [6 marks]

Marking Scheme & Answer

Pseudocode:

DECLARE filename AS STRING
TRY
    OUTPUT "Enter file name:"
    INPUT filename
    OPEN filename FOR READING
    OUTPUT READ(filename)
    CLOSE filename
EXCEPT
    OUTPUT "File not found error"
ENDTRY

Python Code:

filename = input("Enter file name: ")
try:
    with open(filename, 'r') as file:
        content = file.read()
        print(content)
except FileNotFoundError:
    print("File not found error")

Mark allocation: 1 mark for input, 1 mark for TRY block, 2 marks for correct file handling with 'with' statement, 1 mark for EXCEPT block, 1 mark for correct exception type (FileNotFoundError).

4. Describe three different types of exceptions that can occur in programs and how to handle each. [6 marks]

Marking Scheme & Answer

Division by Zero:

Occurs when dividing by zero
Handle with ZeroDivisionError in Python
Solution: Check divisor isn't zero or use TRY-EXCEPT

File Not Found:

Occurs when opening non-existent file
Handle with FileNotFoundError in Python
Solution: Check file exists or use TRY-EXCEPT

Invalid Input:

Occurs with wrong data type input
Handle with ValueError in Python
Solution: Validate input or use TRY-EXCEPT

Mark allocation: 2 marks for each exception type (1 for description, 1 for handling method).

5. Write a Python program that combines multiple exception handlers for a calculator program. [8 marks]

Marking Scheme & Answer

def calculator():
    print("Simple Calculator")
    print("Operations: +, -, *, /")
    
    try:
        num1 = float(input("Enter first number: "))
        operation = input("Enter operation (+, -, *, /): ")
        num2 = float(input("Enter second number: "))
        
        if operation == '+':
            result = num1 + num2
        elif operation == '-':
            result = num1 - num2
        elif operation == '*':
            result = num1 * num2
        elif operation == '/':
            if num2 == 0:
                raise ZeroDivisionError("Cannot divide by zero")
            result = num1 / num2
        else:
            raise ValueError("Invalid operation")
        
        print(f"Result: {result}")
    
    except ValueError as ve:
        print(f"Input error: {ve}")
    except ZeroDivisionError as zde:
        print(f"Math error: {zde}")
    except Exception as e:
        print(f"Unexpected error: {e}")

# Run calculator
calculator()

Mark allocation: 2 marks for input handling, 2 marks for calculation logic, 2 marks for multiple exception handlers, 2 marks for proper error messages and program structure.

6. Explain the difference between syntax errors and exceptions, and how they are handled differently. [4 marks]

Marking Scheme & Answer

Syntax Errors:

Occur during parsing/compilation
Caused by incorrect code structure
Program won't run at all
Examples: missing colon, incorrect indentation

Exceptions:

Occur during program execution
Caused by runtime conditions
Program runs but encounters error
Examples: division by zero, file not found

Key Difference: Syntax errors are caught before program runs (by interpreter/compiler), while exceptions occur during execution and can be handled with TRY-EXCEPT blocks.

7. Design a program that reads student grades from a file and calculates average, with full exception handling. [10 marks]

Marking Scheme & Answer

def calculate_average_grades():
    """Read grades from file and calculate average with exception handling"""
    
    while True:
        try:
            filename = input("Enter grades filename: ")
            
            # Read grades from file
            with open(filename, 'r') as file:
                grades = file.readlines()
            
            # Convert to numbers and calculate average
            total = 0
            count = 0
            
            for grade_str in grades:
                grade = float(grade_str.strip())
                if grade < 0 or grade > 100:
                    raise ValueError(f"Grade {grade} is out of range (0-100)")
                total += grade
                count += 1
            
            if count == 0:
                print("No grades found in file")
                return
            
            average = total / count
            print(f"Average grade: {average:.2f}")
            break  # Exit loop on success
            
        except FileNotFoundError:
            print("Error: File not found. Please try again.")
        except ValueError as ve:
            print(f"Error: Invalid grade data - {ve}")
        except ZeroDivisionError:
            print("Error: Cannot calculate average - no valid grades found")
        except Exception as e:
            print(f"Unexpected error: {e}")
            break  # Exit on unexpected errors

# Run the program
calculate_average_grades()

Mark allocation: 2 marks for file reading, 2 marks for grade processing, 2 marks for average calculation, 4 marks for comprehensive exception handling (file not found, invalid data, division by zero, general exceptions).

8. Compare and contrast defensive programming with exception handling. [6 marks]

Marking Scheme & Answer

Defensive Programming:

Prevents errors before they occur
Uses validation and checks
Example: Check divisor isn't zero before dividing
Proactive approach
Code may have many condition checks

Exception Handling:

Handles errors after they occur
Uses TRY-EXCEPT blocks
Example: Catch ZeroDivisionError when dividing
Reactive approach
Cleaner code structure

Best Practice: Use both approaches together - defensive programming to prevent expected errors, and exception handling to gracefully manage unexpected errors.