PCEP Certification Practice: Delegating Responsibility for Handling Exceptions

Question 1: What does it mean to "delegate responsibility for handling exceptions" in Python?

1. Catching every exception inside the same function where it occurs.
2. Allowing exceptions to propagate to another function or caller to handle them.
3. Using only the finally block to handle exceptions.
4. Raising new exceptions within the same function.

Question 2: Which of the following are valid ways to delegate responsibility for handling exceptions in Python? (Select all that apply.)

• Let the exception propagate to the calling function.
• Re-raise an exception within a function to pass it to another handler.
• Handle all exceptions within the function where they occur.
• Use try-except blocks in the calling code to catch exceptions raised in functions.

Question 3: In Python, exceptions can propagate to the _________ function, which can handle them if not caught inside the function where they occur.

1. main
2. calling
3. except

Question 4: If a function raises an exception and does not handle it, the responsibility for handling that exception is delegated to the __________ function.

Question 5: Fill in the blank to delegate the responsibility of handling the ValueError to the calling function:

def convert_to_int(s):
    return int(s)

try:
    convert_to_int("abc")
except __________:
    print("Invalid value provided!")

Question 6: What happens if a function does not catch an exception, and the calling function does not handle it either?

1. The program terminates.
2. The exception is re-raised automatically.
3. The exception is ignored.
4. The program enters an infinite loop.

Question 7: Insert the correct code to delegate the handling of the ZeroDivisionError to the calling function:

def divide(a, b):
    return a / b

try:
    divide(10, 0)
# INSERT CODE HERE
    print("Division by zero error!")

Question 8: Which of the following statements are true about delegating exception handling in Python? (Select all that apply.)

1. A function can let exceptions propagate to the caller without handling them.
2. The calling function must always handle exceptions.
3. Re-raising an exception in a function delegates responsibility to the caller.
4. Exceptions must always be handled within the same function where they occur.

Question 9: When a function raises an exception and does not handle it, responsibility for handling the exception is passed to the _________ function.

• nested
• calling
• outer

Question 10: If a function raises an exception and does not catch it, responsibility for handling the exception is passed to the __________.

Question 11: Sort the following actions in the correct order when delegating exception handling in Python.

1. An exception occurs in a function.
2. The calling function catches the exception.
3. The exception propagates to the calling function.

Question 12: Which of the following practices are examples of delegating responsibility for handling exceptions? (Select all that apply.)

1. Raising an exception in a function and catching it in the calling function.
2. Re-raising an exception in a function so that it can be caught by a higher-level handler.
3. Using try-except inside every function to handle exceptions locally.
4. Allowing the exception to propagate to a global handler.

Question 13: The responsibility for handling an exception can be delegated to the _________ function if it is not handled locally in the function where it occurs.

1. next
2. main
3. calling

Question 14: If a function raises an exception and does not handle it, the exception will propagate to the __________ function.

Question 15: Fill in the blank to delegate responsibility for handling exceptions to the calling function:

def calculate_area(radius):
    if radius < 0:
        raise ValueError("Radius cannot be negative")
    return 3.14 * radius ** 2

try:
    calculate_area(-5)
except __________:
    print("Invalid radius provided!")

Question 16: What happens if a function raises an exception, but it is not caught in the calling function?

1. The program terminates.
2. The exception propagates further.
3. The function automatically returns None.
4. The program ignores the exception.

Question 17: Insert the correct code to delegate responsibility for handling an exception from one function to another:

def func1():
    raise KeyError("Key not found")

def func2():
    try:
        func1()
# INSERT CODE HERE to handle the exception
        print("KeyError handled")

func2()

Question 18: Which of the following are examples of delegating exception handling responsibility to other functions? (Select all that apply.)

1. Re-raising an exception after catching it.
2. Letting an exception propagate to the calling function.
3. Handling the exception inside the function where it occurs.
4. Allowing the exception to propagate to a global handler.

Question 19: In Python, an exception that is raised but not caught in a function will propagate to the _________.

1. next line
2. calling function
3. global scope

Question 20: If a function raises an exception but does not catch it, the __________ function is responsible for handling the exception.

Question 21: Arrange the following actions in the correct order when handling exceptions in a delegated fashion.

1. A function raises an exception.
2. The exception is propagated to the calling function.
3. The calling function catches the exception.

Question 22: Which of the following are valid strategies for handling exceptions by delegating responsibility in Python? (Select all that apply.)

1. Re-raising exceptions after catching them.
2. Handling all exceptions inside each function locally.
3. Allowing exceptions to propagate to higher-level functions.
4. Letting a global exception handler catch unhandled exceptions.

Question 23: In Python, an exception raised in a function will propagate to the _________ function if it is not caught.

1. next
2. previous
3. calling

Question 24: Fill in the blank to delegate responsibility for handling exceptions to a higher-level function:

def check_positive(value):
    if value < 0:
        raise ValueError("Negative value provided")

try:
    check_positive(-10)
except __________:
    print("Caught a ValueError")

Question 25: What happens when an exception is not caught by the calling function?

1. The exception propagates further up the call chain.
2. The exception is re-raised by the called function.
3. The program automatically handles the exception.
4. The function returns None.