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

Question 1

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 2

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 3

Which TWO of the following are valid ways to create a tuple containing the elements 1 and 2? (Select two.)

Accepted Answer

tuple([1, 2]). `tuple([1, 2])` calls the `tuple()` constructor with a list `[1, 2]` as an argument, which converts the list into a tuple `(1, 2)`. Option E is correct because `(1, 2)` is the literal syntax for a tuple containing the elements 1 and 2.

Answer

(1)

Answer

[1, 2]

Answer

int(1)

Question 4

Refer to the exhibit. What type of exception occurred?

Accepted Answer

ZeroDivisionError. The code attempts to divide by zero (e.g., `10 / 0`), which raises a `ZeroDivisionError` in Python. This is a specific built-in exception for division or modulo operations where the divisor is zero.

Answer

TypeError

Answer

ValueError

Answer

ArithmeticError

Question 5

Refer to the exhibit. What is the output?

Accepted Answer

[1] [2] [1, 3]. The function uses a mutable default argument `lst=[]`. On the first call, `append_to_list(1)` uses the default list and appends 1, returning `[1]`. On the second call, `append_to_list(2, [])` passes an explicit empty list, so it appends 2 to that new list, returning `[2]`. On the third call, `append_to_list(3)` uses the default list again, which now contains `[1]` from the first call, so appending 3 yields `[1, 3]`. Thus the output is `[1] [2] [1,3]` printed on separate lines.

Answer

[1] [2] [3]

Answer

Error: default argument is mutable

Answer

[1] [1, 2] [1, 2, 3]

Question 6

Refer to the exhibit. What is the output?

Accepted Answer

1 2 (3, 4) {'x': 5, 'y': 6}. The code uses a tuple (3, 4) and a dictionary {'x': 5, 'y': 6} as arguments to the print() function. The print() function outputs each argument separated by a space, so the tuple is printed as (3, 4) and the dictionary as {'x': 5, 'y': 6}, preceded by 1 and 2. Option D correctly shows this output.

Answer

1 2 [3, 4] {'x': 5, 'y': 6}

Answer

1 2 (3, 4) {}

Answer

1 2 3 4 5 6

Question 7

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 8

A function is designed to process a list and returns a modified list. The developer wants to avoid unintended side effects on the original list when it is passed as an argument. Which approach best ensures the original list remains unchanged?

Accepted Answer

Use None as default and create a new list inside the function. Using `None` as a default parameter and creating a new list inside the function ensures that the original list passed as an argument is never mutated. In Python, default arguments are evaluated only once at function definition time, so using a mutable default like an empty list can cause unintended side effects across multiple calls. By creating a new list inside the function (e.g., `result = list(original)`), the function operates on a copy, leaving the original list unchanged.

Answer

Use a tuple as default

Answer

Use an empty list as default

Answer

Use a global variable as default

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 script counts occurrences of words in a text file. The current code uses: if word in count_dict: count_dict[word] += 1 else: count_dict[word] = 1. Which alternative is more concise and Pythonic?

Accepted Answer

count_dict[word] = count_dict.get(word, 0) + 1. `dict.get(word, 0)` returns the current count for `word` (or 0 if missing), then adds 1 and assigns back. This replaces the explicit `if/else` with a single line, making the code more concise and Pythonic while preserving the same logic.

Answer

Use collections.Counter

Answer

count_dict[word] = count_dict[word] + 1

Answer

count_dict.setdefault(word, 0); count_dict[word] += 1

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 TWO of the following are valid ways to merge two dictionaries in Python 3.5+? (Assume dict1 = {'a':1} and dict2 = {'b':2})

Accepted Answer

dict1.update(dict2). `dict1.update(dict2)` merges `dict2` into `dict1` in-place, updating existing keys and adding new ones. Option E is correct because `{**dict1, **dict2}` uses dictionary unpacking to create a new merged dictionary, available since Python 3.5.

Answer

dict1 | dict2

Answer

dict1 + dict2

Answer

dict1.merge(dict2)

Question 13

Which THREE of the following are characteristics of Python tuples?

Accepted Answer

They are hashable. Tuples are immutable sequences, and immutability is a key requirement for an object to be hashable in Python. A hashable object must have a hash value that never changes during its lifetime, which allows it to be used as a dictionary key or set member. Since tuples cannot be modified after creation, they satisfy this requirement, provided all their elements are also hashable.

Answer

They are mutable

Answer

They support item assignment

Question 14

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 15

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