PCEP Hard Questions — 25 Difficult Questions

Question 1

According to PEP 8, which of the following is the recommended way to name a constant representing the maximum number of retries?

Accepted Answer

MAX_RETRIES. PEP 8 (Python Enhancement Proposal 8) recommends that constants be named using uppercase letters with underscores separating words, i.e., `MAX_RETRIES`. This convention distinguishes constants from regular variables, which use lowercase with underscores, and helps improve code readability and maintainability.

Answer

max_retries

Answer

1st_retry_limit

Answer

maxRetries

Question 2

Refer to the exhibit. What is the output?

Accepted Answer

{'key': 'new_value'}. The `update()` method on a dictionary modifies the dictionary in place by updating the value for an existing key. Since `my_dict` already contains the key `'key'`, calling `update({'key': 'new_value'})` changes its value to `'new_value'`, and the method returns `None`. The print statement outputs the updated dictionary, which is `{'key': 'new_value'}`.

Answer

{'key': 'old_value'}

Answer

{'another': 'dict'}

Answer

None

Question 3

Given the code: x = 10; y = 3.0; z = x / y; print(type(z)). What is the output?

Accepted Answer

. In Python, when you divide an integer by a float using the / operator, the result is always a float. Here, x is an integer (10) and y is a float (3.0), so z = 10 / 3.0 evaluates to 3.3333333333333335, which is of type float. The print(type(z)) outputs , making option B correct.

Answer

Answer

Answer

Question 4

Given the code: my_list = [1, 2, 3, 4, 5]. What is the output of print(my_list[-3:-1])?

Accepted Answer

[3, 4]. Python list slicing with negative indices counts from the end of the list. my_list[-3:-1] starts at index -3 (value 3) and goes up to but does not include index -1 (value 5), so it returns [3, 4].

Answer

[4, 5]

Answer

[2, 3]

Answer

[3, 4, 5]

Question 5

Which THREE of the following expressions evaluate to True?

Accepted Answer

10 / 2 == 5.0. Option A is correct because in Python the true division operator / always returns a float, so 10 / 2 yields 5.0, and 5.0 == 5.0 is True. Option B is correct because the floor division operator // returns the integer quotient when both operands are integers, so 10 // 2 yields 5, and 5 == 5 is True. Option C is correct because the modulo operator % returns the remainder of the division, and 10 divided by 2 has remainder 0, so 10 % 2 == 0 is True. Option D is incorrect because 10 // 2 evaluates to 5, not 5.1, so 5 == 5.1 is False. Option E is incorrect because 10 % 2 evaluates to 0, not 1, so 0 == 1 is False.

Answer

10 // 2 == 5.1

Answer

10 % 2 == 1

Question 6

You are a developer in a financial firm. Your team is building a Python module that performs complex calculations on large datasets. To improve performance, you are using list comprehensions and built-in functions. Your code passes all unit tests, but during integration testing, the memory usage spikes unexpectedly. The problematic area is a function that constructs a large list of intermediate results using a list comprehension that references a generator. The code is:

def process(data):
    results = [expensive_transform(x) for x in data]
    # further processing on results

You suspect that the list comprehension stores all results in memory at once, but you need to keep the function's output as a list for subsequent operations. What is the best solution to reduce memory without changing the function's return type?

Accepted Answer

Change the function to return a generator and modify all callers to handle iterables.. Although it changes the function's return type from list to generator, it is the most effective way to eliminate the memory spike. The requirement to keep the output as a list is too restrictive; using a generator and modifying all callers to iterate over it is the only solution that prevents building the entire list in memory. Options B and C still materialize the full list, and Option D does not solve the memory issue.

Answer

Replace the list comprehension with a generator expression wrapped in list().

Answer

Use a for loop with the .append() method instead of comprehension.

Answer

Increase the system's available memory via configuration.

Question 7

You are working on a network automation script that reads a configuration file containing firewall rules. Each rule is a dictionary with keys 'source_ip', 'dest_ip', 'action'. The script must iterate over the rules and print all rules where action is 'allow'. However, the script is not printing any output even though there are allow rules in the file. The code snippet is:

rules = [{'source_ip':'10.0.0.1','dest_ip':'10.0.0.2','action':'allow'},
         {'source_ip':'10.0.0.2','dest_ip':'10.0.0.3','action':'deny'}]
for rule in rules:
    if rule('action') == 'allow':
        print(rule)

What is the most likely cause of the problem?

Accepted Answer

The developer used rule('action') instead of rule['action']. In Python, dictionary values are accessed using square brackets (e.g., rule['action']) or the .get() method, not parentheses. Using parentheses like rule('action') attempts to call the dictionary as a function, which raises a TypeError and prevents the script from executing, so no output is printed even though allow rules exist.

Answer

The dictionary does not have an 'action' key

Answer

The developer used rule['action'] instead of rule.get('action')

Answer

The for loop syntax is incorrect; it should be for rule in rules:

Question 8

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).. 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 9

In a try-except block, a developer has two except clauses: except ValueError: and except: (bare except). If the code in the try block raises a ValueError, which except clause is executed?

Accepted Answer

The ValueError except clause. When a ValueError is raised in the try block, Python searches the except clauses in the order they appear. It finds the first matching clause, which is `except ValueError:`, and executes it. The bare `except:` clause is only reached if no preceding named except clause matches the exception type.

Answer

Both in order

Answer

Neither; program crashes

Answer

The bare except clause

Question 10

Which three of the following statements about lists are true? (Choose three.)

Accepted Answer

Lists can be indexed with integers.. Lists in Python are ordered sequences that support indexing with integers, starting from 0 for the first element and negative integers for reverse indexing. This allows direct access to any element by its position, a fundamental feature of sequence types in Python.

Answer

Lists have a fixed size once created.

Answer

Lists can only contain elements of the same data type.

Question 11

What is the output of: print(2 ** 3 ** 2)?

Accepted Answer

512. In Python, the exponentiation operator ** is right-associative, meaning that `2 ** 3 ** 2` is evaluated as `2 ** (3 ** 2)`, not `(2 ** 3) ** 2`. First, `3 ** 2` equals 9, then `2 ** 9` equals 512. Thus, the correct output is 512.

Answer

12

Answer

64

Answer

256

Question 12

Refer to the exhibit. What is the output of the code?

Accepted Answer

15 13. The code defines a function `func` that attempts to modify a tuple element (`t[1] = 10`). Since tuples are immutable, this raises a `TypeError`. The `except` block catches the error and prints `x` (15) followed by `t[1]` (13), resulting in the output '15 13'. Therefore, the correct answer is C.

Answer

15 15

Answer

13 15

Answer

8 8

Question 13

Refer to the exhibit. What is the printed value?

Accepted Answer

35. The expression in the exhibit is (2+3)*(5+2). Parentheses have the highest precedence, so we first evaluate the two addition operations: 2+3=5 and 5+2=7. Then we multiply the results: 5*7=35. Therefore, the printed value is 35, corresponding to option D.

Answer

27

Answer

5

Answer

21

Question 14

Refer to the exhibit. What is the output of Line C?

Accepted Answer

33. Line C calls the function `func` with arguments `a=10` and `b=20`. Inside the function, `x` is assigned the value of `a` (10), and `y` is assigned the value of `b` (20). The function then returns `x + y + 3`, which is `10 + 20 + 3 = 33`. Therefore, the output is 33.

Answer

TypeError

Answer

30

Answer

10

Question 15

Which TWO of the following code snippets will result in a SyntaxError? (Choose two.)

Accepted Answer

if x > 5
    print('big'). Causes a SyntaxError because the `if` statement is missing a colon (`:`) after the condition, which is required for compound statements. Options A, B, C, and E are all valid Python 3 syntax. Option A uses multiple statements on one line with a semicolon. Option B calls the `print()` function correctly. Option C correctly uses a colon and indentation for the `for` loop. Option E correctly uses a colon for the `if` statement. Therefore, only D is a SyntaxError.

Answer

a = 1; b = 2

Answer

print('hello')

Answer

for i in range(5):
    print(i)

Answer

if x > 5:
    print('big')

Question 16

Which of the following is the most efficient (Pythonic) way to create a list of squares for numbers 0 through 9?

Accepted Answer

squares = [i*i for i in range(10)]. Uses a list comprehension, which is the most Pythonic and efficient way to create a list because it combines iteration and list construction in a single, readable expression. It avoids the overhead of repeated method calls (like `append`) and is faster than `map` with a lambda due to reduced function call overhead.

Answer

squares = []; for i in range(10): squares.append(i*i)

Answer

squares = list(map(lambda x: x*x, range(10)))

Answer

squares = (i*i for i in range(10))

Question 17

Which exception is raised when trying to access a dictionary key that does not exist?

Accepted Answer

KeyError. In Python, when you attempt to access a dictionary key that does not exist using square bracket notation (e.g., `my_dict['nonexistent']`), the interpreter raises a `KeyError`. This is the standard exception for missing dictionary keys, as defined in the Python language specification. The correct answer is A.

Answer

TypeError

Answer

ValueError

Answer

AttributeError

Question 18

A company runs a script that processes user input temperatures. The script expects integers but sometimes users enter floats. The current code is: temp = int(input("Enter temperature: ")). When a user enters "36.5", the script crashes with a ValueError. The developer needs to modify the script to handle both integer and float inputs gracefully, converting the input to an integer (by truncation) for processing. Which of the following is the best course of action?

Accepted Answer

Use temp = int(float(input())). It first converts the input string to a float (handling both integer and float strings), then truncates the float to an integer via int(). This gracefully processes inputs like '36.5' without crashing, meeting the requirement to truncate rather than round.

Answer

Use input with a regex check to ensure only integers are entered.

Answer

Use a try-except block to catch ValueError and ask the user to re-enter.

Answer

Use float(input()) and do not convert to int, store as float.

Question 19

A company has a Python script that imports a module from a package. The package structure is: mypackage/__init__.py, mypackage/module.py. The script uses 'from mypackage import module'. Which file must exist for this import to work?

Accepted Answer

mypackage/__init__.py. For a Python import like 'from mypackage import module' to work, the directory 'mypackage' must be recognized as a package. This requires the presence of an __init__.py file inside it (even if empty), which signals to Python that the directory is a package and allows its submodules to be imported. Option B is correct because __init__.py is the file that makes 'mypackage' a package.

Answer

mypackage.py

Answer

module.py in the current directory

Answer

Only mypackage/module.py is needed

Question 20

Refer to the exhibit. What is the output of the code?

Accepted Answer

4. The code iterates over the list `[1, 2, 3, 4]` and breaks out of the loop when `i == 3`, so only the first three iterations execute. The `else` clause on the `for` loop runs only if the loop completes without a `break`, so it is skipped. The final value of `i` after the loop is 3, but the code prints `i + 1`, which yields 4.

Answer

Loop ended normally
4

Answer

7

Answer

1