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

Question 1

A developer is working with a dictionary `d = {'a': 1, 'b': 2, 'c': 3}` and needs to retrieve the value associated with a key without causing a KeyError if the key is missing. Which two approaches correctly achieve this? (Choose two.)

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

Accepted Answer

value = d['d'] if 'd' in d else 0. The get method and the conditional expression both safely retrieve a value or return a default without modifying the dictionary or raising a KeyError. The pop and setdefault methods also avoid KeyError but mutate the dictionary, which is not specified. Direct indexing raises KeyError when the key is missing.

Answer

value = d.setdefault('d', 0)

Answer

value = d['d']

Answer

value = d.pop('d', 0)

Question 2

A monitoring tool parses a tuple `reading = (21.5, 'celsius', 'sensor-7')` and the developer wants to unpack it into three descriptive variables in a single statement. Which two statements unpack this tuple correctly? (Choose two.)

Accepted Answer

value, unit, *source = reading. Tuple unpacking requires the number of targets to match the tuple length, unless a single starred target collects the remainder into a list. A plain three-name assignment and a starred variant both succeed for this three-element reading, while mismatched name counts raise ValueError and semicolon-separated names do not unpack at all.

Answer

value; unit; source = reading

Answer

value, unit = reading

Answer

value, unit, source, extra = reading

Question 3

A developer is writing a function that must safely retrieve a value from a dictionary without raising a KeyError if the key is missing. The function should return a default value instead. Which TWO approaches correctly achieve this? (Choose two.)

Accepted Answer

Use the dictionary's get method with a default argument, such as d.get(key, default_value).. The get method retrieves a value with a fallback and never raises KeyError. A try-except block catching KeyError also safely handles missing keys by returning a default. Both are standard patterns for safe dictionary access. The other options either mutate the dictionary or are not valid for safe retrieval without side effects. The scenario requires returning a default without altering the dictionary.

Answer

Use the dictionary's setdefault method, such as d.setdefault(key, default_value).

Answer

Use the in operator to check if the key exists, then access it directly, such as if key in d: return d[key] else: return default.

Answer

Use the dictionary's pop method with a default, such as d.pop(key, default_value).

Question 4

A developer is building a simple inventory system for a small retail shop. They have a dictionary named `stock` that maps product names to quantities, and they need to add a new product `'widget'` with a quantity of 10. If `'widget'` already exists in the dictionary, they want to increase the existing quantity by 10. Which of the following code snippets will accomplish this correctly?

Accepted Answer

stock['widget'] = stock.get('widget', 0) + 10. The correct approach uses the `get` method with a default of 0 to safely retrieve the current quantity, adds 10, and assigns it back to the key. This handles both the case where the product is new and where it already exists, avoiding a `KeyError`. The other options either raise errors or fail to update the dictionary value.

Answer

stock.setdefault('widget', 0) + 10

Answer

stock.update('widget', stock.get('widget', 0) + 10)

Answer

stock['widget'] = stock['widget'] + 10

Question 5

A developer is writing a function that accepts a dictionary and needs to safely retrieve a value for a given key, returning a default if the key is missing. They also want to iterate over all key-value pairs. Which TWO of the following approaches correctly achieve safe retrieval or iteration? (Choose two.)

Accepted Answer

value = data[key] if key in data else default. The dict.get method and the conditional expression using the in operator both safely retrieve a value without raising an exception or mutating the dictionary. They provide a default when the key is absent. The other options either mutate the dictionary (pop and setdefault) or only handle iteration without addressing safe retrieval. Thus, the two correct approaches are get and the in-based conditional.

Answer

value = data.pop(key, default)

Answer

value = data.setdefault(key, default)

Answer

for key, value in data.items(): print(key, value)

Question 6

A developer is writing a function that processes a dictionary of user settings. The function should return the value for a given key, but if the key is missing, it should return a default string 'Not specified' and also add the key with that default value to the dictionary for future use. Which code snippet accomplishes this?

Accepted Answer

return settings.setdefault(key, 'Not specified'). The `setdefault` method is designed for this exact scenario: it returns the value if the key exists, otherwise inserts the key with the default and returns the default. This combines retrieval and insertion in one step. The other options either do not insert the key or are more verbose and less efficient.

Answer

settings[key] = settings.get(key, 'Not specified')
return settings[key]

Answer

return settings.get(key, 'Not specified')

Answer

if key in settings:
    return settings[key]
else:
    settings[key] = 'Not specified'
    return 'Not specified'

Question 7

A developer defines a function to calculate the total cost of items in a shopping cart, applying a discount only if the cart total exceeds 100. The function must also handle the case where the cart is empty by returning 0. Which function definition best meets these requirements?

Accepted Answer

def calculate_total(items, discount=0.1):
    if not items:
        return 0
    total = sum(items)
    if total > 100:
        total -= total * discount
    return total. The correct function must explicitly return 0 for an empty cart and apply the discount only when the total is greater than 100. The chosen definition includes an empty-cart check, uses strict greater-than for the discount condition, and applies the discount correctly. The other options either mishandle the threshold or omit the explicit empty-cart handling, making them less suitable for the stated requirements.

Answer

def calculate_total(items, discount=0.1):
    if len(items) == 0:
        return 0
    total = sum(items)
    if total >= 100:
        total -= total * discount
    return total

Answer

def calculate_total(items, discount=0.1):
    if not items:
        return 0
    total = sum(items)
    total -= total * discount
    return total

Answer

def calculate_total(items, discount=0.1):
    total = sum(items)
    if total > 100:
        total -= total * discount
    return total

Question 8

A developer writes a function that reads a configuration file and returns a dictionary of settings. The function may raise a `FileNotFoundError` if the file is missing, or a `ValueError` if the file content is malformed. The developer wants to call this function and, if either error occurs, print a specific message and use an empty dictionary as a fallback. Which try-except block correctly implements this?

Accepted Answer

try:
    config = read_config()
except FileNotFoundError:
    print('File missing')
    config = {}
except ValueError:
    print('Malformed')
    config = {}. To handle multiple exceptions with different messages, use separate except clauses for each exception type. This ensures that each error triggers the appropriate message and fallback. A bare except would catch too much, and a single tuple except would not differentiate messages.

Answer

try:
    config = read_config()
except FileNotFoundError or ValueError:
    print('Error')
    config = {}

Answer

try:
    config = read_config()
except FileNotFoundError:
    print('File missing')
    config = {}
except:
    print('Malformed')
    config = {}

Answer

try:
    config = read_config()
except (FileNotFoundError, ValueError):
    print('Error')
    config = {}

Question 9

A developer is writing a Python program that reads data from a file. The code includes a `try` block that opens the file and reads its contents. They want to handle specific exceptions that might occur: `FileNotFoundError` if the file does not exist, and `PermissionError` if the file cannot be accessed due to permissions. They also want to handle any other unexpected exceptions by printing a generic error message. Which TWO of the following code structures correctly implement this exception handling? (Choose two.)

Accepted Answer

try:
    # file operations
except FileNotFoundError:
    print('File not found')
except PermissionError:
    print('Permission denied')
except Exception:
    print('An unexpected error occurred'). The correct structures handle `FileNotFoundError` and `PermissionError` with separate except clauses, then provide a catch-all for other exceptions. Using separate clauses allows specific handling for each. The catch-all can be either `except Exception:` or a bare `except:`; both catch other exceptions, though bare except is broader and generally discouraged. The two correct options are those that separate the specific exceptions and include a catch-all.

Answer

try:
    # file operations
except FileNotFoundError:
    print('File not found')
except PermissionError:
    print('Permission denied')
except BaseException:
    print('An unexpected error occurred')

Answer

try:
    # file operations
except (FileNotFoundError, PermissionError):
    print('File error')
except Exception as e:
    print(f'An unexpected error occurred: {e}')

Answer

try:
    # file operations
except (FileNotFoundError, PermissionError):
    print('File error')
except Exception:
    print('An unexpected error occurred')

Question 10

A developer is writing a function that accepts a tuple of numbers and must return a new tuple containing only the even numbers from the input, preserving order. Which TWO of the following approaches correctly achieve this? (Choose two.)

Accepted Answer

def evens(numbers):
    return tuple(num for num in numbers if num % 2 == 0). The two correct approaches must return a new tuple containing only even numbers in the original order. Building a tuple via concatenation and using a generator expression inside tuple() both satisfy this. The other options either return a list, attempt to modify an immutable tuple, or filter for odd numbers instead of even numbers.

Answer

def evens(numbers):
    result = []
    for num in numbers:
        if num % 2 == 0:
            result.append(num)
    return tuple(result)

Answer

def evens(numbers):
    return tuple(filter(lambda x: x % 2 == 0, numbers))

Answer

def evens(numbers):
    for num in numbers:
        if num % 2 != 0:
            numbers.remove(num)
    return numbers

Question 11

A developer is working with a function that accepts a dictionary as an argument. The function modifies the dictionary by adding a new key-value pair. The developer wants to ensure that the original dictionary passed to the function is not modified. Which of the following approaches will achieve this?

Accepted Answer

Pass a copy of the dictionary to the function, such as `func(my_dict.copy())`.. To prevent a function from modifying the original dictionary, the caller should pass a copy of the dictionary. The `copy()` method creates a shallow copy, so modifications to the copy do not affect the original. The other options either do not create a copy or misunderstand dictionary mutability.

Answer

Inside the function, assign the parameter to a new variable before modifying it, like `local_dict = param_dict`.

Answer

Dictionaries are immutable, so the original dictionary cannot be modified by the function.

Answer

Use the `dict()` constructor inside the function to create a new dictionary from the parameter, like `local_dict = dict(param_dict)`.

Question 12

A developer is building a function that accepts a dictionary and a key, and returns the value associated with the key. If the key is not present, the function should return the string 'Not found' without raising an exception. Which implementation correctly achieves this?

Accepted Answer

def get_value(data, key):
    try:
        return data[key]
    except KeyError:
        return 'Not found'. The correct implementation must return the value if the key exists and 'Not found' if it does not, without modifying the dictionary or catching unrelated exceptions. Using a try-except block that catches only KeyError achieves this safely and explicitly. The other options either modify the dictionary, handle exceptions too broadly, or misinterpret None values.

Answer

def get_value(data, key):
    return data.get(key, 'Not found')

Answer

def get_value(data, key):
    try:
        return data[key]
    except:
        return 'Not found'

Answer

def get_value(data, key):
    if key in data:
        return data[key]
    else:
        return 'Not found'

Question 13

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 14

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 15

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.