PCEP Practice Test 30 — 15 Questions

Question 1

A data scientist needs to read a list of floats from a file, one per line, and compute the sum. The current code:

total = 0.0
with open("data.txt") as f:
    for line in f:
        total = total + line
print(total)

When run, a TypeError occurs: unsupported operand type(s) for +: 'float' and 'str'. The scientist knows that line is a string. Which fix will correctly sum the numbers?

Accepted Answer

Change to: total = total + float(line.strip()). Option C is correct because `float(line.strip())` converts the string read from the file (after removing any surrounding whitespace, including the newline character) into a float, which can then be added to the float variable `total`. The original error occurs because Python does not allow implicit addition of a string to a float.

Answer

Change to: total = total + eval(line)

Answer

Change to: total = total + line.strip()

Answer

Change to: total = total + int(line)

Question 2

A programmer is writing a script to read a number, determine if it is even or odd, and then also use the number to calculate its square. The code:

num = input("Enter a number: ")
if num % 2 == 0:
    print("Even")
else:
    print("Odd")
square = num ** 2
print("Square:", square)

When run, a TypeError occurs on the modulo line. Which fix will resolve the error and allow the later calculation to work?

Accepted Answer

Change the input to: num = int(input("Enter a number: ")). Option D is correct because the `input()` function always returns a string, and the modulo operator `%` and exponentiation operator `**` require numeric operands. By converting the input to an integer with `int(input(...))`, both the modulo and exponentiation operations work correctly, resolving the TypeError and allowing the square calculation to proceed.

Answer

Change the condition to: if num // 2 == 0:

Answer

Change the condition to: if float(num) % 2 == 0:

Answer

Change the condition to: if int(num) % 2 == 0:

Question 3

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)`. Option B is correct because `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]`

Question 4

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. Option D is correct because 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 5

A student is learning Python and writes a program to compute the area of a rectangle. The code:

length = input("Enter length: ")
width = input("Enter width: ")
area = length * width
print("Area:", area)

When the user enters 5 and 3, the program crashes with a TypeError: can't multiply sequence by non-int of type 'str'. The student is puzzled because they thought input returns numbers. What is the correct explanation and fix?

Accepted Answer

The input function returns a string, so use int(input("Enter length: ")) and int(input("Enter width: ")).. Option A is correct because the `input()` function in Python always returns a string, even if the user types a number. When you try to multiply two strings (or a string by a string), Python raises a `TypeError` because it cannot multiply sequences by non-integers. The fix is to explicitly convert the input to an integer using `int()` before performing arithmetic.

Answer

The error is due to variable names length and width conflicting with built-in functions; rename them to l and w.

Answer

The print function cannot handle the multiplication result because area is a string; convert area to int.

Answer

The error can be fixed by using the eval function to directly evaluate the input as Python code.

Question 6

A developer is working on a project that requires handling large numbers. They write:

x = 10000000000
y = 3.0
z = x / y
print(int(z))

The output is 3333333333. However, the developer expected 3333333333 (same). But they suspect that integer division might be better. They try:

x = 10000000000
y = 3
z = x // y
print(z)

Output: 3333333333. Both give same. Now they test with negative numbers:

x = -10
y = 3
z1 = x / y
z2 = x // y
print(z1, z2)

The output is -3.3333333333333335 and -4. The developer is confused why z2 is -4 instead of -3. Which of the following explains the behavior?

Accepted Answer

Floor division always rounds down toward negative infinity, so -10 // 3 = -4 because -3.33 floor is -4.. Option C is correct because Python's floor division (`//`) always rounds down toward negative infinity, not toward zero. For `-10 // 3`, the exact result is approximately -3.333..., and the floor (largest integer ≤ the value) is -4, not -3. This is consistent with the mathematical definition of floor division used in Python.

Answer

The division operator / rounds toward zero, while // rounds toward negative infinity.

Answer

Truncation division always rounds toward zero, so -10 // 3 should be -3, but Python has a bug.

Answer

The result depends on the types; using float y yields different result.

Question 7

A junior developer is tasked with writing a Python script that reads a list of integers from a file, removes any duplicate numbers, and then writes the unique numbers back to the same file in ascending order. The file 'numbers.txt' currently contains one integer per line. The developer writes the following code:

with open('numbers.txt', 'r') as f:
    numbers = [int(line.strip()) for line in f]
unique = list(set(numbers))
unique.sort()
with open('numbers.txt', 'w') as f:
    for num in unique:
        f.write(str(num) + '
')

The script runs without errors, but the output file contains the numbers in descending order instead of ascending. The developer checks the sort() method and confirms it sorts in ascending order. What is the MOST likely cause of the issue?

Accepted Answer

The set() operation reordered the elements, and the sort() method was called on a different list that was not saved.. Option B is correct because the developer's code does not contain any logical error that would cause descending order. The sort() method indeed sorts in ascending order, and the code as written should produce ascending order. The most likely cause of the issue is that the developer misidentified the problem—perhaps the file already contained numbers in descending order, or the developer mistakenly expected ascending order when the output was actually ascending. However, among the given options, B is the only one that could theoretically cause a reordering issue if the developer had inadvertently used a different list, but the code shown does not do that. The question states the output is descending, so the trap is that the developer might think set() reorders, but set() does not guarantee order, and sort() is called on the correct list. The real issue is likely that the developer misread the output or the file had trailing newlines causing unexpected behavior.

Answer

The numbers were read as strings and the sort() method sorted them lexicographically, putting '10' before '2'.

Answer

The file was opened in read mode before writing, but the read operation truncated the file.

Answer

The file was opened in append mode instead of write mode, causing the sorted numbers to be appended after the original unsorted numbers.

Question 8

A system administrator writes a script to monitor disk usage. The script reads a percentage from a file as a string, e.g., "100". The code:

usage = open("usage.txt").read().strip()
if usage > 80:
    print("Warning: disk usage high")
else:
    print("Disk usage OK")

Even when usage.txt contains "100", the script prints "Disk usage OK". The admin expected "Warning". What is the problem and how to fix?

Accepted Answer

The file reading returns a string; convert usage to int before comparison.. Option C is correct because the `read()` method returns the file content as a string. In Python, comparing a string to an integer with `>` performs lexicographic (character-by-character) comparison, not numeric comparison. For example, `"100" > 80` evaluates to `False` because `"1"` (ASCII 49) is less than `80` (integer), so the condition fails and the script prints "Disk usage OK". Converting the string to an integer with `int(usage)` before the comparison ensures numeric comparison works as intended.

Answer

The comparison operator > is incorrect; use >= instead.

Answer

The file is not properly closed; use with statement.

Answer

The strip() method removes newlines but not spaces; usage may have extra spaces.

Question 9

A student tries to write a program that prints the square of a number. The code:

num = 5
print("The square is " + num ** 2)

When run, a TypeError occurs. Which of the following fixes the error and produces exactly the output 'The square is 25'?

Accepted Answer

Change to: print("The square is " + str(num ** 2)). Option A is correct because it converts the integer result of `num ** 2` (which is 25) to a string using `str()`, allowing concatenation with the string literal `"The square is "`. Without this conversion, Python raises a `TypeError` because the `+` operator cannot concatenate a string and an integer directly.

Answer

Change to: print("The square is " + num ** 2)

Answer

Change to: print("The square is", num ** 2)

Answer

Change to: print("The square is " + (num ** 2))

Question 10

A system administrator wrote a Python script to monitor disk usage. The script reads the output of a system command that returns a string like 'Used: 45%' and extracts the percentage. The code uses slicing to get the numeric part and converts to int. However, on some servers, the output format changes to 'Used: 45.2%', causing a ValueError when converting to int. The administrator needs a robust solution that works with both integer and floating-point percentages while still producing an integer result (e.g., 45 for 45.2%). Which option is the best approach?

Accepted Answer

Use a try-except block to attempt int conversion first; if a ValueError occurs, convert to float and then convert to int (which truncates the decimal part).. Option D is correct because it uses a try-except block to first attempt int conversion for integer percentages, and if a ValueError occurs (due to a decimal point), it converts to float and then to int, which truncates the decimal part. This approach handles both '45%' and '45.2%' formats without raising an error, producing an integer result as required.

Answer

Use string splitting to extract the numeric part, then convert to float and round to the nearest integer.

Answer

Use a regular expression to extract the number and convert to float, then convert to int.

Answer

Use the .replace() method to remove the '%' character and then convert to int.

Question 11

A data analyst needs to read two integers from the user and compute their average as a float. The current code:

a = int(input())
b = int(input())
avg = a + b / 2
print(avg)

The output is always incorrect when a=5 and b=7 (expected 6.0, actual 8.5). The analyst cannot identify the bug. What is the root cause and correct fix?

Accepted Answer

The addition and division have wrong operator precedence; use parentheses: (a + b) / 2.. Option C is correct because in Python, the division operator `/` has higher precedence than addition `+`, so `a + b / 2` is evaluated as `a + (b / 2)`, not `(a + b) / 2`. For a=5 and b=7, this computes `5 + (7 / 2) = 5 + 3.5 = 8.5` instead of the expected `(5 + 7) / 2 = 12 / 2 = 6.0`. Adding parentheses around `a + b` forces the addition to occur first, yielding the correct average as a float.

Answer

The input function is not converting correctly; use float(input()) instead.

Answer

The print function is rounding the result; use print("{:.1f}".format(avg)).

Answer

The division operator / always returns an integer; use // instead.

Question 12

A junior developer is writing a script to calculate the total cost of items in a shopping cart. The script uses variables item_price (float) and quantity (int). The code is:

item_price = 2.5
quantity = 3
total = item_price * quantity
print("Total: " + total)

When run, this code raises a TypeError. The developer is confused because the multiplication seems correct. What is the most likely issue and the correct fix?

Accepted Answer

The print function cannot concatenate a string with a float; convert total to string using str(total).. Option D is correct because the `print` function in Python expects all arguments to be strings when using the `+` operator for concatenation. The variable `total` is a float (result of multiplying a float by an int), and Python does not implicitly convert it to a string. The error is a `TypeError: can only concatenate str (not 'float') to str`. The fix is to explicitly convert `total` to a string using `str(total)` before concatenation.

Answer

The variable total is being overwritten by the print statement; use a different variable name.

Answer

The multiplication should be written as int(item_price) * quantity to ensure integer result.

Answer

The variable names are too descriptive; rename them to a and b to avoid confusion.

Question 13

A beginner Python learner writes a script to swap two numbers:

a = 10
b = 20
a = b
b = a
print("a =", a, "b =", b)

The output is "a = 20 b = 20". The learner expected "a = 20 b = 10". Which of the following is the most Pythonic way to fix the code?

Accepted Answer

Use tuple unpacking: a, b = b, a. Option B is correct because tuple unpacking is the most Pythonic and idiomatic way to swap two variables. It leverages Python's ability to evaluate the right-hand side as a tuple before assignment, so the original values of `a` and `b` are captured simultaneously, avoiding the overwrite issue in the original code.

Answer

Use bitwise XOR: a ^= b; b ^= a; a ^= b

Answer

Use a temporary variable: temp = a; a = b; b = temp

Answer

Use integer arithmetic: a = a + b; b = a - b; a = a - b

Question 14

You are a developer for a financial application that processes transactions. The application uses a dictionary to store account balances where keys are account numbers (strings) and values are floats. A function `transfer(from_acc, to_acc, amount)` is supposed to subtract amount from `from_acc` and add it to `to_acc`. However, some transfers are resulting in incorrect balances: the `from_acc` balance is reduced but the `to_acc` balance is not increased. The code uses `try-except` to catch KeyError if an account does not exist. Upon inspection, the function first checks if both accounts exist, then performs subtraction, then addition, and finally returns success. No exceptions are raised during the problematic transfers. The accounts definitely exist. What is the most likely cause?

Accepted Answer

The dictionary is being modified concurrently by multiple threads or processes without synchronization, leading to race conditions.. Option A is correct because the described symptom — the `from_acc` balance is reduced but the `to_acc` balance is not increased — is a classic race condition. In Python, dictionary operations like `dict[key] -= amount` are not atomic; they involve a read, modify, and write sequence. If two threads execute the transfer function concurrently on overlapping accounts, one thread's write to `to_acc` can be overwritten by another thread's stale read, causing the addition to be lost. The `try-except` only catches `KeyError`, not data races, and since no exception is raised, the only plausible explanation is unsynchronized concurrent access.

Answer

The function catches KeyError and silently returns without completing the transfer.

Answer

The function does not check if the from_acc has sufficient balance before subtracting.

Answer

The balances are stored as strings instead of floats, causing concatenation instead of arithmetic.

Question 15

A developer is writing a program to calculate the average of three test scores. The current code reads scores as integers: a=int(input()); b=int(input()); c=int(input()); avg = (a+b+c)/3; print(avg). For scores 7, 8, and 9, the output is 8.0, but the requirement is to print the integer average (8), rounded to the nearest whole number. Which modification should the developer make to meet the requirement?

Accepted Answer

Use round(avg): print(round(avg)). The requirement is to print the integer average rounded to the nearest whole number. Using `round(avg)` correctly rounds the floating-point result (8.0) to the nearest integer (8) and prints it as an integer, satisfying the requirement. Option D is correct because `round()` performs standard rounding (banker's rounding in Python 3) and returns an integer when called with a single argument.

Answer

Use integer division after multiplying sum

Answer

Use integer division: avg = (a+b+c)//3

Answer

Use int(avg): print(int(avg))