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

Question 1

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?

Choose an answer to begin — your selection is scored in the full session.

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 2

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 3

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 4

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.

Question 5

Which THREE of the following are valid ways to handle an exception in Python?

Accepted Answer

Using a `try` block with both `except` and `finally` blocks.. Option A is correct because a `try` statement may combine `except` and `finally` clauses, where `except` handles matching exceptions and `finally` runs cleanup code regardless of whether an exception occurred. Option D is correct because a `try` block with only a `finally` clause is valid Python syntax; it provides guaranteed cleanup but does not itself catch or handle the exception, which then propagates after `finally` executes. Option E is correct because the canonical exception-handling form is `try` with one or more `except` clauses, each optionally specifying an exception type, that catch and process matching exceptions. Option B is not valid because `finally` must be attached to a `try` statement and cannot stand alone. Option C is not valid because an `else` clause in a `try` statement requires at least one preceding `except` clause; `try`/`else` without `except` is a syntax error.

Answer

Using a `finally` block without a `try` block.

Answer

Using a `try` block with an `else` block but no `except` block.

Question 6

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 7

What is the output of the code?

Accepted Answer

An unhandled ZeroDivisionError is raised.. The code divides by zero, which raises a ZeroDivisionError. The try-except block does not catch ZeroDivisionError (it catches a different exception or does not have an appropriate except clause), so the exception is unhandled, causing the program to terminate with a traceback. The output is not None; an unhandled exception is raised.

Answer

None

Answer

inf

Answer

2.0

Question 8

What is the output of this code?

Accepted Answer

RuntimeError: dictionary changed size during iteration. Modifying a dictionary's size (adding or deleting keys) during iteration over its keys, values, or items raises a RuntimeError. In this code, the loop iterates over the dictionary's keys while deleting them, which changes the dictionary's size and triggers the exception.

Answer

{}

Answer

{'b': 2}

Answer

{'a': 1, 'c': 3}

Question 9

You are a developer for a financial application that processes transactions. The application uses a dictionary to store account balances where keys are account numbers (strings) and values are floats. A function `transfer(from_acc, to_acc, amount)` is supposed to subtract amount from `from_acc` and add it to `to_acc`. However, some transfers are resulting in incorrect balances: the `from_acc` balance is reduced but the `to_acc` balance is not increased. The code uses `try-except` to catch KeyError if an account does not exist. Upon inspection, the function first checks if both accounts exist, then performs subtraction, then addition, and finally returns success. No exceptions are raised during the problematic transfers. The accounts definitely exist. What is the most likely cause?

Accepted Answer

The dictionary is being modified concurrently by multiple threads or processes without synchronization, leading to race conditions.. The described symptom — the `from_acc` balance is reduced but the `to_acc` balance is not increased — is a classic race condition. In Python, dictionary operations like `dict[key] -= amount` are not atomic; they involve a read, modify, and write sequence. If two threads execute the transfer function concurrently on overlapping accounts, one thread's write to `to_acc` can be overwritten by another thread's stale read, causing the addition to be lost. The `try-except` only catches `KeyError`, not data races, and since no exception is raised, the only plausible explanation is unsynchronized concurrent access.

Answer

The function catches KeyError and silently returns without completing the transfer.

Answer

The function does not check if the from_acc has sufficient balance before subtracting.

Answer

The balances are stored as strings instead of floats, causing concatenation instead of arithmetic.

Question 10

A team is building a configuration parser that reads a file containing key=value pairs. They use a dictionary to store the configuration. The parser function `load_config(filename)` opens the file, reads line by line, splits on '=', and populates a dictionary. Some lines have comments starting with '#'. The developer wants to ensure that the dictionary is not polluted with comment lines. They write: `if line.startswith('#'): continue`. However, after parsing, the dictionary contains an entry with key '#' because some lines have no '=' sign. For example, a line like `#comment` is being added as a key with value None. The developer wants to fix this. Which modification should be made?

Accepted Answer

Check `if '=' not in line: continue` before splitting.. The core issue is that lines without an '=' sign (like `#comment`) are still processed by the split, causing the entire line to become a key with no value. By explicitly checking `if '=' not in line: continue` before splitting, the developer ensures that only lines containing a key-value separator are added to the dictionary, effectively filtering out comment lines and any other malformed lines.

Answer

Use `key, value = line.split('=', 1)` and catch ValueError if less than two parts.

Answer

Strip the line of whitespace before checking for comments.

Answer

Replace `startswith('#')` with `line.lstrip().startswith('#')` and also skip empty lines.

Question 11

Match each Python function to its description.

Accepted Answer

len: Returns the number of items in an object. These are common built-in Python functions. len() returns length, print() outputs, int() converts to integer, str() converts to string, and input() reads user input.

Answer

str: Returns the length of a string

Answer

input: Outputs data to the console

Question 12

Match each Python string method to its action.

Accepted Answer

.upper(): Returns a copy of the string converted to uppercase. These are common string methods used for text manipulation. Correct matches: .upper() converts to uppercase, .lower() to lowercase, .strip() removes leading/trailing whitespace, .split() splits into a list. The distractors swap definitions to test understanding.

Answer

.upper(): Splits the string into a list of substrings

Answer

.strip(): Returns a copy of the string converted to uppercase

Question 13

A developer writes a function that should return the sum of two numbers, but the code returns 0 instead. What is the most likely cause?

def add(a, b):
    result = a + b

print(add(3, 4))

Accepted Answer

The function does not have a return statement.. The function `add` computes `a + b` and assigns it to `result`, but lacks a `return` statement. In Python, a function without an explicit `return` automatically returns `None`. When `print(add(3, 4))` is executed, it prints `None`, not the sum. The question states the code returns 0, which is a common misreading — the actual output is `None`, but the core issue is the missing `return`.

Answer

The function is not defined before the call.

Answer

The variable 'result' is not defined.

Answer

The function parameters are of incompatible types.

Question 14

Based on the exhibit, where did the exception originate?

Accepted Answer

At line 5 in the divide function inside app.py.. The exception (ZeroDivisionError) originates at line 5 inside the divide function in app.py, where the code attempts to divide by zero. The traceback shows the innermost frame first, indicating the exact line where the error was raised.

Answer

In the main module outside any function.

Answer

In the ZeroDivisionError exception handler.

Answer

At line 10 in app.py, where the function was called.

Question 15

What is the output of the code in the exhibit?

Accepted Answer

{'apple':5, 'banana':6, 'cherry':6}. The code creates a dictionary using the `dict()` constructor with a list of tuples. Each tuple is a key-value pair. The keys are strings ('apple', 'banana', 'cherry') and the values are integers (5, 6, 6). The resulting dictionary is {'apple':5, 'banana':6, 'cherry':6}.

Answer

{5:'apple', 6:'banana', 6:'cherry'}

Answer

{'apple':5, 'banana':7, 'cherry':6}

Answer

{0:'apple', 1:'banana', 2:'cherry'}