PCEP Control Flow, Loops, Lists and Logic — 100 Questions

Question 1

A developer writes a loop to sum numbers from 1 to 10. The code outputs 55, but the expected sum is 55. However, the loop uses a range that includes 0. Which range should be used to achieve the correct sum?

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

Accepted Answer

range(1,11). (range(1,11)) is correct because range(start, stop) generates numbers from start inclusive to stop exclusive. To sum numbers 1 through 10, the range must start at 1 and end at 11 (so 10 is included). The loop that used range(0,11) included 0, but since adding 0 does not change the sum, the output was still 55 — however, the question asks for the range that achieves the correct sum without including unnecessary values.

Answer

range(0,11)

Answer

range(0,101)

Answer

range(1,10)

Question 2

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()). Both Option A and Option D correctly iterate over the list and print each string in uppercase. Option A uses enumerate to get each item and calls item.upper() with parentheses, printing the result. Although it introduces an unused index variable i, it still works correctly. Option D uses range(len(mylist)) to access each element by index and prints mylist[i].upper(). Option B fails because it does not print the result; it only reassigns the variable. Option C omits the parentheses on upper(), printing the method object instead of the string.

Answer

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

Answer

for item in mylist: print(item.upper)

Question 3

A list contains strings and numbers: items = ['apple', 10, 'banana', 20]. A programmer wants to create a new list that contains only the strings. Which approach is correct?

Accepted Answer

[item for item in items if isinstance(item, str)]. The `isinstance(item, str)` function is the recommended way to check if an item is a string because it handles inheritance and is more readable. Option C, `type(item) == str`, also works in this case but is not considered the best practice for type checking in Python, especially when dealing with subclasses. Option A uses `isdigit()`, which only works for strings that represent digits, not all strings. Option B uses `type(item) is 'str'`, which compares the type to a string literal, which is incorrect.

Answer

[item for item in items if item.isdigit()]

Answer

[item for item in items if type(item) is 'str']

Answer

[item for item in items if type(item) == str]

Question 4

A programmer needs to check if at least one element in a list of booleans flags is True. Which expression correctly does this?

Accepted Answer

any(flags). The built-in `any()` function returns `True` if at least one element in the iterable is truthy. For a list of booleans, this correctly checks if any element is `True`. Option A, `True in flags`, only checks for the exact boolean `True`, but if the list contained truthy non-boolean values (e.g., integers), it would not work. Since the question specifies a list of booleans, both work conceptually, but `any()` is the standard, more robust approach and is the intended correct answer here.

Answer

True in flags

Answer

all(flags)

Answer

flags.any()

Question 5

What is the output of the code?

Accepted Answer

0 1 2 4. The code uses a for loop with range(5) to iterate over numbers 0 through 4. Inside the loop, an if statement checks if the current number equals 3; if true, the continue statement skips the remainder of the current iteration and moves to the next iteration. Therefore, when i is 3, the print(i) statement is skipped, but the loop continues with i=4, printing 4. Thus, the output is '0 1 2 4' (each on a new line). Option C correctly lists the printed values as 0, 1, 2, and 4.

Answer

No output

Answer

0 1 2 3 4

Answer

0 1 2 4 5

Question 6

A developer runs main.py and gets True. They then modify config.py by adding `allowed_ports.append(22)` and run main.py again without restarting the interpreter. What is the output?

Accepted Answer

True. Python imports modules only once per interpreter session; subsequent imports use the cached module object. Since `config.py` was already imported, modifying the file does not affect the already-loaded list object in memory. The `allowed_ports` list remains unchanged, so the condition that originally returned `True` still holds.

Answer

False

Answer

None

Answer

Error

Question 7

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?

Accepted Answer

Rewrite as: [msg for line in lines if 'ERROR' in line for msg in [line.split(': ')[1]]]. 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 8

Match each exception type to its description.

Accepted Answer

ValueError: Raised when a function gets an argument with correct type but inappropriate value. These are built-in exceptions in Python that indicate specific error conditions.

Answer

ValueError: Raised when an operation or function is applied to an object of inappropriate type

Answer

IndexError: Raised when a dictionary key is not found

Question 9

Match each Python concept to its description.

Accepted Answer

Module: A file containing Python definitions and statements. The correct matches are: Module is a single file; Package is a directory of modules; Class is a blueprint; Function is reusable code. Common mistakes are confusing module and package definitions.

Answer

Module: A collection of modules organized in a directory tree

Answer

Package: A file containing Python definitions and statements

Question 10

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

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]. 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 12

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(). 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 13

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

Accepted Answer

for num in numbers:
    if num <= 0:
        continue
    total += num. 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 14

Which three of the following expressions evaluate to True? (Choose three.)

Accepted Answer

3 in [1,2,3] and 4 not in [1,2,3]. Option C is correct because `3 in [1,2,3]` evaluates to True and `4 not in [1,2,3]` also evaluates to True, so the `and` expression yields True. Option D is correct because `'a' in 'abc'` is True, and since `or` only needs one True operand, the whole expression is True even though `5 > 10` is False. Option E is correct because `(True and False)` is False and `(False or True)` is True, so the surrounding `or` evaluates to True. Option A is incorrect because `(10 > 5)` is True but `(5 < 3)` is False, making the `and` expression False. Option B is incorrect because `(0 or 1)` evaluates to 1 (truthy), and `not 1` is False.

Answer

(10 > 5) and (5 < 3)

Answer

not (0 or 1)

Question 15

Refer to the exhibit. What is the output?

Accepted Answer

1. (1). The code initializes x to 0, then iterates over the list [1, 2, 3, 4, 5]. In each iteration, it first assigns the current number to x, then checks if the number equals 1. On the first iteration, i is 1, so x becomes 1, then the condition i == 1 is true, causing the loop to break. The print(x) statement after the loop outputs the final value of x, which is 1.

Answer

5

Answer

2

Answer

9

Question 16

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?

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 17

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 18

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 19

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 20

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