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

Question 1

You are writing a script to parse a log file. Each line in the log contains a timestamp and a message separated by a colon. You need to extract only the messages that contain the word 'ERROR'. The script uses a list comprehension to filter lines. However, the script crashes with a 'ValueError: not enough values to unpack' when processing some lines. The code is:

lines = ['2024-01-01 12:00:00: INFO: all good', '2024-01-01 12:01:00: ERROR: something wrong'] errors = [msg for timestamp, msg in line.split(': ') for line in lines if 'ERROR' in msg]

What is the correct fix?

lines = ['2024-01-01 12:00:00: INFO: all good', '2024-01-01 12:01:00: ERROR: something wrong']
errors = [msg for timestamp, msg in line.split(': ') for line in lines if 'ERROR' in msg]

What is the correct fix?

Accepted Answer

Rewrite as: [msg for line in lines if 'ERROR' in line for msg in [line.split(': ')[1]]]. Option D is correct because it properly separates the filtering and unpacking steps. The original code attempts to unpack each line into timestamp and msg using `line.split(': ')`, but some lines may not contain exactly two parts after splitting (e.g., if the colon is missing or there are extra colons), causing a ValueError. Option D first filters lines containing 'ERROR', then safely extracts the message part by splitting and taking index [1] inside a nested comprehension, avoiding the unpacking error.

Answer

Rewrite as: [line for line in lines if 'ERROR' in line]

Answer

Change the list to a dictionary

Answer

Swap the order of the for clauses to: [msg for line in lines for timestamp, msg in line.split(': ') if 'ERROR' in msg]

Question 2

Arrange the steps to handle an exception in Python using try-except.

Question 3

Arrange the steps to install a third-party Python package using pip.

Question 4

Match each exception type to its description.

Question 5

Match each Python concept to its description.

Question 6

A junior developer needs to write code that processes a list of student scores and stops processing when a score of 100 is encountered, as that score represents a perfect score that should be treated separately. Which loop construct is most appropriate?

Accepted Answer

for score in scores: if score == 100: break ... further processing. Option B is correct because the `break` statement immediately exits the loop when a score of 100 is encountered, which matches the requirement to stop processing further scores. The `for` loop iterates over the list naturally, and the `if` condition checks for the perfect score, making this the most straightforward and efficient construct for this scenario.

Answer

for score in scores: if score == 100: pass ...

Answer

for i in range(len(scores)): if scores[i] == 100: exit() ...

Answer

while scores: score = scores.pop(); if score == 100: continue ...

Question 7

A data analyst has a list of temperature readings in Celsius and wants to create a new list containing only readings that are valid (>= -273.15 and <= 1000). Which code correctly creates the filtered list?

Accepted Answer

valid = [temp for temp in temps if -273.15 <= temp <= 1000]. Option A is correct because it uses a list comprehension with a chained comparison (`-273.15 <= temp <= 1000`) that correctly includes both boundary values. This syntax is Pythonic and ensures temperatures equal to -273.15 or 1000 are considered valid, matching the requirement exactly.

Answer

valid = [temp for temp in temps if temp > -273.15 and temp < 1000]

Answer

valid = [] for t in temps: if t > -273.15 and t < 1000: valid.append(t)

Answer

valid = list(filter(lambda t: t >= -273.15, temps))

Question 8

A developer is implementing a toggle switch feature. The variable flag starts as False. Which code snippet correctly toggles the flag and performs an action based on the new value each time the code is run? (Assume action1 is performed when flag is True, action2 when False.)

Accepted Answer

flag = not flag; if flag: action1() else: action2(). Option A is correct because it first toggles the flag using `flag = not flag`, which flips the boolean value from False to True (or vice versa). Then it uses a conditional `if flag:` to check the new value and calls `action1()` when True or `action2()` when False, exactly matching the requirement to act on the new state each time the code runs.

Answer

if not flag: flag = True; action1() else: flag = False; action2()

Answer

if flag: flag = False; action1() else: flag = True; action2()

Answer

flag = not flag; if flag: action2() else: action1()

Question 9

Which code correctly and efficiently sums only positive numbers from a list?

Accepted Answer

for num in numbers:
    if num <= 0:
        continue
    total += num. Option D is correct because it uses `continue` to skip non-positive numbers and then unconditionally adds the remaining numbers to `total`. This is both efficient (no unnecessary `else` branch) and correct: it sums only positive numbers without breaking the loop prematurely or adding zero/negative values.

Answer

for num in numbers:
    if num > 0:
        total += num
    else:
        break

Answer

for num in numbers:
    if num <= 0:
        pass
    else:
        total += num

Answer

for num in numbers:
    if num > 0:
        total += num
    else:
        continue

Question 10

A developer needs to iterate over a list of network interfaces and print only the names that start with 'eth'. Which code should be used?

Accepted Answer

for iface in interfaces: if iface.startswith('eth'): print(iface). Option C is correct because the `startswith()` string method is the most direct and readable way to check if each interface name begins with the substring 'eth'. This approach avoids unnecessary slicing or substring membership checks, making the intent clear and the code efficient.

Answer

for i in range(len(interfaces)): if 'eth' in interfaces[i]: print(interfaces[i])

Answer

for iface in interfaces: if iface[:3] is 'eth': print(iface)

Answer

for iface in interfaces: if 'eth' in iface: print(iface)

Question 11

A programmer has a list of tuples representing (product, price) and wants to find the highest price. Which code correctly finds the maximum price?

Accepted Answer

max_price = max([price for product, price in prices]). Option B correctly uses a list comprehension to extract all prices from the tuples, then passes that list to the built-in `max()` function, which returns the highest numeric value. This directly solves the problem of finding the maximum price without any unnecessary complexity.

Answer

max_price = max(prices, key=lambda x: x[1])

Answer

max_price = 0; for p in prices: if p[1] > max_price: max_price = p[1]

Answer

max_price = sorted(prices, key=lambda x: x[1])[-1]

Question 12

Which code correctly creates a list of squares for numbers 1 to 5 using a list comprehension?

Accepted Answer

squares = [x**2 for x in range(1,6)]. Option C is correct because it uses the proper syntax for a list comprehension: `[expression for item in iterable]`. Here, `x**2` computes the square, and `range(1,6)` generates numbers 1 through 5 (since range excludes the stop value). This produces the list `[1, 4, 9, 16, 25]`.

Answer

squares = [x**2 for x in range(5)]

Answer

squares = [x^2 for x in (1,2,3,4,5)]

Answer

squares = [x^2 for x in [1,2,3,4,5]]

Question 13

A developer needs to implement a loop that prints numbers from 10 down to 1. Which loop correctly achieves this?

Accepted Answer

for i in range(10, 0, -1): print(i). Option A is correct because `range(10, 0, -1)` generates numbers from 10 down to 1 inclusive. The start is 10, the stop is 0 (exclusive), and the step is -1, so the sequence is 10, 9, 8, ..., 1. This matches the requirement exactly.

Answer

for i in range(10, 0): print(i)

Answer

for i in reversed(range(1, 10)): print(i)

Answer

for i in range(10, 1, -1): print(i)

Question 14

A program contains a nested while loop. The inner loop should run as long as a condition is True, but the outer loop should stop after 3 iterations. Which code structure is correct? (Assume the inner loop condition is inner < 5.)

Accepted Answer

outer = 0
while outer < 3:
    inner = 0
    while inner < 5:
        # do something
        inner += 1
    outer += 1. Option D correctly implements a nested while loop where the inner loop runs while `inner < 5` and the outer loop runs while `outer < 3`. The inner loop increments `inner` to control its own termination, and the outer loop increments `outer` after the inner loop completes, ensuring exactly 3 iterations of the outer loop. This matches the requirement that the outer loop stops after 3 iterations while the inner loop runs as long as its condition is True.

Answer

for outer in range(3):
    inner = 0
    while inner < 5:
        # do something
        inner += 1

Answer

outer = 0
while outer < 3:
    for inner in range(5):
        # do something
        outer += 1

Answer

outer = 0
while outer < 3:
    inner = 0
    while inner < 5:
        # do something
        outer += 1
        inner += 1

Question 15

Which two of the following list methods modify the original list in place? (Choose two.)

Accepted Answer

sort(). A is correct because the `sort()` method sorts the list in place, meaning it modifies the original list object without creating a new one. D is correct because `append()` adds an element to the end of the list, directly mutating the original list.

Answer

count()

Answer

sorted()

Answer

copy()