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

Question 1

A developer needs to write a loop that prints all even numbers from a list. They attempt: for num in numbers: if num % 2 == 0: print(num). However, they want a more efficient approach using list comprehension. Which alternative achieves the same result?

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

Accepted Answer

for even in [num for num in numbers if num % 2 == 0]: print(even). It uses a list comprehension to generate a list of even numbers, then iterates over that list with a for loop, printing each even number. This achieves the same result as the original loop but with the efficiency of list comprehension for filtering, while still printing each number individually.

Answer

print([num for num in numbers if num % 2 == 0])

Answer

for num in numbers: print(num if num % 2 == 0 else None)

Answer

print([num % 2 == 0 for num in numbers])

Question 2

A developer writes: result = [x**2 for x in range(10) if x % 2 == 0]. What does this code produce?

Accepted Answer

A list containing [0, 4, 16, 36, 64]. The code uses a list comprehension with a conditional filter: `[x**2 for x in range(10) if x % 2 == 0]`. It iterates over numbers 0 through 9, keeps only even numbers (those where `x % 2 == 0`), squares each, and collects the results into a list. The resulting list is `[0, 4, 16, 36, 64]`, which are the squares of the even numbers 0, 2, 4, 6, and 8.

Answer

A list of even numbers squared

Answer

A generator object

Answer

A list of squares of all numbers from 0 to 9

Question 3

A team observes that the following code prints 'Found' even when the item is not in the list. Code: for item in mylist: if item == target: print('Found'); break; else: print('Not found'). Which modification ensures it correctly prints 'Not found' only if the item is not present?

Accepted Answer

Align the else with the for statement (for-else construct). The original code uses a for-else construct where the else block executes after the loop completes normally (i.e., without a break). However, the code has a syntax error: the else is incorrectly indented as part of the if statement, causing it to execute on every iteration when the condition is false. Aligning the else with the for statement (for-else construct) ensures the else block runs only if the loop finishes without hitting a break, which occurs when the item is not found.

Answer

Move else inside the if block

Answer

Replace break with continue

Answer

Use a flag variable to track found status

Question 4

Which TWO of the following are valid ways to iterate over a list in reverse order? (Choose two.)

Accepted Answer

for item in reversed(lst):. Option A is correct because the built-in reversed() function returns an iterator that yields the list's elements from last to first, so 'for item in reversed(lst):' cleanly iterates in reverse order. Option B is correct because range(len(lst)-1, -1, -1) generates indices starting at the last valid index (len(lst)-1) down to 0 with a step of -1, allowing reverse iteration by index. Option C is incorrect because range(len(lst)) produces indices 0 through len(lst)-1 in forward order, not reverse. Option D is incorrect because the slice lst[-1::-1] starts at the last element and steps backward, but it creates a reversed copy of the list rather than being a standard idiomatic reverse-iteration construct (and the question asks for valid ways to iterate in reverse; the canonical slice form is lst[::-1], not lst[-1::-1]). Option E is incorrect because 'for item in lst:' simply iterates over the list in its natural forward order.

Answer

for i in range(len(lst)):

Answer

for item in lst[-1::-1]:

Answer

for item in lst:

Question 5

What is the output of the code?

Accepted Answer

1
2. The code uses a `for` loop with `range(1, 4)` which generates the sequence 1, 2, 3. Inside the loop, `if i == 3: break` causes the loop to terminate when `i` equals 3, so the loop only prints 1 and 2 before breaking. There is no additional print statement after the loop, so the output is just `1` and `2` on separate lines.

Answer

1
2
3
Done

Answer

1
2
Done

Answer

1
2
3

Question 6

What is the output of the code?

Accepted Answer

['Positive', 'Zero', 'Negative']. The question stem does not contain any code. Without the code, it is impossible to determine the output. The explanation previously assumed a specific code snippet which is not present.

Answer

['Positive', 'Zero']

Answer

[Positive, Zero, Negative]

Answer

('Positive', 'Zero', 'Negative')

Question 7

What is the output of the code?

Accepted Answer

Alice
Check. The code iterates over the list `['Alice', 'Bob']`. For each name, if the length is less than 5, the loop continues to the next iteration without printing. 'Alice' has length 5, so the condition is false and 'Alice' is printed. 'Bob' has length 3, so the condition is true and the loop skips printing 'Bob'. After the loop ends, `print('Check')` executes, printing 'Check'. Therefore, the output is 'Alice' followed by 'Check' on separate lines. Option A correctly shows this.

Answer

Alice

Answer

Alice
Too young

Answer

Alice
Bob

Question 8

Refer to the exhibit.
What is the output?

Accepted Answer

[1, 4, 3, 8, 5]. The code iterates over the list `[1, 2, 3, 4, 5]` using indices. It only modifies elements at odd indices (index 1 and 3). For those elements, if the value is even, it multiplies by 2; if odd, it adds 2. At index 1, value 2 (even) becomes 4; at index 3, value 4 (even) becomes 8. Elements at even indices (0, 2, 4) remain unchanged: 1, 3, 5. Thus the final list is `[1, 4, 3, 8, 5]`.

Answer

[2, 5, 7, 9, 5]

Answer

[2, 4, 6, 8, 10]

Answer

[1, 2, 3, 4, 5]

Question 9

Refer to the exhibit.
What is printed?

Accepted Answer

A. The code uses a `for` loop to iterate over the list `['A', 'B', 'C']`. The `break` statement inside the loop executes when the variable `letter` equals `'A'`, immediately terminating the loop. Therefore, only `'A'` is printed before the loop ends, making option B correct.

Answer

None (error)

Answer

B

Answer

C

Question 10

Refer to the exhibit.
What is the output?

Accepted Answer

[1, 2]. The code creates a list [1,2,3] and uses slicing with start index 0 and end index 2 (exclusive), extracting elements at indices 0 and 1, which are 1 and 2. Therefore, the output is [1,2].

Answer

[1, 2, 3]

Answer

[0, 1, 2]

Answer

[2, 3]

Question 11

A company stores employee data as a list of dictionaries. Each dictionary has keys 'name' and 'age'. Which code correctly counts employees older than 30?

Accepted Answer

count = 0
for emp in employees:
    if emp['age'] > 30:
        count += 1. It uses a simple `for` loop to iterate directly over each dictionary in the `employees` list, checks if the value of the `'age'` key is greater than 30, and increments the counter accordingly. This is the most Pythonic and readable approach for counting elements that satisfy a condition.

Answer

count = 0
for i in range(len(employees)):
    if employees[i]['age'] <= 30:
        count += 1

Answer

count = 0
i = 0
while i < len(employees):
    if employees[i]['age'] > 30:
        count += 1

Answer

count = [emp for emp in employees if emp['age'] > 30]

Question 12

Which THREE of the following are valid ways to iterate over a list?

Accepted Answer

for i in mylist:. Python's `for i in mylist:` syntax directly iterates over each element of the list `mylist`, assigning the element value to the loop variable `i` in each iteration. This is the standard and most Pythonic way to traverse a list.

Answer

foreach i in mylist:

Answer

iter(mylist)

Question 13

A program needs to print the index and value of each item in a list named 'items'. Which code snippet correctly does this?

Accepted Answer

Both A and C are correct. Both Option A and Option C are valid code snippets that correctly print the index and value of each item in the list. Option A uses the clean, Pythonic enumerate() function. Option C uses range(len(items)) to iterate by index. Since both are correct, the best answer is B, which correctly identifies that both A and C are correct. Option D is incorrect because items.index(item) can fail with duplicate values and is inefficient.

Answer

for i, item in enumerate(items): print(i, item)

Answer

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

Answer

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

Question 14

A developer is debugging a function that uses a while loop to reverse a list in place. The current code causes an infinite loop. Which three modifications would likely fix the infinite loop? (Select three.)

Accepted Answer

Ensure the end index is decremented each iteration. In a while loop that reverses a list in place, the end index must be decremented each iteration to move the end pointer toward the center. Without decrementing the end index, the loop condition (e.g., start < end) may never become false, causing an infinite loop. This ensures the two pointers converge and the loop terminates.

Answer

Add a break statement after the swap

Answer

Use a temporary variable for the swap

Question 15

A network administrator uses a Python script to analyze firewall logs. The script reads a CSV file with columns 'src_ip', 'dst_ip', 'action', 'time'. It needs to build a list of source IPs that have been blocked more than 3 times. The current code:

blocked_count = {}
blocked_ips = []
for row in logs:
    if row['action'] == 'block':
        if row['src_ip'] in blocked_count:
            blocked_count[row['src_ip']] += 1
        else:
            blocked_count[row['src_ip']] = 1
for ip, count in blocked_count.items():
    if count > 3:
        blocked_ips.append(ip)

The script runs correctly but slowly on large logs. The administrator wants to optimize it. Which change would most improve performance?

Accepted Answer

Use a counter from collections module. Using `collections.Counter` replaces the manual dictionary increment logic with a single optimized C-level operation, reducing Python bytecode execution overhead. The Counter's `most_common()` method or direct iteration over items still requires a second loop, but the first loop's increment is significantly faster due to internal C implementation, which is the primary bottleneck in large log processing.

Answer

Use a list comprehension for the second loop

Answer

Pre-allocate the blocked_ips list

Answer

Use a set for blocked_ips to avoid duplicates