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

Question 1

A company needs to filter a list of temperatures in Celsius to only those above 0, then convert to Fahrenheit (multiply by 9/5 and add 32). Which code snippet correctly accomplishes this using a list comprehension?

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

Accepted Answer

[t*9/5+32 for t in temps if t>0]. It uses the standard list comprehension syntax: `[expression for item in iterable if condition]`. Here, `t*9/5+32` is the expression that converts Celsius to Fahrenheit, `for t in temps` iterates over the list, and `if t>0` filters out temperatures at or below zero. This produces a new list containing only the Fahrenheit equivalents of positive Celsius temperatures.

Answer

[t for t in temps if t>0 then t*9/5+32]

Answer

[t*9/5+32 for t in temps if t>0 else 0]

Answer

[t*9/5+32 for t in temps if t>0 else t]

Question 2

A developer writes code to iterate over a list and break when a certain condition is met. Which keyword is used to exit the loop prematurely?

Accepted Answer

break. The `break` keyword is used in Python to immediately exit the nearest enclosing loop (for or while) when a specified condition is met, allowing the program to resume execution at the next statement after the loop. This is the standard mechanism for premature loop termination in Python, as defined in the language specification.

Answer

stop

Answer

exit

Answer

continue

Question 3

A log file processing script uses a while loop to read lines until a specific pattern is found. The code currently hangs. The developer suspects an infinite loop. Which change is most likely to fix the issue?

Accepted Answer

Ensure the condition variable is updated inside the loop. An infinite while loop typically occurs when the condition controlling the loop never becomes false. In a log file processing script, the condition variable (e.g., a line counter or a flag indicating the pattern was found) must be updated inside the loop body. Without that update, the loop condition remains true indefinitely, causing the hang. Adding a `break` statement (option A) would exit the loop unconditionally after the first iteration, which is not the intended fix for a missing update.

Answer

Add a break statement after reading the line

Answer

Increase the sleep time in the loop

Answer

Replace while with for loop

Question 4

What is the output of the code?

numbers = [1, 2, 3, 4]
result = [x**2 for x in numbers if x % 2 == 0]
print(result)

Accepted Answer

[4, 16]. The list comprehension `[x**2 for x in numbers if x % 2 == 0]` iterates over `numbers`, filters for even numbers (2 and 4) using the condition `x % 2 == 0`, and squares each selected element. Squaring 2 gives 4, squaring 4 gives 16, so the result is `[4, 16]`. Option B is correct.

Answer

[2, 4]

Answer

[1, 9]

Answer

[2, 4, 16]

Question 5

A network engineer writes a script to validate IP addresses. The script checks each octet and prints 'Valid' if all octets are between 0 and 255, otherwise 'Invalid'. However, the script always prints 'Invalid' for valid IPs. The code uses a for loop with an else clause. Which logical error is likely?

Accepted Answer

The for loop's else clause executes when the loop completes without break, but the engineer expects else to run when break occurs. In Python, a `for` loop's `else` clause executes only when the loop completes normally (i.e., without hitting a `break`). The engineer likely intended the `else` to run when an invalid octet is found (triggering a `break`), but instead the `else` runs when all octets are valid and the loop finishes without breaking, causing the script to always print 'Invalid' when the validation logic is inverted.

Answer

The list of octets is not properly split

Answer

The condition uses 'or' instead of 'and'

Answer

The else clause is indented incorrectly

Question 6

Which of the following best describes the behavior of the 'range' function in a for loop?

Accepted Answer

It generates a sequence of numbers from start to stop exclusive. The built-in `range()` function in Python generates an immutable sequence of numbers from the start value (default 0) up to, but not including, the stop value. When used in a `for` loop, it yields each number in the sequence one at a time, making it ideal for iterating a fixed number of times. The stop value is exclusive, meaning the loop body does not execute for the stop value itself.

Answer

It returns a list of numbers with a default step of 0

Answer

It can only be used with integers

Answer

It generates a list of numbers from start to stop inclusive

Question 7

What does the following code print?

x = 10
if x > 5:
    if x > 15:
        print("A")
    else:
        print("B")
else:
    print("C")

Accepted Answer

B. The code first checks if x > 5, which is true because x = 10. Then it checks if x > 15, which is false, so the else branch of the inner if-else executes, printing 'B'. The outer else is skipped entirely.

Answer

No output

Answer

C

Answer

A

Question 8

A developer is writing a function that takes a list of numbers and returns the sum of all even numbers. Which two code snippets correctly implement this function? (Select two.)

Accepted Answer

def sum_even(nums): total=0; for n in nums: if n%2==0: total+=n; return total. It initializes a total variable to 0, iterates over each number in the list, checks if it is even using the modulo operator (n % 2 == 0), and adds the number to the total. This correctly accumulates the sum of all even numbers and returns the final total.

Answer

def sum_even(nums): return [n for n in nums if n%2==0]

Answer

def sum_even(nums): total=0; for i in range(len(nums)): if nums[i]%2==0: total+=nums[i]*2; return total

Answer

def sum_even(nums): total=0; for n in nums: if n%2==1: total+=n; return total

Question 9

Which two of the following are valid ways to create a list with elements 1, 2, 3? (Select two.)

Accepted Answer

list = list(range(1, 4)). `list(range(1, 4))` creates a list from the range object that generates numbers 1, 2, and 3 (the `range` function stops before the stop value 4). This is a common Python idiom for converting a range into a list.

Answer

list = [1, 2, 3]]

Answer

list = (1, 2, 3)

Answer

list = [1; 2; 3]

Question 10

A system administrator is writing a Python script to monitor server uptime. The script reads a log file line by line, parses timestamps, and stores them in a list. It then loops through the list to detect gaps longer than 5 minutes that indicate a crash. However, the script keeps missing crashes. The current loop is a for loop that iterates over the list using indices. The administrator suspects the loop logic. The loop uses 'for i in range(len(timestamps)-1): if timestamps[i+1] - timestamps[i] > 300: print("Crash detected")'. Timestamps are integers representing seconds since epoch. What is the most likely cause of missed crashes and the best fix?

Accepted Answer

The timestamps list may not be sorted. The loop assumes timestamps are in chronological order, but if the list is unsorted, adjacent elements may not represent consecutive events, causing the time difference to be negative or misleading, and thus missing actual gaps. Sorting the list before the loop ensures that timestamps[i+1] - timestamps[i] correctly reflects the time between consecutive log entries.

Answer

The loop should use range(len(timestamps)) instead of -1

Answer

The difference should be computed as timestamps[i] - timestamps[i+1]

Answer

The comparison should be > 300, but use > 300.0

Question 11

A data analyst is processing a large dataset of customer transactions. The dataset is stored as a list of dictionaries, each with keys 'amount' and 'date'. The analyst needs to compute the total revenue for 2024. They write:

total = 0
for t in transactions:
    if t['date'].year == 2024:
        total += t['amount']

They then run it and get a KeyError: 'date'. After inspection, they notice that some records have a 'Date' key (capital D) instead. The analyst wants to fix this without modifying the data. Which approach will correctly sum amounts regardless of key case?

Accepted Answer

Change the if condition to: if t.get('date', t.get('Date')).year == 2024. `dict.get(key, default)` safely attempts to retrieve the value for 'date', and if that key is missing, it falls back to retrieving the value for 'Date'. This handles the case inconsistency without modifying the original data and avoids a KeyError. The `.year` attribute is then accessed on the returned date object.

Answer

Use a try-except block to catch KeyError and use alternative key

Answer

Convert all keys to lowercase before processing

Answer

Use a list comprehension with conditional chaining

Question 12

A developer is writing a simple number guessing game. The computer picks a random number between 1 and 100, and the user keeps guessing until correct. The developer implements:

secret = random.randint(1,100)
guess = 0
while guess != secret:
    guess = int(input("Guess: "))
    if guess == secret:
        print("Correct!")
    else:
        print("Wrong, try again.")

The game works, but the developer notices that if the user enters something that is not an integer, the program crashes. Which modification ensures the program handles non-integer input gracefully?

Accepted Answer

Use a try-except around the input conversion. Wrapping the `int(input(...))` in a `try-except` block catches the `ValueError` that occurs when the user enters a non-integer string. This allows the program to handle the error gracefully (e.g., by printing a message and continuing the loop) instead of crashing. The other options do not prevent the crash when `int()` receives invalid input.

Answer

Use a while True loop with break

Answer

Change the data type of guess to string

Answer

Add an if statement to check if input is digit

Question 13

Which two of the following statements about Python lists are true?

Accepted Answer

List elements can be accessed using negative indices.. Python lists support negative indexing, where -1 refers to the last element, -2 to the second last, and so on. This allows convenient access to elements from the end of the list without needing to calculate the length.

Answer

Lists are immutable.

Answer

The append() method inserts an element at the beginning of the list.

Answer

Lists can only contain elements of the same data type.

Question 14

A junior developer writes a Python script to sum all numbers greater than 10 from a list. The code is:

numbers = [5, 12, 8, 15, 3]
total = 0
for num in numbers:
    if num > 10:
        total = total + 1
print(total)

The output is 2, but the expected sum is 27 (12+15). Which change will produce the correct output?

Accepted Answer

Change `total = total + 1` to `total += num`. The original code increments `total` by 1 for each qualifying number, counting them instead of summing their values. Changing `total = total + 1` to `total += num` adds the actual number to the accumulator, producing the correct sum of 12 + 15 = 27.

Answer

Change `total = 0` to `total = []`

Answer

Change `if num > 10:` to `if num >= 10:`

Answer

Change `for num in numbers:` to `for num in range(numbers):`

Question 15

A data analyst writes a Python script to double each element in a matrix without altering the original. The code is:

original = [[1,2,3],[4,5,6]]
copy = original
for i in range(len(original)):
    for j in range(len(original[i])):
        copy[i][j] *= 2
print(original)

The output shows [[2,4,6],[8,10,12]], meaning the original was also changed. Which single modification to the line 'copy = original' ensures the original matrix remains unchanged?

Accepted Answer

Replace `copy = original` with `import copy; copy = copy.deepcopy(original)`. `copy.deepcopy()` creates a fully independent copy of the nested list structure. In Python, assignment (`copy = original`) only copies the reference to the outer list, so modifying elements through `copy` also modifies `original`. Shallow copies (like `original[:]` or `list(original)`) copy the outer list but still share references to the inner lists, so changes to inner elements affect both. Only `deepcopy` recursively duplicates all nested objects, ensuring the original matrix remains unchanged.

Answer

Replace `copy = original` with `copy = original[:]`

Answer

Replace `copy = original` with `copy = list(original)`

Answer

Replace the nested loop with a list comprehension: `copy = [[x*2 for x in row] for row in original]`