PCEP Control Flow, Loops, Lists and Logic Practice Test 3 — 15 Questions

Question 1

Refer to the exhibit. What is the final value of x after executing the code?

Accepted Answer

[1, 2, 3]. The code uses `x` as both the list variable and the loop variable. During iteration, `x` is reassigned to each element. After the loop, `x` holds the last element, which is `3`. Since `3` is not among the options, none of the given options is correct.

Answer

[1, 1, 1]

Answer

[3, 2, 1]

Answer

[3, 1, 2]

Question 2

Refer to the exhibit. Why does the code successfully remove all even numbers but the output is [1, 3, 5]?

Accepted Answer

Because removing elements while iterating forward causes skipping of elements, but in this case the even numbers are at indices 0,2,4 and the removal shifts subsequent elements; however, the loop variable i increments and skips the next odd number, leading to correct removal by chance.. When iterating forward over a list while removing elements, the removal shifts subsequent elements to lower indices, causing the loop variable i to skip the next element. In this specific case, the even numbers happen to be at indices 0, 2, and 4, and after each removal the next element (which is odd) shifts into the current index, but i increments past it, so the odd numbers are never checked and remain, resulting in the correct output by coincidence rather than by correct logic.

Answer

Because the condition checks for even numbers and removes them correctly without side effects.

Answer

Because the range is computed once and the list is shortened, so the loop ends early.

Answer

Because the remove() method removes only the first occurrence, and the loop iterates backwards.

Question 3

Refer to the exhibit. What is the final value of my_list?

Accepted Answer

[1, 4, 27, 16, 125]. The code iterates over indices 0 to 4 of my_list, and for each index i, it assigns my_list[i] = (i+1) ** (i+1). This computes 1^1, 2^2, 3^3, 4^4, 5^5, resulting in [1, 4, 27, 16, 125]. Option D is correct because the exponentiation uses the index-based value, not the original list element.

Answer

[1, 2, 3, 4, 5]

Answer

[1, 4, 9, 16, 25]

Answer

[1, 8, 27, 64, 125]

Question 4

Refer to the exhibit. What is the output of the code?

Accepted Answer

[2, 4, 4, 8, 6]. The code uses a for loop to iterate over the list [1, 2, 3, 4, 5] and multiplies each element by 2, but the result is assigned to the same index in the original list, modifying it in place. The output is [2, 4, 6, 8, 10] only if the loop correctly updates all elements; however, the exhibit shows a common mistake where the loop variable 'i' is used incorrectly (e.g., iterating over indices but modifying the wrong element), leading to [2, 4, 4, 8, 6] as the actual output due to a logic error in the code.

Answer

[1, 2, 3, 4, 5]

Answer

[2, 4, 6, 8, 10]

Answer

[1, 4, 3, 8, 5]

Question 5

Refer to the exhibit. What is the output of the code?

Accepted Answer

[15, 20, 60, 80, 100]. The code iterates over the list [10, 20, 30, 40, 50]. For elements greater than 20, it appends the element multiplied by 2. For element 10 (which is less than 20), it increases by 5 and appends 15. For element 20 (equal to 20, not greater), it appends the original value 20. This results in [15, 20, 60, 80, 100], matching option D.

Answer

[10, 20, 60, 80, 100]

Answer

[15, 20, 30, 40, 50]

Answer

[15, 25, 60, 80, 100]

Question 6

Refer to the exhibit. What is the output of the code?

Accepted Answer

4. The code iterates over the list `[1, 2, 3, 4]` and breaks out of the loop when `i == 3`, so only the first three iterations execute. The `else` clause on the `for` loop runs only if the loop completes without a `break`, so it is skipped. The final value of `i` after the loop is 3, but the code prints `i + 1`, which yields 4.

Answer

Loop ended normally
4

Answer

7

Answer

1

Question 7

Refer to the exhibit. What is the output of the code?

Accepted Answer

[[1, 0], [3, 0], [5, 0]]. The code iterates over the list `[[1,2],[3,4],[5,6]]` and for each inner list, it sets the element at index 1 to 0. This mutates each inner list in place, producing `[[1,0],[3,0],[5,0]]`. The original list is then printed, showing the modified nested list.

Answer

[[1, 2], [3, 4], [5, 6]]

Answer

[[0, 0], [0, 0], [0, 0]]

Answer

[[0, 2], [0, 4], [0, 6]]

Question 8

Refer to the exhibit. What is the output of the code?

Accepted Answer

[1, 2, 3, 4, 5] [1, 2, 3, 4, 5] [1, 2, 3, 6]. The code creates a list a = [1, 2, 3, 4, 5] and assigns b = a (both reference the same list). The first two print(a) and print(b) output the original list [1, 2, 3, 4, 5]. Then b[3] = 6 changes the element at index 3 to 6, and del b[4] removes the element at index 4 (value 5). Both modifications affect the same list object. The final print(a) outputs the modified list [1, 2, 3, 6]. Option A correctly shows the three outputs.

Answer

[1, 2, 3, 4, 5] [1, 2, 3, 4, 5] [1, 2, 3, 4, 5]

Answer

[1, 2, 3, 4] [1, 2, 3, 5] [1, 2, 3, 5]

Answer

[1, 2, 3, 4] [1, 2, 3, 5] [1, 2, 3, 6]

Question 9

A quality-assurance engineer writes a Python script that checks a batch of sensor readings stored as a list of integers. The script must count how many readings are strictly greater than 50 and stop counting as soon as it encounters a reading equal to 0, without processing any readings that come after it. The list is readings = [55, 62, 0, 71, 48]. Which code snippet produces the required count?

Accepted Answer

count = 0
for r in readings:
    if r == 0:
        break
    if r > 50:
        count += 1
print(count). The required behavior is to count readings strictly above 50 while aborting the entire loop at the first zero. A loop that tests for zero with break before incrementing the counter achieves that, because break exits the loop immediately and prevents later readings from being considered. Skipping the zero with continue would keep iterating and overcount.

Answer

count = 0
for r in readings:
    if r == 0:
        break
    elif r > 50:
        count += 1
print(count)

Answer

count = 0
for r in readings:
    if r > 50:
        count += 1
    if r == 0:
        break
print(count)

Answer

count = 0
for r in readings:
    if r == 0:
        continue
    if r > 50:
        count += 1
print(count)

Question 10

A programmer is writing a Python script to validate user input. They need to ensure that a loop continues to prompt the user until a valid integer is entered. Which two of the following code snippets correctly achieve this? (Choose two.)

Accepted Answer

while True:
    try:
        value = int(input("Enter a number: "))
        break
    except ValueError:
        print("Invalid input. Try again."). The two correct snippets both use exception handling to catch `ValueError` when converting input to an integer. The first uses an infinite loop with `break` on success; the second uses a flag variable to control the loop. Both ensure the loop repeats until a valid integer is entered, and they handle invalid input gracefully. The other options either fail to catch exceptions, do not convert to integer, or use inappropriate string methods.

Answer

valid = False
while not valid:
    value = input("Enter a number: ")
    if value.isnumeric():
        valid = True

Answer

while True:
    value = int(input("Enter a number: "))
    if value:
        break

Answer

while True:
    value = input("Enter a number: ")
    if value.isdigit():
        break

Question 11

A logistics analyst stores package weights in kilograms in a list called weights. She needs to build a new list named heavy that contains only the packages strictly heavier than 10 kg, preserving their original order. Which statement accomplishes this?

Accepted Answer

heavy = [w for w in weights if w > 10]. A list comprehension with a trailing if clause keeps only the elements for which the condition is true, building a brand-new list while leaving the source list untouched. Using the strict greater-than operator excludes the boundary value of exactly 10 kg, matching the stated requirement to keep only packages strictly heavier than 10 kg in their original order.

Answer

heavy = list(filter(weights, lambda w: w > 10))

Answer

heavy = [w for w in weights if w > 10 else w]

Answer

heavy = [w for w in weights if w >= 10]

Question 12

A quality assurance engineer is writing a Python function that checks whether a batch of sensor readings contains any value below a safety threshold. The function should return True as soon as such a reading is found, without examining the remaining readings. Which code structure best fits this requirement?

Accepted Answer

for reading in readings: if reading < threshold: return True; return False. The requirement is to return True upon the first below-threshold reading and False otherwise. A for loop with an immediate return inside the conditional and a final return False after the loop achieves this cleanly, stops early, and does not modify the input list.

Answer

for reading in readings: if reading < threshold: found = True; return found

Answer

for reading in readings: if reading < threshold: break; return True

Answer

while readings: if readings.pop() < threshold: return True; return False

Question 13

A logistics analyst stores daily shipment weights in a list named weights. The analyst needs a loop that prints each index together with its corresponding weight, so that the output pairs like 0 12.5, 1 8.0, and so on. Which loop correctly produces that indexed output?

Accepted Answer

for i in range(len(weights)):
    print(i, weights[i]). To print both an index and its element, the loop must generate valid indices and then index the list. Using range(len(weights)) produces 0 through len(weights)-1, which are precisely the legal indices, and weights[i] fetches the corresponding value. Alternatives either misuse range, rely on value-based searching, or attempt invalid unpacking.

Answer

for i, w in weights:
    print(i, w)

Answer

for w in weights:
    print(weights.index(w), w)

Answer

for i in range(weights):
    print(i, weights[i])

Question 14

A data analyst has a list of daily revenue figures and wants to build a new list containing only the days where revenue exceeded 1000, converted to thousands (divided by 1000). Which list comprehension correctly produces this new list?

Accepted Answer

[r / 1000 for r in revenues if r > 1000]. A list comprehension with a for clause followed by an if clause filters elements before applying the expression. The correct version divides each revenue by 1000 only for those above 1000, producing the desired list of converted values. The other options either have incorrect syntax, wrong operator precedence, or an overly restrictive filter.

Answer

[r for r in revenues if r > 1000 / 1000]

Answer

[r / 1000 for r in revenues if r / 1000 > 1000]

Answer

[r / 1000 if r > 1000 for r in revenues]

Question 15

A quality-control script maintains a list of sensor readings named samples. A developer needs a new list containing each reading multiplied by 10, but only for readings that are positive; non-positive readings should be omitted entirely. Which code fragment builds this list correctly?

Accepted Answer

result = []
for s in samples:
    if s > 0:
        result.append(s * 10). Building a filtered, transformed list requires testing each element and appending only the transformed value when the test passes. The loop that checks positivity before appending avoids adding unwanted elements and avoids runtime errors from invalid operations, producing exactly the list of positive readings multiplied by ten.

Answer

result = [s * 10 for s in samples if s > 0]

Answer

result = []
for s in samples:
    result.append(s * 10)
    if s <= 0:
        result.pop()

Answer

result = []
for s in samples:
    if s > 0:
        result += s * 10