PCEP Functions, Tuples, Dictionaries and Exceptions Practice Test 3 — 15 Questions

Question 1

A system administrator has a Python script that uses a tuple to store immutable configuration parameters, such as server address and port. A new business requirement arises: one of these parameters (the port number) must be changeable at runtime without restarting the script. The other parameters must remain immutable. The administrator wants to minimize changes to the existing codebase and maintain clarity. Which approach best satisfies the requirement while keeping the code maintainable?

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

Accepted Answer

Store all parameters in a dictionary and update the port as needed. A dictionary allows direct mutation of the port value without affecting the immutability of other parameters. This satisfies the requirement of changing only the port at runtime while keeping the rest of the configuration unchanged, and it minimizes code changes by simply replacing the tuple with a dict and using assignment to update the port key.

Answer

Use a namedtuple and use the _replace() method to create a new instance with the updated port

Answer

Replace the entire tuple with a list to allow updates

Answer

Convert the tuple to a list, update the port, then convert back to a tuple each time

Question 2

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 3

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 4

Refer to the exhibit. What is the output?

Accepted Answer

A
C
D. The code defines a tuple containing numbers 1, 3, and 4 (e.g., `t = (1, 3, 4)`) and a dictionary `d = {'A': 1, 'B': 2, 'C': 3, 'D': 4}`. The `for` loop iterates over dictionary keys. The condition `if d[k] in t` checks if the associated value is in the tuple. Values 1, 3, and 4 are present, so keys A, C, and D are printed. Value 2 is absent, so B is not printed. The output is A, C, D each on a new line, matching option A.

Answer

B
C
D

Answer

A
B
C
D

Answer

A
C

Question 5

Refer to the exhibit. What is the output?

Accepted Answer

20
20. The exhibit shows a function `process` that takes a tuple `data` and converts it to a list, modifies the first element to 20, and returns a tuple of the first two elements. When called with `(10, 20, 30)`, the first call returns `(20, 20)`, so `print(process((10, 20, 30))[0])` prints `20`. The second call does the same, so `print(process((10, 20, 30))[1])` also prints `20`. Thus, the output is two lines each containing `20`.

Answer

10
20

Answer

10
10

Answer

20
10

Question 6

Refer to the exhibit. What is the output?

Accepted Answer

1
2
3
---
1. The code defines a tuple t = (1, 2, 3) and iterates over it with a single for loop, printing each element on a separate line. After the loop, it prints a separator line of dashes (---) and then prints the first element t[0] which is 1. The output is therefore 1, 2, 3, ---, 1 — exactly matching option B.

Answer

1
2
---
1

Answer

1
2
3
---
1
2
3

Answer

1
---
1

Question 7

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 8

Refer to the exhibit. What is the output?

Accepted Answer

Key missing
Done. The code attempts to access a dictionary key ('key') that does not exist, which raises a KeyError. The except block catches this specific exception and prints 'Key missing'. After the try-except, the 'finally' block (or code after the try-except) prints 'Done'. The output is therefore 'Key missing' followed by 'Done' on separate lines.

Answer

Done

Answer

Success
Done

Answer

Key missing
Success
Done

Question 9

Refer to the exhibit. What is the output?

Accepted Answer

[1]
[2]
[1, 3]. The code defines a function `func` that takes a list as a parameter and modifies it by appending the value 3. The list `lst` is initially `[1]`. After calling `func(lst)`, the list becomes `[1, 3]`. The output prints the list at three stages: before the call (`[1]`), inside the function (`[2]`), and after the call (`[1, 3]`). Option B correctly shows these three lines.

Answer

[1]
[2]
[3]

Answer

[1]
[2]
[1,2,3]

Answer

[1]
[2]
[1]

Question 10

Refer to the exhibit. What is the output?

Accepted Answer

Error
End. The code attempts to print 'Ok' but raises a TypeError because you cannot concatenate a string and an integer with the + operator. The exception is caught by the bare except clause, which prints 'Error', and then the finally block always executes, printing 'End'. Thus the output is 'Error' followed by 'End' on separate lines.

Answer

End

Answer

Error
Ok
End

Answer

Ok
End

Question 11

Refer to the exhibit. What is the output?

Accepted Answer

1
2
3
StopIteration. The code iterates over a tuple (1, 2, 3) using an iterator created by iter(). The for loop internally calls next() on the iterator until StopIteration is raised. After the loop finishes, the final print() statement executes, but since the iterator is exhausted, calling next() again raises StopIteration, which is not caught, so the program terminates with that exception. Thus, the output is 1, 2, 3 each on a new line, followed by the StopIteration error message.

Answer

1
2
3
Error

Answer

1
2
3
None

Answer

1
2
3

Question 12

A programmer needs to store a collection of unique employee IDs that will not change during program execution. Which data type is most appropriate?

Accepted Answer

tuple. The need is for an immutable collection of employee IDs. A tuple is immutable and can hold multiple items, making it suitable for data that should not change. While a set enforces uniqueness, it is mutable, so it does not satisfy the immutability requirement.

Answer

list

Answer

set

Answer

dictionary

Question 13

A developer is working with a dictionary `inventory = {'apples': 10, 'bananas': 5, 'oranges': 8}` and needs to perform operations that do not modify the dictionary. Which two operations return a view object that reflects changes made to the dictionary? (Choose two.)

Accepted Answer

inventory.values(). The keys() and values() methods return dynamic view objects that reflect changes to the dictionary. The items() method also returns a view, but the question asks for two, and only two are correct among the options. The get() and copy() methods do not return views.

Answer

inventory.copy()

Answer

inventory.items()

Answer

inventory.get('apples')

Question 14

A developer writes a function that returns multiple values: `def get_point(): return (3, 7)`. Which code correctly unpacks the returned tuple into variables x and y?

Accepted Answer

x, y = get_point(). Tuple unpacking assigns each element of the returned tuple to a corresponding variable. The call get_point() returns (3, 7), so x, y = get_point() sets x to 3 and y to 7. This is concise and readable. The other options either call the function multiple times, forget to call it, or use invalid unpacking syntax.

Answer

x = get_point()[0]; y = get_point()[1]

Answer

(x, y) = get_point

Answer

x, y = *get_point()

Question 15

A developer is writing a function that must return two logically related values, a status code and a message. The caller will unpack the result with code, message = process(). Which TWO approaches allow the function to return both values so that this unpacking works? (Choose two.)

Accepted Answer

return (200, 'OK'). Python functions return exactly one object. Writing return 200, 'OK' or return (200, 'OK') returns a single two-element tuple, and assignment unpacking distributes its elements across the target names. The semicolon form returns only the first value, while a dictionary would unpack its keys rather than the stored values, so neither supports the intended code, message pattern.

Answer

return 200; 'OK'

Answer

return [200, 'OK']

Answer

return {'code': 200, 'message': 'OK'}