PCEP Timed Practice Test 5 — 10 Questions

Question 1

Given the code:
x = [1, 2, 3]
y = x
y.append(4)
print(x)
What is the output?

Accepted Answer

[1, 2, 3, 4]. Option C is correct because in Python, variables hold references to objects, not the objects themselves. When `y = x` is executed, both `x` and `y` point to the same list object in memory. The `y.append(4)` method modifies that shared list in-place, so the change is reflected when `x` is printed, outputting `[1, 2, 3, 4]`.

Answer

Error

Answer

[1, 2, 3]

Answer

[1, 2, 3, 4, 5]

Question 2

A list of numbers is defined as nums = [1, 2, 3, 4, 5]. Which expression returns the last element?

Accepted Answer

nums[-1]. Option B is correct because Python uses zero-based indexing, so the first element is at index 0 and the last element is at index -1. Negative indices count from the end of the list, so nums[-1] directly accesses the last element (5) without needing to know the list length.

Answer

nums[5]

Answer

nums[0]

Answer

nums[-2]

Question 3

A programmer needs to iterate over a list of strings and print each string in uppercase. Which loop correctly accomplishes this?

Accepted Answer

for i, item in enumerate(mylist): print(item.upper()). Option A is correct because it uses a for loop with enumerate to iterate over the list, and calls the string method upper() (with parentheses) to convert each item to uppercase before printing. This ensures each string is properly transformed and output.

Answer

for item in mylist: item = item.upper()

Answer

for item in mylist: print(item.upper)

Question 4

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 5

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 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

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 8

Which of the following statements about Python indentation is true?

Accepted Answer

Indentation must be consistent within a block.. Option C is correct because Python enforces consistent indentation within a block to define the scope of statements. Unlike many languages that use braces, Python relies on the indentation level to group statements, and any inconsistency (e.g., mixing spaces and tabs or varying the number of spaces) will raise an IndentationError.

Answer

Indentation is optional but recommended.

Answer

You can mix tabs and spaces freely.

Answer

Indentation only matters for loops and conditionals.

Question 9

A developer needs to iterate over the indices of a list named 'items' and print each index and its corresponding value. Which loop construct is most appropriate?

Accepted Answer

for i, val in enumerate(items): print(i, val). Option C is correct because `enumerate(items)` returns an iterator that yields pairs of (index, value) directly, making it the most Pythonic and efficient way to iterate over both indices and values of a list. It avoids the overhead of calling `items.index(val)` (which is O(n) per iteration) or manually managing `range(len(items))`.

Answer

for val in items: print(items.index(val), val)

Answer

for i in range(len(items)): print(i, items[i])

Answer

for i in items: print(i)

Question 10

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]