PCEP Functions, Tuples, Dictionaries and Exceptions — 15 Questions

Question 1

Which THREE of the following dictionary methods return a view object that changes when the dictionary changes?

Accepted Answer

`dict.keys()`. C, and E because dict.keys(), dict.values(), and dict.items() all return view objects in Python 3. A view object provides a dynamic view of the dictionary's entries, meaning it reflects changes made to the dictionary. dict.get() returns a single value, not a view. dict.copy() returns a shallow copy, not a view. Therefore, there are three methods that return view objects.

Answer

`dict.get()`

Answer

`dict.copy()`

Question 2

A function is defined as: def func(*args, **kwargs): print(args, kwargs). It is called as func(1, 2, a=3, b=4). What is printed?

Accepted Answer

(1, 2) {'a': 3, 'b': 4}. The function uses `*args` to capture positional arguments into a tuple and `**kwargs` to capture keyword arguments into a dictionary. When called as `func(1, 2, a=3, b=4)`, `args` becomes `(1, 2)` and `kwargs` becomes `{'a': 3, 'b': 4}`, so `print(args, kwargs)` outputs `(1, 2) {'a': 3, 'b': 4}`. Option B is correct because it matches this exact output.

Answer

(1, 2, a=3, b=4)

Answer

TypeError

Answer

[1, 2] {'a': 3, 'b': 4}

Question 3

A developer wants to raise a ValueError with a custom message when a negative number is passed. Which code is correct?

Accepted Answer

raise ValueError("Negative input not allowed"). In Python, raising an exception with a custom message requires passing the message as an argument to the exception constructor: `raise ValueError("Negative input not allowed")`. This creates a ValueError instance with the specified message, which is the standard and only syntactically valid way to include a custom message in a raise statement.

Answer

raise ValueError "Negative input not allowed"

Answer

raise ValueError() + "Negative input not allowed"

Answer

raise new ValueError("Negative input not allowed")

Question 4

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 5

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 6

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 7

Refer to the exhibit. What is the output of Line C?

Accepted Answer

33. Line C calls the function `func` with arguments `a=10` and `b=20`. Inside the function, `x` is assigned the value of `a` (10), and `y` is assigned the value of `b` (20). The function then returns `x + y + 3`, which is `10 + 20 + 3 = 33`. Therefore, the output is 33.

Answer

TypeError

Answer

30

Answer

10

Question 8

A developer writes a function to calculate the average of a list of numbers, but the function sometimes returns a wrong result when the list contains non-numeric values. What is the best way to handle this?

Accepted Answer

Check that all items are numeric before calculation, and raise TypeError otherwise.. It explicitly validates that all items are numeric before performing the calculation, raising a TypeError if any non-numeric value is found. This follows Python's principle of explicit error handling and ensures the function's contract is clear: it only works with numeric data. Returning None (A) or silently ignoring values (B) can lead to subtle bugs, while converting to strings (C) would produce a concatenated string, not an average.

Answer

Return None if any non-numeric value is encountered.

Answer

Use try-except to ignore non-numeric values and proceed with the remaining numbers.

Answer

Convert all values to string and concatenate them.

Question 9

A Python script uses a dictionary to store user session data. The developer writes `user = {'id': 101, 'name': 'Alice'}` and later tries to access `user['email']`. What is the outcome?

Accepted Answer

It raises a KeyError.. In Python, accessing a dictionary key that does not exist raises a KeyError. The dictionary `user` contains only the keys 'id' and 'name', so `user['email']` triggers a KeyError because the key 'email' is not present. This is a fundamental behavior of Python dictionaries, which do not return default values for missing keys unless a method like `.get()` is used.

Answer

It returns an empty string.

Answer

It returns None.

Answer

It checks the 'in' operator automatically and returns False.

Question 10

A server logs are stored as a list of tuples: `logs = [('2024-01-10', 'INFO', 'Started'), ('2024-01-10', 'ERROR', 'Disk full')]`. A developer wants to count how many ERROR logs exist. Which code snippet correctly counts them?

Accepted Answer

count = sum(log[1] == 'ERROR' for log in logs). Uses a generator expression with `sum()` to count how many tuples in the `logs` list have the second element equal to `'ERROR'`. The expression `log[1] == 'ERROR'` evaluates to `True` (which is treated as 1) or `False` (0) for each tuple, and `sum()` adds them up, giving the correct count of ERROR logs.

Answer

count = logs.count(('ERROR',))

Answer

count = [log for log in logs if log[1] == 'ERROR']

Answer

count = len(logs)

Question 11

A function `def process(data):` modifies the dictionary passed as argument by adding a new key. The developer wants to avoid modifying the original dictionary. What should the function do?

Accepted Answer

Create a copy of the dictionary at the start: `data = data.copy()`. Dictionaries are mutable objects in Python, so passing a dictionary to a function passes a reference to the same object. Calling `data.copy()` creates a shallow copy of the dictionary, allowing the function to modify the copy without affecting the original dictionary. This is the standard Pythonic way to avoid side effects on mutable arguments.

Answer

Add the key, then delete it at the end.

Answer

Modify directly; changes to mutable objects are local only.

Answer

Convert the dictionary to a tuple before processing.

Question 12

A developer writes a function that returns multiple values as a tuple. Which of the following is a valid way to unpack the result into separate variables?

Accepted Answer

a, b = func(). When a function returns multiple values as a tuple, Python allows tuple unpacking directly in an assignment statement. The syntax `a, b = func()` automatically unpacks the two-element tuple into the variables `a` and `b`, which is the standard and most Pythonic way to handle such a return.

Answer

result = func(); a, b = result[0], result[1]

Answer

a, b, c = func()

Answer

a = func()[0]; b = func()[1]

Question 13

A Python script processes a list of tuples representing coordinates: `points = [(1,2), (3,4), (5,6)]`. The developer wants to create a dictionary mapping each coordinate to its distance from origin. Which code correctly creates the dictionary?

Accepted Answer

distances = {}; for point in points: distances[point] = (point[0]**2 + point[1]**2)**0.5. Options B and C are both correct. Option B uses a for loop to compute the Euclidean distance with the square root and inserts it into a dictionary. Option C achieves the same result with a dictionary comprehension. Both produce a dictionary mapping each coordinate tuple to its distance from the origin.

Answer

distances = {}; for point in points: distances[point] = (point[0]**2 + point[1]**2)

Answer

distances = {point: point[0]**2 + point[1]**2 for point in points}

Answer

distances = [(point, (point[0]**2 + point[1]**2)**0.5) for point in points]

Question 14

A developer writes a function that takes a tuple as an argument and tries to modify an element inside the tuple. What happens?

Accepted Answer

The code raises a TypeError.. Tuples in Python are immutable, meaning their elements cannot be changed after creation. Attempting to modify an element (e.g., `my_tuple[0] = 5`) raises a `TypeError` because the tuple object does not support item assignment. This is a fundamental property of the tuple data type.

Answer

The tuple is converted to a list automatically.

Answer

The first element is modified successfully.

Answer

The code raises a ValueError.

Question 15

A script uses a dictionary to store counts of words. The code `counts['apple'] += 1` raises a KeyError the first time because the key doesn't exist. Which approach best solves this?

Accepted Answer

Use `counts.setdefault('apple', 0)` then increment.. `setdefault('apple', 0)` inserts the key with a default value of 0 if it does not exist, then returns the value (0). After that, `counts['apple'] += 1` increments safely. This avoids a KeyError without requiring an explicit check or exception handling, making it the most concise and Pythonic approach for initializing missing dictionary keys.

Answer

Use `try-except` to catch KeyError and then set the key.

Answer

Use `counts['apple'] = counts.get('apple') + 1`

Answer

Use `if 'apple' in counts:` before incrementing.