PCEP Certification Practice: Exception Propagation through Function Boundaries

Question 1: What happens when an exception occurs in a function and it is not handled within that function?

1. The exception is ignored.
2. The exception is propagated to the calling function.
3. The function automatically returns None.
4. The program enters an infinite loop.

Question 2: Which of the following are true about exceptions propagating through function boundaries?

• If an exception occurs in a function and is not caught, it will propagate to the calling function.
• If an exception is caught in a function, it will not propagate to the calling function.
• Uncaught exceptions terminate the program if they propagate to the top level.
• Exceptions must always be caught within the same function they occur in.

Question 3: In Python, an uncaught exception in a function will propagate to the _________.

1. calling function
2. exception block
3. finally block

Question 4: If a function does not catch an exception, it is automatically propagated to the __________.

Question 5: Fill in the blanks to catch the ZeroDivisionError in the calling function and not within the divide() function:

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

try:
    divide(10, 0)
except __________:
    print("Division by zero!")

Question 6: What happens if a function raises an exception that is not handled inside the function or the calling function?

1. The exception is ignored.
2. The program terminates.
3. The exception is automatically caught at the top level.
4. The exception causes an infinite loop.

Question 7: Insert the correct except block to handle an exception propagated from a function:

def raise_exception():
    raise ValueError("An error occurred")

try:
    raise_exception()
# INSERT CODE HERE
    print("Error handled")

Question 8: Which of the following are correct regarding exception propagation in Python? (Select all that apply.)

1. Exceptions propagate from a function to the code that called it if not caught.
2. If a function raises an exception and catches it, the exception will still propagate.
3. Uncaught exceptions can propagate through multiple function calls.
4. An exception caught in a function does not propagate to the caller.

Question 9: When an exception is not caught within a function, it is propagated to the _________.

• next line
• function that called it
• finally block

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

Question 11: Sort the following steps in the order in which an uncaught exception propagates through function calls.

1. Function where the exception occurred.
2. Function that called the function where the exception occurred.
3. Main program that called the top-level function.

Question 12: Which of the following are consequences of not handling exceptions in a function? (Select all that apply.)

1. The exception is propagated to the calling function.
2. The program will terminate if the exception is not caught at any level.
3. The exception will automatically be handled by Python.
4. The exception may propagate through multiple layers of function calls.

Question 13: In Python, exceptions can propagate through multiple function calls and can be caught by the _________ function that calls them.

1. first
2. last
3. any

Question 14: If an exception is not caught by a function, it propagates to the calling function, and if still uncaught, it reaches the __________ level.

Question 15: Fill in the blank to propagate the exception from inner_function() to outer_function():

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

def outer_function():
    try:
        inner_function()
    except __________:
        print("Key error caught in outer function")

outer_function()

Question 16: If a function raises an exception and the calling function catches it, what happens?

1. The exception is propagated further.
2. The program terminates.
3. The exception is handled, and the program continues.
4. The function where the exception occurred is executed again.

Question 17: Insert the correct code to handle an exception that is propagated through multiple function calls:

def func_a():
    raise ValueError("An error occurred")

def func_b():
    func_a()

def func_c():
    try:
        func_b()
# INSERT CODE HERE to catch the exception
        print("Error handled in func_c")

func_c()

Question 18: Which of the following statements are true about exceptions propagating through multiple functions? (Select all that apply.)

1. The function where the exception occurred must catch it.
2. The calling function can catch an exception raised in the called function.
3. An exception can propagate through several function calls before being caught.
4. The exception must be caught in the same function where it occurs.

Question 19: An exception can propagate through multiple function calls and can be caught by any function in the _________.

1. call chain
2. exception hierarchy
3. input stream

Question 20: When an exception is not caught in a function, it propagates through the __________ of function calls.

Question 21: Sort the following steps in the order in which an uncaught exception propagates through function calls.

1. The function that called the function where the exception occurred.
2. The function where the exception occurs.
3. The main function or top-level code.

Question 22: Which of the following functions can catch an exception propagated from a lower-level function? (Select all that apply.)

1. The function where the exception occurred.
2. Any function in the call chain.
3. The main function or top-level code.
4. Only the function where the exception occurred.

Question 23: In Python, an exception will propagate through the function call _________ if it is not caught.

1. return value
2. stack
3. hierarchy

Question 24: Fill in the blank to propagate the exception from inner_func() to outer_func():

def inner_func():
    raise TypeError("Type mismatch")

def outer_func():
    try:
        inner_func()
    except __________:
        print("TypeError caught in outer_func")

outer_func()

Question 25: What happens when an exception propagates through multiple function calls and reaches the top level of the program without being caught?

1. The program terminates.
2. The exception is ignored.
3. The program continues running.
4. The function where the exception occurred is called again.