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

Question 1

What is the output of the code?

Accepted Answer

Key not found. The code uses a dictionary's `get()` method with a default value of 'Key not found'. When the key 'b' is not present in the dictionary `d`, `get()` returns the specified default instead of raising an exception. Therefore, the output is 'Key not found', making option D correct.

Answer

AttributeError

Answer

The program exits with no output

Answer

None

Question 2

Refer to the exhibit. What exception is raised when this code is executed?

Accepted Answer

ZeroDivisionError. The code attempts to divide by zero, which raises a ZeroDivisionError in Python. This is a specific exception for division or modulo operations where the divisor is zero, and it is a subclass of ArithmeticError.

Answer

ValueError

Answer

ArithmeticError

Answer

TypeError

Question 3

Refer to the exhibit. What happens when this code is executed?

Accepted Answer

RuntimeError: dictionary changed size during iteration. Modifying a dictionary (adding or deleting keys) while iterating over it with a for loop raises a RuntimeError in Python. The code attempts to delete keys from the dictionary `d` during iteration, which changes the dictionary's size and triggers the error before 'done' is printed.

Answer

Prints 'done' with no error

Answer

KeyError: 'a'

Answer

Nothing; the code runs silently

Question 4

A function returns a tuple. Which code correctly unpacks the tuple?

def min_max(numbers):
    return min(numbers), max(numbers)

result = min_max([3, 1, 2])

Accepted Answer

(a, b) = result. Both options B and C correctly unpack the tuple. Option B uses explicit parentheses, while option C uses the implicit form — both are valid tuple unpacking syntax in Python. Option A unpacks via indexing (not tuple unpacking), and option D incorrectly swaps the values.

Answer

a = result[0]; b = result[1]

Answer

a = result[1]; b = result[0]

Question 5

Which code sorts a list of strings by their length in descending order?

lst = ['aa', 'b', 'ccc']

Accepted Answer

sorted(lst, key=len, reverse=True). `sorted(lst, key=len, reverse=True)` sorts the list by string length in descending order. Although option C (`sorted(lst, key=lambda s: len(s), reverse=True)`) would also produce the same result, this single-answer question expects the most straightforward and Pythonic solution, which is using the built-in `len` function directly without an unnecessary lambda. Option B sorts alphabetically in reverse order, not by length. Option D sorts by length in ascending order.

Answer

sorted(lst, reverse=True)

Answer

sorted(lst, key=lambda s: len(s), reverse=True)

Answer

sorted(lst, key=lambda s: len(s))

Question 6

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 7

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 8

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 9

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 10

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 11

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 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

A large e-commerce platform uses a Python function to calculate the average rating from a tuple of customer ratings. The function is called thousands of times per second with the same ratings tuple (which is static across many calls). The function currently computes sum(ratings) / len(ratings) each time, causing a performance bottleneck. The development team wants to optimize the function without changing its signature (it still takes the tuple as argument). They also want to avoid using global variables or external libraries. Which approach best optimizes the function?

Accepted Answer

Use a local variable with a simple cache (dictionary) to store sums and lengths for previously seen tuples. It implements memoization: a local dictionary caches the sum and length for each tuple key, avoiding repeated computation of sum() and len() for the same static tuple. This reduces time complexity from O(n) per call to O(1) after the first call, without using globals or external libraries, and without changing the function signature.

Answer

Store the sum and length in global variables

Answer

Use the tuple as is; Python internally optimizes repeated sum() calls

Answer

Convert the tuple to a list and use list operations

Question 15

A network configuration tool stores device settings in a dictionary where each setting key may have multiple values from different configuration sources. For example, the key 'dns_servers' might have values from the DHCP server and manual configuration. The current implementation simply assigns values: settings[key] = value. If the same key appears multiple times, only the last value is kept, losing previous values. The developer must modify the data structure so that all values for a key are preserved. The solution should be efficient for both adding new values and accessing all values for a key. Which modification is best?

Accepted Answer

Use a dictionary of lists with a default factory (e.g., collections.defaultdict(list)). `collections.defaultdict(list)` automatically creates a new list for each new key, allowing multiple values to be appended without overwriting. This preserves all values for a key while providing O(1) average-time access to the list of values, meeting the efficiency requirement for both adding and retrieving.

Answer

Use a set for each value to avoid duplicates

Answer

Use a list for each value, and append new values to the list

Answer

Use a tuple for each value, converting to list when needed