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

Question 1

A developer writes a function to log sensor readings. The function is defined as:

def log_reading(sensor_id, value, unit="C"):
    return f"{sensor_id}: {value}{unit}"

The developer calls log_reading("T1", 22, unit="F"). What is the result?

Accepted Answer

"T1: 22F". The function call provides two positional arguments ("T1" and 22) and one keyword argument (unit="F"). The keyword argument overrides the default value "C". The f-string then interpolates sensor_id, value, and unit, producing "T1: 22F". This demonstrates how default parameters can be overridden by explicit keyword arguments in a function call.

Answer

A SyntaxError because keyword arguments must come before positional arguments.

Answer

A TypeError because the function expects three arguments and only two positional arguments were given.

Answer

"T1: 22C"

Question 2

A function is defined to accept a variable number of positional arguments and return their sum. The code is:

def total(*args):
    return sum(args)

What is the result of `total(1, 2, 3)`?

Accepted Answer

6. The *args parameter collects the positional arguments into a tuple. The sum function then adds the elements of that tuple. With arguments 1, 2, and 3, the sum is 6. Thus, the function returns 6.

Answer

A tuple `(1, 2, 3)`

Answer

A TypeError is raised.

Answer

0

Question 3

An inventory script defines `def add_stock(item, quantity, *restock_dates):` and is called as `add_stock('bolt', 40, '2024-01-05', '2024-02-11')`. Inside the function, the developer wants to count how many restock dates were supplied. Which expression correctly reports that count?

Accepted Answer

len(restock_dates). The starred parameter packs all surplus positional arguments into a tuple, so the number of restock dates equals the length of that tuple. Calling the built-in len on the packed tuple gives the exact count of extra arguments received, while indexing or attribute-style length access either measures the wrong thing or fails outright.

Answer

len(restock_dates[0])

Answer

restock_dates.length

Answer

restock_dates.count

Question 4

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?

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 5

A programmer needs to store a fixed set of error codes that should not change during program execution. Which data type is most appropriate for this purpose?

Accepted Answer

tuple. A tuple is an immutable sequence, so its contents cannot be altered after creation. This ensures that the set of error codes remains constant throughout the program's execution. While lists, dictionaries, and sets can hold multiple values, they are all mutable, meaning they could be accidentally modified. The immutability of tuples makes them the most appropriate choice for storing fixed data.

Answer

dictionary

Answer

set

Answer

list

Question 6

A developer writes a function to calculate the area of a rectangle: def area(length, width): return length * width. They call it as area(5, 3). What is the result and why?

Accepted Answer

15, because the arguments are passed positionally, so length=5 and width=3.. Positional arguments are matched to parameters based on their order in the function call. The first argument binds to the first parameter, the second to the second, and so on. Since length and width are multiplied, area(5, 3) returns 15. No keyword arguments are necessary, and the function does not enforce keyword-only parameters.

Answer

15, but only if the arguments are passed as area(length=5, width=3).

Answer

A TypeError occurs because the function requires keyword arguments.

Answer

8, because the function adds the arguments instead of multiplying them.

Question 7

A developer writes a function that retrieves a value from a dictionary and handles missing keys:

def get_value(data, key):
    try:
        return data[key]
    except KeyError:
        return None

What happens if data is not a dictionary but a list, and key is an integer index?

Accepted Answer

The function returns the element at the specified index because lists support integer indexing.. The function uses a try-except block to handle KeyError, which is specific to dictionary key lookups. When data is a list and key is an integer, the expression data[key] performs list indexing, which succeeds if the index is valid. No KeyError is raised, so the except block is skipped, and the element is returned. This shows that the same syntax can work for different types, but the exception handling is tailored to dictionaries.

Answer

The function returns None because the except KeyError clause catches any error.

Answer

The function raises a KeyError because lists use integer indices, not keys.

Answer

The function raises a TypeError because lists do not support the [] operator.

Question 8

A developer uses a tuple to store immutable configuration data: config = ('localhost', 8080, True). They then write: host, port, secure = config. What is the result of this statement?

Accepted Answer

host becomes 'localhost', port becomes 8080, and secure becomes True.. Tuple unpacking assigns each element of the tuple to the corresponding variable on the left side, in order. The number of variables must equal the number of elements. In this case, three variables match three elements, so host, port, and secure receive 'localhost', 8080, and True respectively. No error occurs.

Answer

A SyntaxError occurs because the left side must be enclosed in parentheses.

Answer

A ValueError is raised because tuples cannot be unpacked into multiple variables.

Answer

host becomes the entire tuple, and port and secure are assigned None.

Question 9

A developer wants to create a dictionary that maps employee IDs to their department names. The IDs are integers, and departments are strings. Which of the following correctly creates such a dictionary?

Accepted Answer

employees = {101: "HR", 102: "IT"}. The dictionary literal {101: "HR", 102: "IT"} is the correct syntax for creating a dictionary with integer keys and string values. The dict() constructor can also be used, but keyword arguments cannot have integer names, and passing multiple positional arguments is invalid. The literal syntax is straightforward and commonly used for this purpose.

Answer

employees = dict(101: "HR", 102: "IT")

Answer

employees = dict(101="HR", 102="IT")

Answer

employees = dict([101, "HR"], [102, "IT"])

Question 10

A developer writes a function that reads an integer from a string and adds it to a running total. The code uses try: total += int(value) followed by except ValueError: total += 0. During testing, a value of '12.5' is supplied. What is the resulting behaviour?

Accepted Answer

The ValueError handler runs, total is incremented by 0, and execution continues normally.. int applied to the string '12.5' cannot produce an integer and raises ValueError. The except ValueError clause matches that exception type, so its body runs, adding zero to the total and allowing execution to continue. The conversion does not silently truncate string decimals, and the handler is correctly typed to catch exactly this failure.

Answer

The program terminates with an unhandled ValueError because except clauses cannot add to variables defined outside the function.

Answer

The conversion succeeds and total is increased by 12 because int truncates the decimal portion.

Answer

A TypeError is raised because the except clause names ValueError rather than the broader Exception class.

Question 11

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.

Question 12

A payroll script calls `calculate_bonus(employee_id, base)` inside a try block. The function raises a custom exception `BonusError` when the employee is not eligible, and the script wants to log that specific failure while still letting an unexpected ZeroDivisionError propagate to a global handler. Which except clause should the developer write?

Accepted Answer

except BonusError as err:. Naming a single specific exception type in an except clause handles exactly that failure and lets everything else propagate. Binding it with as captures the instance for logging without broadening the catch. Catching a base class or listing unrelated types would either swallow unexpected errors or fail syntactically, defeating the script's escalation requirement.

Answer

except BonusError or ZeroDivisionError as err:

Answer

except BonusError, ZeroDivisionError as err:

Answer

except Exception as err:

Question 13

A developer is writing a function that accepts a variable number of arguments and needs to handle them as a tuple. Which two of the following statements about tuples and function arguments are true? (Choose two.)

Accepted Answer

Inside a function, the *args parameter collects extra positional arguments into a tuple.. The *args parameter collects extra positional arguments into a tuple, and the * operator can unpack a tuple into positional arguments in a function call. These two features are often used together to create flexible functions. The **kwargs parameter collects keyword arguments into a dictionary, not a tuple, and tuples are immutable, so their contents cannot be changed. Understanding these behaviors is essential for working with variable argument lists in Python.

Answer

Tuples are mutable, so the arguments collected by *args can be modified inside the function.

Answer

A tuple cannot be passed to a function as a single argument if the function expects multiple parameters.

Answer

The **kwargs parameter collects extra keyword arguments into a tuple.

Question 14

A Python developer is writing a function that takes a tuple of numbers and returns a new tuple containing only the even numbers. They write the following code:

def filter_even(numbers):
    result = ()
    for num in numbers:
        if num % 2 == 0:
            result += (num,)
    return result

What is the primary reason this function works correctly?

Accepted Answer

Tuples are immutable, but the += operator creates a new tuple each time, which is then reassigned to result.. The function correctly builds a tuple of even numbers because the `+=` operator, when used with tuples, creates a new tuple by concatenation and reassigns it to the variable. Tuples are immutable, so this is the only way to 'modify' them. The other options incorrectly describe tuple immutability or methods.

Answer

Tuples support the append method, which adds elements to the end of the tuple in place.

Answer

The += operator modifies the tuple in place by adding the new element to the existing tuple object.

Answer

The function returns a list, not a tuple, because += converts the tuple to a list.

Question 15

A developer writes a function `def process(data):` that uses a try-except-else-finally block. The try block reads from a file, the except block handles IOError, the else block processes the data, and the finally block closes the file. If no exception occurs, which blocks execute and in what order?

Accepted Answer

try, else, finally. In a try-except-else-finally structure, the try block runs first. If it completes without raising an exception, the else block executes. The finally block always executes, regardless of whether an exception occurred. The except block only runs if an exception is raised. Therefore, with no exception, the order is try, else, finally.

Answer

try, except, finally

Answer

try, else, except, finally

Answer

try, finally