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

Question 1

A Python developer is building a quiz application. The program stores correct answers in a list named `key` and user responses in a list named `answers`. The developer wants to count how many positions match between the two lists, stopping the comparison as soon as the first mismatch is found so that a diagnostic message can be shown. Which control-flow statement should be used inside the loop to stop iterating immediately when a mismatch occurs?

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

Accepted Answer

break. The `break` statement exits the nearest enclosing loop immediately, which is precisely what is needed to stop comparing list positions once the first mismatch appears. `continue` only skips one iteration, `pass` does nothing, and `return` leaves the whole function, so none of those produce the desired early loop termination while preserving subsequent code execution.

Answer

return

Answer

continue

Answer

pass

Question 2

A data analyst maintains `matrix = [[1, 2], [3, 4], [5, 6]]` and wants a flat list `flat` containing every number in row order, that is `[1, 2, 3, 4, 5, 6]`. Which code produces this result?

Accepted Answer

flat = []
for row in matrix:
    for value in row:
        flat.append(value). Flattening a list of lists requires iterating the outer list to obtain each row and then iterating each row to reach its elements. Appending every visited integer builds the one-dimensional result in the original order. Appending whole rows keeps the nesting, hard-coded concatenation does not adapt to different sizes, and selecting a single column index drops data.

Answer

flat = []
for row in matrix:
    flat.append(row)

Answer

flat = matrix[0] + matrix[1] + matrix[2]

Answer

flat = []
for i in range(len(matrix)):
    flat.append(matrix[i][0])

Question 3

A student is writing a program that stores the daily steps walked over a week in a list. She wants to determine whether any day had fewer than 1000 steps, and if so, report the first such day's index. Which approach correctly finds the index of the first value below 1000?

Accepted Answer

Use a for loop with range(len(steps)) and break when steps[i] < 1000, then use the loop variable i.. Finding the first element that satisfies a condition requires both the element and its position. Iterating over indices with range(len(steps)) provides the index, and breaking on the first match leaves the loop variable holding that index. Searching for the minimum, iterating over values, or counting qualifying days all answer different questions and cannot report the earliest qualifying index.

Answer

Use a while loop with a counter that increments only when the step count is below 1000.

Answer

Use a for loop over the list elements and break when the element is below 1000, then print the element itself.

Answer

Use steps.index(min(steps)) to locate the day with the fewest steps.

Question 4

A monitoring script checks a list of sensor readings and must stop examining them as soon as a reading above 100 is found, without checking any remaining readings. The readings list contains at least one value above 100. Which loop control approach implements this behavior correctly?

Accepted Answer

Use break when a reading exceeds 100, so the loop ends immediately and no further readings are checked.. Only break exits a loop immediately when a condition is met. When a reading above 100 is encountered, break ends iteration and control moves past the loop, so no later readings are examined. The other keywords either skip one iteration, do nothing, or run after normal completion.

Answer

Use pass when a reading exceeds 100, so the loop silently ignores the condition and finishes normally.

Answer

Use continue when a reading exceeds 100, so the loop skips the rest of that iteration and keeps going.

Answer

Use else on the for loop, so the loop stops when a reading exceeds 100.

Question 5

A Python developer is validating a list of sensor readings stored in `readings`. The developer needs to build a new list containing only readings that are strictly greater than 10. Which two code fragments correctly produce a list of only the values greater than 10? (Choose two.)

Accepted Answer

filtered = [r for r in readings if r > 10]. A list comprehension with a trailing `if r > 10` and the built-in `filter()` with a lambda both select exactly the elements satisfying the strict comparison, producing the required list. The other fragments either use an inclusive comparison that wrongly keeps 10, call a nonexistent list method, or use invalid comprehension syntax with an `else` clause in the filter position.

Answer

filtered = [r for r in readings if r > 10 else r]

Answer

filtered = [r for r in readings if r >= 10]

Answer

filtered = readings.filter(r > 10)

Question 6

A student is writing a Python script to sum all even numbers in a list `nums`. The script should ignore odd numbers. Which code correctly computes the sum?

Accepted Answer

total = 0
for n in nums:
    if n % 2 == 0:
        total += n. The correct loop uses the modulo operator to test whether each number is even, and adds only those numbers to the running total. This directly implements the requirement to sum even numbers while ignoring odd ones, using a standard accumulator pattern in Python.

Answer

total = sum(nums) if nums % 2 == 0 else 0

Answer

total = 0
for n in nums:
    if n / 2 == 0:
        total += n

Answer

total = 0
for n in nums:
    if n % 2 == 1:
        total += n

Question 7

A software tester is examining a list of error codes: `errors = [404, 500, 403, 404, 200]`. She wants to determine if the code 404 appears in the list and print 'Found' if it does, otherwise 'Not found'. Which code correctly achieves this?

Accepted Answer

if 404 in errors:
    print('Found')
else:
    print('Not found'). The `in` operator is the correct tool for checking if an element exists in a list. It returns a boolean and does not raise errors. The other options either misuse the `in` operator, rely on `index()` which can raise exceptions and misinterpret index 0, or invert the logic with `count()`.

Answer

if errors.count(404) == 0:
    print('Found')
else:
    print('Not found')

Answer

if errors in 404:
    print('Found')
else:
    print('Not found')

Answer

if errors.index(404):
    print('Found')
else:
    print('Not found')

Question 8

A developer is building a simple inventory check. The list stock holds integers representing item quantities. He wants to append the string 'low' to a separate list alerts once for each quantity that is less than 5. Which code correctly populates alerts?

Accepted Answer

for q in stock: if q < 5: alerts.append('low'). Appending inside a loop with a conditional adds one entry per qualifying quantity, which matches the requirement of one 'low' per item below 5. Breaking after the first match stops too early, using any collapses the count to a single Boolean decision, and rebinding alerts with a comprehension replaces rather than extends the existing list.

Answer

if any(q < 5 for q in stock): alerts.append('low')

Answer

alerts = ['low' for q in stock if q < 5] appended to the existing alerts list.

Answer

for q in stock: if q < 5: alerts.append('low') break

Question 9

A developer is writing a Python script to validate a list of usernames. The script must examine each username in the list and print 'Invalid' as soon as a username shorter than 3 characters is found, then stop checking the remaining usernames. Which control flow statement should be used inside the loop to terminate it immediately when the invalid username is encountered?

Accepted Answer

break. The break statement exits the innermost loop immediately, which is exactly what is needed to stop checking usernames once an invalid one is found. The other statements either skip only one iteration, do nothing, or exit the whole function, so they do not satisfy the requirement to terminate the loop early while continuing the rest of the script.

Answer

return

Answer

pass

Answer

continue

Question 10

A logistics coordinator tracks delivery statuses in a list of strings. The coordinator wants to build a new list containing only the statuses that are not equal to `"delivered"`, preserving the original order. Which code fragment produces the desired list `pending`?

Accepted Answer

pending = [s for s in statuses if s != "delivered"]. Selecting all entries that differ from a target value calls for a comprehension whose condition compares each element with `!=`. That preserves order and includes every non-matching status. Inverting the comparison keeps the wrong subset, `remove` mutates and returns `None`, and testing the literal's truthiness yields nothing at all.

Answer

pending = statuses.remove("delivered")

Answer

pending = [s for s in statuses if not "delivered"]

Answer

pending = [s for s in statuses if s == "delivered"]

Question 11

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 12

A Python developer is writing a script that processes a list of temperatures in a loop. Inside the loop, a conditional block handles sub-zero readings by appending a warning to a report. The developer notices that the loop body is executing even for temperatures that are not sub-zero. Which statement about Python's `if`/`elif`/`else` structure explains why a block guarded by `if temp < 0:` should not execute for a temperature of 5?

Accepted Answer

The `if` block executes only when its condition evaluates to a truthy value; since `5 < 0` is False, the block is skipped.. Conditional blocks in Python execute based on the truth value of their condition, evaluated before the block runs. Because `5 < 0` is False, the guarded block is skipped and control moves on. The other statements misdescribe evaluation order, trigger conditions, or dependencies among sibling clauses, none of which match Python's top-down conditional evaluation model.

Answer

The `if` block executes whenever the loop variable is reassigned, regardless of the condition's truth value.

Answer

The `if` block executes only if a previous `elif` condition was also False, making it dependent on sibling clauses.

Answer

The `if` block executes for every iteration because Python evaluates conditions after running the block once.

Question 13

A developer is auditing loop constructs in a Python script. Which TWO statements about `break`, `continue`, `else`, and `range` are correct in Python? (Choose two.)

Accepted Answer

`continue` skips the rest of the current iteration and immediately re-evaluates the loop condition or fetches the next item.. The `else` clause of a loop runs only on normal exhaustion, not after a `break`, which supports search idioms. `continue` ends the current iteration and moves to the next, re-evaluating or advancing as appropriate. The other statements misdescribe `break` as iteration-skipping, give `range` an inclusive upper bound, and claim `while` always runs once, all of which are incorrect for Python.

Answer

`break` exits only the current iteration and resumes with the next item.

Answer

A `while` loop always executes its body at least once, even if the condition is initially false.

Answer

`range(5)` produces the list `[0, 1, 2, 3, 4, 5]` when printed.

Question 14

A programmer is building a simple inventory tracker using a Python list named stock that contains integer quantities. They need to add 10 to every quantity in the list, modifying the list in place. Which code correctly performs this operation?

Accepted Answer

for i in range(len(stock)): stock[i] = stock[i] + 10. To modify a list in place, you must assign to individual elements using their indices. Using range(len(stock)) provides those indices, and stock[i] = stock[i] + 10 updates each element. The other options either leave the list unchanged, create a new list, or cause an error, so they do not satisfy the in-place requirement.

Answer

stock = [qty + 10 for qty in stock]

Answer

stock = stock + 10

Answer

for qty in stock: qty = qty + 10

Question 15

A Python developer is writing a script to process a list of order IDs. The script must skip any order ID that is an empty string and continue processing the remaining IDs. Inside a `for` loop over the list, which statement should be used to skip the current iteration when an empty string is encountered and proceed with the next order ID?

Accepted Answer

continue. The `continue` statement abandons the current iteration and proceeds with the next element, which is the correct behavior for skipping empty order IDs while still processing the rest of the list. `break` would stop the loop entirely, `pass` does nothing, and `exit` would terminate the interpreter, so none of those match the filtering requirement.

Answer

pass

Answer

exit

Answer

break