PCEP Practice Test 34 — 15 Questions

Question 1

A developer writes a function to update a configuration dictionary: def update_config(config, key, value): config[key] = value; return config. They call it as: my_config = {'debug': False}; result = update_config(my_config, 'debug', True). What is the value of my_config after the call, and why?

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

Accepted Answer

my_config becomes {'debug': True} because the dictionary is passed by reference and modified in place.. Because dictionaries are mutable and passed into functions by object reference, assigning to a key inside the function updates the caller's dictionary. The original object is modified in place, so the change is visible outside the function without any return or reassignment. This behavior is central to Python's argument-passing semantics for mutable types.

Answer

my_config remains {'debug': False} because integers and booleans are immutable and passed by value.

Answer

A TypeError is raised because dictionaries cannot be modified inside a function.

Answer

my_config becomes {'debug': True} only if the function returns the dictionary and the caller reassigns it.

Question 2

A programmer needs a constant that identifies the maximum number of retry attempts for a network operation. The value must not change while the program runs. Which statement about naming and using this constant in Python is accurate?

Accepted Answer

Naming it MAX_RETRIES signals by convention that it should not be reassigned. Python relies on naming conventions rather than keywords to express constants, and an all-uppercase identifier such as MAX_RETRIES is the standard signal that a value is intended to remain fixed. The language does not block reassignment, so the guarantee is social and stylistic, supported by linters and code review. Placing values in functions or containers changes scope or internal mutability but never prevents rebinding the name.

Answer

Assigning it inside a function makes it permanently immutable

Answer

Wrapping the value in a tuple prevents any later change to the name

Answer

Declaring the name with the const keyword prevents reassignment

Question 3

A developer is writing a Python script and needs to create valid variable names. Which two of the following are valid variable names? (Choose two.)

Accepted Answer

total_amount. Valid Python identifiers must start with a letter or underscore, followed by letters, digits, or underscores, and cannot be keywords. _value and total_amount satisfy these rules, while my-var contains a hyphen, 2ndPlace starts with a digit, and for is a keyword.

Answer

2ndPlace

Answer

my-var

Answer

for

Question 4

A Python programmer wants to determine whether the variable n is an even number greater than zero. Which expression correctly evaluates to True only when n is a positive even integer?

Accepted Answer

n % 2 == 0 and n > 0. Even numbers leave a remainder of zero when divided by two, which the modulo operator % detects. The comparison n > 0 filters out zero and negative values. Joining these with the logical and operator yields True only for positive even integers. Division and floor division do not test divisibility by two, and using or would accept odd values.

Answer

n % 2 == 1 or n > 0

Answer

n / 2 == 0 and n > 0

Answer

n // 2 == 0 and n > 0

Question 5

A trainee is reviewing how Python 3 handles basic data types and type conversion in a small inventory script. Which TWO statements about Python's built-in numeric and string types are correct? (Choose two.)

Accepted Answer

Calling int('42') returns the integer 42, while int('4.2') raises a ValueError. Python 3 integers grow to whatever size memory allows, so counters never silently overflow, and int() accepts only strings that look like whole numbers, rejecting anything with a decimal point. Together these behaviours shape how inventory quantities and parsed input are handled. Floats remain binary approximations, strings stay immutable, and bool is a subclass of int rather than a separate numeric family.

Answer

The bool type is a distinct numeric type where True equals 1 and False equals 0 in arithmetic

Answer

The str type is mutable, so individual characters can be replaced by index assignment

Answer

The float type stores decimal values with exact precision for any fractional number

Question 6

A Python script contains the following assignment: `value = 5` followed by `result = value * '2'`. What is the value of `result` after these statements execute?

Accepted Answer

`'22222'`. The multiplication operator `*` behaves differently depending on operand types. When one operand is an integer and the other is a string, Python repeats the string that many times. With `value = 5` and string `'2'`, the result is `'22222'`. This is a common source of confusion for beginners who expect numeric multiplication or implicit type conversion. Recognizing the operand types is essential to predicting the outcome correctly.

Answer

A `TypeError` is raised.

Answer

`'10'`

Answer

`10`

Question 7

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 8

A Python developer is writing a script that processes a list of sensor readings stored in the variable readings. The developer needs to iterate over the list and print each reading, but wants the loop to stop immediately if a reading of -999 is encountered, because that value indicates a sensor malfunction. Which code snippet correctly implements this behavior?

Accepted Answer

for reading in readings:
    if reading == -999:
        break
    print(reading). The correct implementation must iterate over the list, check for the malfunction value, and break immediately without printing that value. The snippet that places the break inside the if block and the print after the if block ensures that normal readings are printed and the loop terminates upon encountering -999. This matches the specified behavior precisely.

Answer

for reading in readings:
    if reading != -999:
        print(reading)
    else:
        break

Answer

for reading in readings:
    print(reading)
    if reading == -999:
        break

Answer

for reading in readings:
    if reading == -999:
        continue
    print(reading)

Question 9

A developer runs this code:

a = 10
b = 3
a += b * 2
a //= b
print(a)

What is printed?

Accepted Answer

5. Augmented assignment evaluates the right-hand side first, so b * 2 is 6 and a becomes 16. The floor division assignment a //= b then divides 16 by 3 and rounds down to 5. Because both operands are ints, the result stays an int and print displays 5 without a decimal point.

Answer

5.333333333333333

Answer

3

Answer

6

Question 10

A cashier script stores a product's unit price as a string read from a barcode label: price = '4.50'. The developer must compute the total for 3 units and print a numeric result. Which code produces the value 13.5?

Accepted Answer

total = float(price) * 3. The price arrives as text, so it must be converted with float() before multiplication. float('4.50') becomes 4.5, and 4.5 * 3 evaluates to 13.5. Using int() fails on the decimal point, while string repetition produces concatenated text. The correct approach converts first, then computes.

Answer

total = price * 3

Answer

total = str(price) * 3

Answer

total = int(price) * 3

Question 11

A developer writes a short script to convert a numeric string entered at the console into a number for arithmetic:

value = input('Enter a quantity: ')
total = value * 2
print(total)

A user types 7 and presses Enter. What is printed, and why?

Accepted Answer

77, because the string '7' is repeated twice by the * operator. The built-in input always yields a str in Python 3, so value refers to the two-character sequence '7'. When * receives a str on the left and an int on the right, it repeats the string that many times instead of multiplying numerically. The assignment therefore stores '77', and print outputs those characters. Converting with int(value) first would give the arithmetic result 14.

Answer

14, because input converts the entry to an integer automatically

Answer

7, because the second operand is ignored for string values

Answer

A TypeError is raised, because a string cannot be multiplied

Question 12

A developer writes a function to safely divide two numbers and wants to explicitly raise a ValueError when the divisor is zero, rather than letting a ZeroDivisionError propagate. The function signature is `def safe_divide(a, b):`. Which code snippet correctly accomplishes this?

Accepted Answer

if b == 0: raise ValueError('Cannot divide by zero') then return a / b. The correct approach checks the divisor explicitly and raises a ValueError with a clear message before any division occurs. This prevents the built-in ZeroDivisionError and gives the caller a domain-specific exception. The other options either use the wrong exception type, rely on assertions that can be disabled, or contain syntax errors that prevent execution.

Answer

if b = 0: raise ValueError('Cannot divide by zero') then return a / b

Answer

try: return a / b except ZeroDivisionError: raise ValueError

Answer

assert b != 0, 'Cannot divide by zero' then return a / b

Question 13

A developer is working with a dictionary `config = {'host': 'localhost', 'port': 8080}`. They need to perform operations that modify or access the dictionary without causing errors. Which two of the following operations are valid and will not raise an exception? (Choose two.)

Accepted Answer

`config.get('timeout')`. The `get` method safely retrieves a value without raising an exception if the key is missing, returning None. Assigning to an existing key simply updates the value. Both are valid operations that do not cause errors, unlike bracket access for missing keys, `pop` without default, or using a non-existent method.

Answer

`config.remove('host')`

Answer

`config['timeout']`

Answer

`config.pop('timeout')`

Question 14

A login script checks whether a username entered by the user is exactly 'admin' and the account is not locked. The variable locked is a boolean. Which expression evaluates to True only when the username is 'admin' and locked is False?

Accepted Answer

username == 'admin' and not locked. The rule requires two conditions to hold together: the username must equal 'admin' and the account must not be locked. The and operator enforces both, while not locked converts the boolean to its opposite. Using or would allow access when only one condition is satisfied, and testing locked directly reverses the security check.

Answer

not username == 'admin' and not locked

Answer

username == 'admin' and locked

Answer

username == 'admin' or not locked

Question 15

A developer writes a function that attempts to access a dictionary key that may not exist: def get_value(data, key): try: return data[key] except KeyError: return None. They call it as get_value({'a': 1}, 'b'). What is the result and why?

Accepted Answer

None is returned because the KeyError is caught and handled.. The function uses a try-except block to handle a potential KeyError. When the key 'b' is not found, the exception is caught, and the except block returns None. This provides a safe way to access dictionary values without causing the program to crash. The caller receives None as the result of the function call.

Answer

The function returns 1 because it falls back to the first available key.

Answer

The function returns the string 'KeyError' because the exception is converted to a string.

Answer

A KeyError is raised because the key 'b' is not in the dictionary.