Quiz: Error Handling

Test your understanding before moving on. Target: 70% or higher to proceed confidently.

Section 1: Multiple Choice (1 point each)

1. Which of the following is a runtime error (exception), not a syntax error?

• A) print("hello" (missing closing parenthesis)
• B) int("abc")
• C) def greet(name) (missing colon)
• D) x = = 5 (double equals in assignment)

2. When reading a Python traceback, you should start reading from:

• A) The top (first line)
• B) The bottom (last line)
• C) The middle
• D) It doesn't matter — read in any order

3. What happens if an exception occurs inside a try block and no except clause matches it?

• A) Python silently ignores the exception
• B) The else block runs
• C) The exception propagates up to the caller (but finally still runs if present)
• D) Python automatically catches it and prints a generic message

4. What does the else clause in a try/except/else block do?

• A) Runs if an exception IS raised
• B) Runs if no exception is raised in the try block
• C) Runs regardless of whether an exception occurred
• D) Runs only if a specific exception type is raised

5. What is the output of this code?

try:
    x = int("42")
except ValueError:
    print("error")
else:
    print("success")
finally:
    print("done")

• A) error then done
• B) success then done
• C) done only
• D) success only

6. Which of the following is a reason to use finally?

• A) To handle specific exception types
• B) To ensure cleanup code runs regardless of whether an exception occurred
• C) To raise custom exceptions
• D) To convert syntax errors to runtime errors

7. What does EAFP stand for?

• A) Error And Fault Protection
• B) Easier to Ask Forgiveness than Permission
• C) Exception Anticipation For Programs
• D) Early And Fast Processing

8. Which approach is generally considered more "Pythonic"?

• A) LBYL — always check conditions before attempting an operation
• B) EAFP — attempt the operation and handle exceptions if it fails
• C) Both are equally Pythonic
• D) Neither — Python has no preference

9. Why is a bare except: (without specifying an exception type) considered an anti-pattern?

• A) It's a syntax error in Python 3.12+
• B) It catches too many exceptions, including KeyboardInterrupt and SystemExit
• C) It's slower than specifying exception types
• D) It only catches ValueError

10. What is the purpose of raise in Python?

• A) To catch an exception
• B) To suppress an exception
• C) To deliberately trigger an exception
• D) To convert an exception to a warning

Section 2: Short Answer (2 points each)

11. What is the difference between a ValueError and a TypeError? Give an example of each.

12. Explain the difference between the else and finally clauses in a try statement.

13. What is the output of this code?

try:
    result = 10 / 0
except ZeroDivisionError:
    print("A")
else:
    print("B")
finally:
    print("C")
print("D")

A
C
D

14. Convert this LBYL code to EAFP style:

import os
if os.path.exists("config.txt"):
    with open("config.txt") as f:
        config = f.read()
else:
    config = "default settings"

try:
    with open("config.txt") as f:
        config = f.read()
except FileNotFoundError:
    config = "default settings"

15. Why should error messages in raise statements include the actual problematic value?

Section 3: Code Analysis (3 points each)

16. This code has an error handling anti-pattern. Identify it and explain why it's problematic:

def load_data(filename):
    try:
        with open(filename) as f:
            data = json.loads(f.read())
        processed = transform_data(data)
        save_results(processed)
    except Exception:
        print("Something went wrong.")

def load_data(filename):
    try:
        with open(filename) as f:
            data = json.loads(f.read())
    except FileNotFoundError:
        print(f"File '{filename}' not found.")
        return
    except json.JSONDecodeError:
        print(f"File '{filename}' contains invalid JSON.")
        return

    processed = transform_data(data)
    save_results(processed)

17. Trace through this code and determine its output:

def risky(n):
    try:
        if n == 0:
            raise ValueError("zero!")
        result = 100 / n
    except ValueError as e:
        print(f"Caught ValueError: {e}")
        return -1
    except ZeroDivisionError:
        print("Caught ZeroDivisionError")
        return -2
    else:
        print(f"Success: {result}")
        return result
    finally:
        print("Cleanup")

x = risky(0)
print(f"x = {x}")

Caught ValueError: zero!
Cleanup
x = -1

18. What's wrong with this custom exception and how would you fix it?

class NegativeBalanceError:
    def __init__(self, balance):
        self.balance = balance
        self.message = f"Balance cannot be negative: {balance}"

raise NegativeBalanceError(-50)
# TypeError: exceptions must derive from BaseException

class NegativeBalanceError(Exception):
    def __init__(self, balance):
        self.balance = balance
        super().__init__(f"Balance cannot be negative: {balance}")

Section 4: Scenario Analysis (3 points each)

19. You're writing a web scraper that downloads 1,000 pages. About 5% of the URLs will return 404 errors. Should you use LBYL (check if the URL is valid before downloading) or EAFP (try to download and handle the error)? Explain your reasoning.

20. Elena's report script processes 500 CSV rows. About 200 have data quality issues (missing fields, non-numeric values). She wants to process all valid rows and log the bad ones. Design the error handling approach. Should she use LBYL or EAFP? Why? What exception types should she catch?

valid_rows = []
errors = []
for i, line in enumerate(lines):
    try:
        fields = line.strip().split(",")
        if len(fields) != 3:  # LBYL — predictable check
            errors.append((i, "wrong number of fields"))
            continue
        name, score, grade = fields
        score = float(score)  # EAFP — let ValueError happen
        valid_rows.append((name, score, grade))
    except ValueError as e:
        errors.append((i, str(e)))