PCEP Functions, Tuples, Dictionaries and Exceptions — Timed 15 Questions

Question 1

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.. Option D is correct because 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 2

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 3

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). Option B 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 4

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()`. Option A is correct because 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 5

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(). Option D is correct because 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 6

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 = {point: (point[0]**2 + point[1]**2)**0.5 for point in points}. Option C is correct because it uses a dictionary comprehension to map each tuple (coordinate) to its Euclidean distance from the origin, calculated as `(point[0]**2 + point[1]**2)**0.5`. This correctly produces a dictionary with tuples as keys and float distances as values, matching the requirement exactly.

Answer

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

Answer

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

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 7

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 8

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.. Option A is correct because `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 9

Which TWO of the following statements about tuples in Python are true?

Accepted Answer

Tuples can be used as dictionary keys if all elements are hashable.. Option B is correct because tuples can be used as dictionary keys only when all of their elements are hashable. Since tuples themselves are immutable, their hash value depends on the hash values of their elements; if any element is unhashable (e.g., a list), the tuple itself becomes unhashable and cannot be used as a key.

Answer

Tuples are always hashable.

Answer

Tuples do not support indexing.

Answer

Tuples can only contain immutable objects.

Question 10

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 Python's exception handling allows a `try` block to be followed by both `except` and `finally` blocks. The `except` block catches specific exceptions, while the `finally` block always executes (for cleanup), regardless of whether an exception occurred. This combination is fully valid and commonly used for robust resource management.

Answer

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

Answer

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

Question 11

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

Accepted Answer

`dict.keys()`. A is correct because `dict.keys()` returns a view object that dynamically reflects changes made to the dictionary. When the dictionary is updated, the view object automatically updates to show the new keys, making it a live view rather than a static copy.

Answer

`dict.get()`

Answer

`dict.copy()`

Answer

`dict.items()`

Question 12

What is the output of the code?

Accepted Answer

None. Option A is correct because the code attempts to divide an integer by zero (2 / 0), which in Python raises a ZeroDivisionError. Since there is no try-except block to handle this exception, the program crashes before any value is assigned or returned, so the output is None (the default return value of a function that does not execute successfully).

Answer

inf

Answer

2.0

Answer

An unhandled TypeError is raised.

Question 13

What is the output of this code?

Accepted Answer

RuntimeError: dictionary changed size during iteration. Option A is correct because 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 14

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.. Option A is correct because 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 15

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.. Option C is correct because 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.