PCEP Functions, Tuples, Dictionaries and Exceptions Practice Test 7 — 15 Questions

Question 1

What is the result of the following expression?

d = {'a': 1}
d.get('b', 0)

Accepted Answer

0. The `get()` method on a dictionary returns the value for the given key if it exists; otherwise, it returns the default value provided as the second argument. Since key `'b'` is not in dictionary `d`, the method returns `0` (the specified default). Option A is correct because `d.get('b', 0)` explicitly supplies a default of `0`.

Answer

None

Answer

KeyError

Answer

1

Question 2

What is the output of the following code?

def div(a, b):
    try:
        return a / b
    except ZeroDivisionError:
        raise ValueError('Invalid division')

try:
    print(div(10, 0))
except ValueError as e:
    print(e)
except ZeroDivisionError:
    print('Zero division')

Accepted Answer

Invalid division. The `div` function catches the `ZeroDivisionError` and raises a `ValueError` with the message 'Invalid division'. The outer `try` block catches this `ValueError` and prints its message, which is 'Invalid division'.

Answer

Error: division by zero

Answer

Zero division

Answer

TypeError

Question 3

What happens when you try to modify a tuple?

t = (1, 2, 3)
t[0] = 0

Accepted Answer

A TypeError is raised. Tuples are immutable, so trying to assign to an index raises a TypeError.

Answer

A IndexError is raised

Answer

The tuple becomes (0, 2, 3)

Answer

The code runs without error

Question 4

What is the output of the following dictionary comprehension?

{x: x**2 for x in range(3)}

Accepted Answer

{0:0, 1:1, 2:4}. The dictionary comprehension `{x: x**2 for x in range(3)}` iterates over `x` values 0, 1, and 2 (from `range(3)`). For each `x`, it creates a key-value pair where the key is `x` and the value is `x**2` (x squared). This produces `{0: 0**2, 1: 1**2, 2: 2**2}`, which evaluates to `{0:0, 1:1, 2:4}`.

Answer

{0:1, 1:2, 2:3}

Answer

{0:0, 1:2, 2:4}

Answer

{1:1, 2:4}

Question 5

What is the output of the following code?

def f():
    try:
        raise ValueError('error1')
    except ValueError:
        raise TypeError('error2')

try:
    f()
except TypeError as e:
    print(e)
except ValueError:
    print('ValueError')

Accepted Answer

error2. The code raises a `ValueError` inside the `try` block of function `f()`, which is caught by the `except ValueError` handler. That handler then raises a new `TypeError('error2')`. This new exception propagates out of `f()` and is caught by the outer `except TypeError as e` block, which prints the exception message `'error2'`.

Answer

Error: unhandled exception

Answer

error1

Answer

ValueError

Question 6

Which THREE of the following are built-in exceptions in Python? (Select three.)

Accepted Answer

StopIteration. StopIteration is a built-in exception in Python that is raised to signal the end of an iterator. It is automatically raised by the __next__() method when there are no further items to iterate over, and is caught by for loops internally to terminate iteration.

Answer

LoopError

Answer

DivisionError

Question 7

Which TWO of the following are valid dictionary methods? (Select two.)

Accepted Answer

keys(). The `keys()` method returns a view object displaying all keys in a dictionary, and `values()` returns a view object of all values. Both are built-in dictionary methods in Python, making them valid for the PCEP exam.

Answer

keyset()

Answer

entries()

Answer

pairs()

Question 8

A developer needs to determine the number of elements in a tuple named 't'. Which code snippet will correctly return the length?

Accepted Answer

len(t). The correct way to determine the number of elements in a tuple in Python is to use the built-in `len()` function, which returns the length (number of items) of any sequence or collection, including tuples. Option C is correct because `len(t)` directly gives the count of elements in tuple `t`.

Answer

t.append(5)

Answer

t[0] = 5

Answer

t.pop()

Question 9

A developer is writing a robust script that must handle file reading errors. The script should catch only I/O-related exceptions (e.g., FileNotFoundError, PermissionError) and let other exceptions propagate. Which exception handling structure is best suited?

Accepted Answer

Use multiple except blocks for specific exception types. Using multiple `except` blocks for specific exception types (e.g., `FileNotFoundError`, `PermissionError`) allows the script to catch only I/O-related exceptions while letting all other exceptions propagate unhandled. This matches the requirement precisely, as each `except` clause targets a distinct exception class, and any unlisted exception will not be caught, preserving the intended error propagation behavior.

Answer

Use a single bare except: clause

Answer

Use except: and then re-raise the exception

Answer

Use except Exception: as the only handler

Question 10

A developer wants to create a tuple containing a single integer value 5. Which code snippet correctly creates such a tuple?

Accepted Answer

t = (5,). A tuple with a single element requires a trailing comma to disambiguate it from a parenthesized expression. Without the comma, Python treats parentheses as grouping operators, not tuple syntax. Thus, `(5,)` creates a tuple containing the integer 5, while `(5)` is just the integer 5.

Answer

t = [5]

Answer

t = (5)

Answer

t = 5

Question 11

A function receives a dictionary that may contain nested dictionaries. The function must modify the dictionary without affecting the original passed argument. Which technique ensures a complete independent copy?

Accepted Answer

Use copy.deepcopy() from the copy module. `copy.deepcopy()` recursively copies all objects within the dictionary, including nested dictionaries, creating a completely independent copy. This ensures modifications to the copy do not affect the original argument, which is required when the dictionary contains mutable nested structures.

Answer

Assign the dictionary to a new variable (e.g., new_dict = original)

Answer

Use copy.copy() on the original dictionary

Answer

Use dict.copy() method

Question 12

Which THREE of the following statements about Python exception handling are correct?

Accepted Answer

The finally block always runs.. The `finally` block in Python is guaranteed to execute regardless of whether an exception occurred, was caught, or even if the `try` block contains a `return`, `break`, or `continue` statement. This ensures cleanup actions like closing files or releasing resources always run.

Answer

You must have at least one except block if you have a finally block.

Answer

A try block must have at least one except block.

Question 13

A support technician is running a Python script that parses a configuration file and stores key-value pairs in a dictionary called 'config'. The script then uses these values to set application parameters. The configuration file is optional, and some expected keys may be missing. Currently, the script crashes with a KeyError when accessing a missing key. The technician needs to modify the script to safely retrieve a value or return 'N/A' if a key is missing. The script must remain efficient and readable. Which modification best achieves this?

Accepted Answer

Use config.get(key, 'N/A') instead of direct key access. `dict.get(key, default)` is the idiomatic Python method for safely retrieving a value from a dictionary without raising a `KeyError`. It returns the default value `'N/A'` when the key is missing, which directly solves the crash while keeping the code concise and readable. This approach is more efficient than exception handling or explicit membership checks because it performs a single hash lookup.

Answer

Wrap each access in a try-except block to catch KeyError and assign 'N/A'

Answer

Use if key in config: value = config[key] else: value = 'N/A'

Answer

Use config.setdefault(key, 'N/A') before accessing

Question 14

A junior developer wrote a function that calculates the average of a list of numbers. Inside the function, they used a variable named 'list' to store the input parameter. Later, they tried to call the built-in list() function to convert a string to a list inside the same function, but it raised a TypeError. The error occurs because the name 'list' now refers to the parameter, not the built-in. The function must be fixed without changing its external behavior. Which solution is the best practice?

Accepted Answer

Rename the local variable to something else, like 'lst' or 'data'. The best practice is to avoid shadowing built-in names. By renaming the parameter from 'list' to something like 'lst' or 'data', the built-in list() function remains accessible, and the function's external behavior is unchanged. This approach is simple, readable, and follows Python's naming conventions.

Answer

Use the global keyword to refer to the built-in list

Answer

Use the builtins module (import builtins; builtins.list()) to call the built-in

Answer

Remove the local variable and use the input parameter directly

Question 15

A critical automation system uses a try-except block to handle errors during file operations. The current code uses a bare except: clause to catch any error and perform cleanup. However, when an operator tries to stop the program with Ctrl+C, the KeyboardInterrupt exception is caught, and the cleanup routine runs, preventing a clean exit. Additionally, if the system runs out of memory, MemoryError is caught. The developers need to modify the exception handling so that system-exiting exceptions (such as KeyboardInterrupt and SystemExit) are not caught, but other exceptions (e.g., FileNotFoundError, PermissionError) are still handled for cleanup. Which modification best achieves this?

Accepted Answer

Change the bare except: to except Exception:. Changing the bare `except:` to `except Exception:` ensures that only exceptions inheriting from the built-in `Exception` class are caught. System-exiting exceptions like `KeyboardInterrupt` and `SystemExit` inherit from `BaseException` directly, not from `Exception`, so they will propagate uncaught, allowing a clean exit. This preserves the cleanup behavior for file-related errors such as `FileNotFoundError` and `PermissionError`, which are subclasses of `Exception`.

Answer

Remove the except block entirely and rely on a finally block for cleanup

Answer

Replace the single except block with multiple specific except blocks for each expected file error

Answer

Define a custom exception class and raise it for all file errors