PCEP Practice Test 33 — 15 Questions

Question 1

A developer uses a tuple to store immutable configuration data: config = ('localhost', 8080, True). They then write: host, port, secure = config. What is the result of this statement?

Accepted Answer

host becomes 'localhost', port becomes 8080, and secure becomes True.. Tuple unpacking assigns each element of the tuple to the corresponding variable on the left side, in order. The number of variables must equal the number of elements. In this case, three variables match three elements, so host, port, and secure receive 'localhost', 8080, and True respectively. No error occurs.

Answer

A SyntaxError occurs because the left side must be enclosed in parentheses.

Answer

A ValueError is raised because tuples cannot be unpacked into multiple variables.

Answer

host becomes the entire tuple, and port and secure are assigned None.

Question 2

A programmer is writing a Python function that processes a list of integers. The function must remove all negative numbers from the list while preserving the order of the remaining elements, and it must do so in place (modifying the original list). Which two code snippets correctly achieve this? (Choose two.)

Accepted Answer

i = 0
while i < len(numbers):
    if numbers[i] < 0:
        del numbers[i]
    else:
        i += 1. Both the while-loop with manual index management and the slice assignment using a list comprehension correctly modify the original list in place. The while loop carefully avoids skipping elements after deletion, and the slice assignment replaces the contents of the same list object. The other options either create a new list, cause iteration issues, or raise errors.

Answer

for num in numbers:
    if num < 0:
        numbers.remove(num)

Answer

for i in range(len(numbers)):
    if numbers[i] < 0:
        del numbers[i]

Answer

numbers = [x for x in numbers if x >= 0]

Question 3

A developer writes a function that retrieves a value from a dictionary and handles missing keys:

def get_value(data, key):
    try:
        return data[key]
    except KeyError:
        return None

What happens if data is not a dictionary but a list, and key is an integer index?

Accepted Answer

The function returns the element at the specified index because lists support integer indexing.. The function uses a try-except block to handle KeyError, which is specific to dictionary key lookups. When data is a list and key is an integer, the expression data[key] performs list indexing, which succeeds if the index is valid. No KeyError is raised, so the except block is skipped, and the element is returned. This shows that the same syntax can work for different types, but the exception handling is tailored to dictionaries.

Answer

The function returns None because the except KeyError clause catches any error.

Answer

The function raises a KeyError because lists use integer indices, not keys.

Answer

The function raises a TypeError because lists do not support the [] operator.

Question 4

A developer writes a function that reads an integer from a string and adds it to a running total. The code uses try: total += int(value) followed by except ValueError: total += 0. During testing, a value of '12.5' is supplied. What is the resulting behaviour?

Accepted Answer

The ValueError handler runs, total is incremented by 0, and execution continues normally.. int applied to the string '12.5' cannot produce an integer and raises ValueError. The except ValueError clause matches that exception type, so its body runs, adding zero to the total and allowing execution to continue. The conversion does not silently truncate string decimals, and the handler is correctly typed to catch exactly this failure.

Answer

The program terminates with an unhandled ValueError because except clauses cannot add to variables defined outside the function.

Answer

The conversion succeeds and total is increased by 12 because int truncates the decimal portion.

Answer

A TypeError is raised because the except clause names ValueError rather than the broader Exception class.

Question 5

A Python developer is writing a function that takes a tuple of numbers and returns a new tuple containing only the even numbers. They write the following code:

def filter_even(numbers):
    result = ()
    for num in numbers:
        if num % 2 == 0:
            result += (num,)
    return result

What is the primary reason this function works correctly?

Accepted Answer

Tuples are immutable, but the += operator creates a new tuple each time, which is then reassigned to result.. The function correctly builds a tuple of even numbers because the `+=` operator, when used with tuples, creates a new tuple by concatenation and reassigns it to the variable. Tuples are immutable, so this is the only way to 'modify' them. The other options incorrectly describe tuple immutability or methods.

Answer

Tuples support the append method, which adds elements to the end of the tuple in place.

Answer

The += operator modifies the tuple in place by adding the new element to the existing tuple object.

Answer

The function returns a list, not a tuple, because += converts the tuple to a list.

Question 6

A developer is writing a function that accepts a variable number of arguments and needs to handle them as a tuple. Which two of the following statements about tuples and function arguments are true? (Choose two.)

Accepted Answer

Inside a function, the *args parameter collects extra positional arguments into a tuple.. The *args parameter collects extra positional arguments into a tuple, and the * operator can unpack a tuple into positional arguments in a function call. These two features are often used together to create flexible functions. The **kwargs parameter collects keyword arguments into a dictionary, not a tuple, and tuples are immutable, so their contents cannot be changed. Understanding these behaviors is essential for working with variable argument lists in Python.

Answer

Tuples are mutable, so the arguments collected by *args can be modified inside the function.

Answer

A tuple cannot be passed to a function as a single argument if the function expects multiple parameters.

Answer

The **kwargs parameter collects extra keyword arguments into a tuple.

Question 7

A programmer is writing a function that accepts a dictionary of employee records and must return a tuple containing the number of records and the average salary. The function should not modify the input dictionary. Which function definition achieves this?

Accepted Answer

def summarize(employees):
    count = len(employees)
    if count == 0:
        return (0, 0)
    total = sum(employees.values())
    return (count, total / count). The correct function must return a tuple with the count and average salary, avoid modifying the input, and handle an empty dictionary gracefully. The chosen option includes a check for zero count, returns a sensible default, and uses dictionary values for the salary sum. The others either fail on empty input, sum the wrong data, or mutate the input.

Answer

def summarize(employees):
    count = len(employees)
    total = sum(employees.keys())
    return (count, total / count)

Answer

def summarize(employees):
    count = len(employees)
    total = sum(employees.values())
    return (count, total / count)

Answer

def summarize(employees):
    count = len(employees)
    total = sum(employees.values())
    employees.clear()
    return (count, total / count)

Question 8

A developer is writing a function that accepts a dictionary of student names and their scores. The function should return the name of the student with the highest score. If the dictionary is empty, it should return `None`. Which code snippet correctly implements this?

Accepted Answer

def top_student(scores):
    if not scores:
        return None
    return max(scores, key=scores.get). To find the key with the maximum value in a dictionary, pass a key function to max that extracts the value for each key. Using `scores.get` as the key function achieves this. The empty check prevents a ValueError. The other options either return the wrong element or fail on an empty dictionary.

Answer

def top_student(scores):
    if len(scores) == 0:
        return None
    return max(scores.items())

Answer

def top_student(scores):
    return max(scores.values())

Answer

def top_student(scores):
    return max(scores)

Question 9

A developer is writing a function that retrieves a value from a nested dictionary based on a sequence of keys. If any key is missing, the function should raise a custom exception MissingKeyError with the missing key. The function signature is def get_nested(data, keys):. Which implementation correctly meets these requirements?

Accepted Answer

def get_nested(data, keys):
    for key in keys:
        if key not in data:
            raise MissingKeyError(key)
        data = data[key]
    return data. The correct implementation must check each key's presence, raise MissingKeyError with the missing key, and traverse the nested structure. The chosen option does exactly that using the 'in' operator and passes the key to the exception. The others either omit the key in the exception, mishandle None values, or raise the exception class without arguments.

Answer

def get_nested(data, keys):
    for key in keys:
        data = data.get(key)
        if data is None:
            raise MissingKeyError(key)
    return data

Answer

def get_nested(data, keys):
    for key in keys:
        if key not in data:
            raise MissingKeyError
        data = data[key]
    return data

Answer

def get_nested(data, keys):
    try:
        for key in keys:
            data = data[key]
        return data
    except KeyError:
        raise MissingKeyError

Question 10

An inventory script defines `def add_stock(item, quantity, *restock_dates):` and is called as `add_stock('bolt', 40, '2024-01-05', '2024-02-11')`. Inside the function, the developer wants to count how many restock dates were supplied. Which expression correctly reports that count?

Accepted Answer

len(restock_dates). The starred parameter packs all surplus positional arguments into a tuple, so the number of restock dates equals the length of that tuple. Calling the built-in len on the packed tuple gives the exact count of extra arguments received, while indexing or attribute-style length access either measures the wrong thing or fails outright.

Answer

len(restock_dates[0])

Answer

restock_dates.length

Answer

restock_dates.count

Question 11

A programmer writes:

x = 10
y = 4
print(x // y, x % y, x / y)

What is printed?

Accepted Answer

2 2 2.5. The floor division operator // returns the largest integer less than or equal to the quotient, so 10 // 4 is 2. The modulus operator % returns the remainder, so 10 % 4 is 2. True division / returns a float, so 10 / 4 is 2.5. Printing these in order gives '2 2 2.5'.

Answer

2 0.5 2.5

Answer

2 2 2.0

Answer

2.5 2 2

Question 12

A developer is reviewing loop constructs that iterate over the list scores = [10, 20, 30]. Which two statements about iterating this list are true? (Choose two.)

Accepted Answer

for s in scores: accesses each element value directly, so s takes the values 10, 20, and 30 in order.. Python lets you iterate a list either by value, where the loop variable receives each element, or by index, where a range over the list's length supplies positions usable with subscripting. Direct value iteration is simplest for reading data, while index iteration is needed when positions matter. Appending during iteration is unreliable, and an empty list produces no iterations.

Answer

for s in scores: assigns s to each index position, so s holds 0, 1, and 2 during iteration.

Answer

Modifying scores by appending a new element during a for loop over scores reliably processes the appended element in the same loop.

Answer

A for loop over scores always executes at least once, even when the list is empty.

Question 13

A quality engineer tracks defect counts per shift in a list called defects. She needs the running total of all defects after every shift, producing a list of cumulative sums with the same length as defects. Which approach produces that cumulative list?

Accepted Answer

total = 0
cumulative = []
for d in defects:
    total += d
    cumulative.append(total). A running total requires an accumulator initialized before the loop, updated with each element, and recorded after the update. Appending after adding yields a cumulative value for every shift and keeps the output length equal to the input length. Appending before adding shifts all values by one position, and recomputing the whole-list sum each iteration produces a repeated grand total instead.

Answer

cumulative = []
for d in defects:
    cumulative.append(sum(defects))

Answer

total = 0
cumulative = []
for d in defects:
    cumulative.append(total)
    total += d

Answer

cumulative = [defects[i] + defects[i+1] for i in range(len(defects))]

Question 14

A developer is writing a Python script to process a list of integers representing inventory counts. The developer needs to iterate over the list and, for each element, perform an action, but also needs to be able to terminate the entire loop early when a sentinel value (0) is encountered. Which two statements about loop control in Python are correct? (Choose two.)

Accepted Answer

The continue statement skips the rest of the current iteration and proceeds to the next iteration of the loop.. The break statement exits the innermost loop immediately, which is suitable for stopping on a sentinel value. The continue statement skips to the next iteration without terminating the loop. These two control statements are fundamental for managing loop execution and are distinct from return, which exits a function.

Answer

The continue statement terminates the loop and resumes execution after the loop.

Answer

A for loop in Python automatically stops when it encounters a None value in the sequence.

Answer

The break statement can be used outside a loop to exit a function early.

Question 15

A developer writes the following code:

values = [10, 20, 30, 40, 50]
result = values[1:4]

What does the variable result contain after execution?

Accepted Answer

[20, 30, 40]. List slicing takes a start index that is included and a stop index that is excluded. With values[1:4], the slice begins at the element twenty and continues through the elements at indexes two and three, which are thirty and forty. The element at index four is not included because the stop bound is exclusive, so the result list holds three elements.

Answer

[20, 30, 40, 50]

Answer

[10, 20, 30]

Answer

[10, 20, 30, 40]