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

Question 1

A developer is writing a Python function that must accept any number of positional arguments and return their sum. The function should also work when called with zero arguments. Which function definition correctly achieves this?

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

Accepted Answer

def total(*nums): return sum(nums). The function must handle any number of positional arguments, including zero. Using *nums in the function definition collects arguments into a tuple, and sum() correctly adds them, returning 0 for an empty tuple. Other options either restrict the number of arguments or incorrectly unpack the tuple.

Answer

def total(nums): return sum(nums)

Answer

def total(nums=0): return sum(nums)

Answer

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

Question 2

A developer needs to store configuration settings as key-value pairs and later retrieve the value for a key that may not exist, providing a default value if the key is missing. Which dictionary method should be used?

Accepted Answer

get(). The get() method safely retrieves a value for a key and returns a default if the key is absent, without altering the dictionary. Other methods either modify the dictionary or do not directly retrieve values, making them unsuitable for a read-only lookup with a fallback.

Answer

pop()

Answer

keys()

Answer

setdefault()

Question 3

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 4

A developer writes a function that assigns a new value to an element of a list passed as an argument. After the function returns, the caller observes that the original list has been modified. The developer wants a second function that appends an item to a list but leaves the caller's list unchanged. Which definition achieves this?

Accepted Answer

def add_item(lst, item):
    lst = lst + [item]
    return lst. Passing a list to a function passes a reference to the same object, so any in-place method such as append, insert, or += alters the caller's data. Only creating a new list object, as with the concatenation lst + [item], avoids mutating the caller's list while still producing an appended result that can be returned.

Answer

def add_item(lst, item):
    lst += [item]
    return lst

Answer

def add_item(lst, item):
    lst.insert(0, item)
    return lst

Answer

def add_item(lst, item):
    lst.append(item)
    return lst

Question 5

A developer defines a function `def add_item(item, basket=[]):` and calls it multiple times without providing a basket argument. After three calls with different items, what is the content of the default basket?

Accepted Answer

The basket contains all three items from the three calls, because the default list is shared and mutated.. Default arguments are evaluated once at function definition, so a mutable default like a list is shared across all calls that do not provide an explicit argument. The list is modified in place with each append, causing all items to accumulate. The other options incorrectly assume per-call initialization, overwriting, or a runtime error.

Answer

Each call gets a fresh empty list, so the basket remains empty after each call.

Answer

A TypeError is raised because mutable default arguments are not allowed in Python.

Answer

The basket contains only the item from the most recent call, as previous items are overwritten.

Question 6

A developer writes a function that needs to accept any number of positional arguments and return their sum. Which function definition correctly collects all positional arguments into a tuple named values?

Accepted Answer

def total(*values):. The *args syntax in a function definition packs all positional arguments into a tuple. Using def total(*values) makes values a tuple containing every positional argument passed. Then sum(values) returns their total. The other definitions either collect keyword arguments into a dictionary, accept only one argument, or add an unnecessary keyword-argument collector that changes the function's behavior.

Answer

def total(**values):

Answer

def total(*values, **kwargs):

Answer

def total(values):

Question 7

A developer defines a function with the signature def configure(host, port=8080, protocol='http'). A call is made as configure('web01', protocol='https'). Which statement describes what happens?

Accepted Answer

The call succeeds; host receives 'web01', port keeps its default 8080, and protocol receives 'https'.. Positional arguments bind to parameters in order, while keyword arguments bind by name regardless of position. Here the single positional value fills host, the keyword protocol fills that named parameter, and port is simply omitted, so it retains its default. The call is valid and produces host='web01', port=8080, protocol='https'.

Answer

The call fails with a SyntaxError because default parameters must always be passed explicitly when any keyword argument is used.

Answer

The call fails with a TypeError because a positional argument cannot be combined with a keyword argument.

Answer

The call succeeds, but 'https' is assigned to port because keyword arguments fill parameters in declaration order.

Question 8

A developer is writing a function that should accept any number of positional arguments and return their sum. Which function definition correctly achieves this?

Accepted Answer

def sum_all(*args): return sum(args). The *args parameter collects any number of positional arguments into a tuple, which can then be summed using the built-in sum function. The other options either accept only a single iterable, collect keyword arguments instead, or incorrectly unpack the tuple when calling sum, leading to errors.

Answer

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

Answer

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

Answer

def sum_all(args): return sum(args)

Question 9

A logistics team stores shipment data as `shipment = {'id': 'A17', 'weight_kg': 12.5, 'destination': 'Osaka'}`. A developer needs to retrieve the destination but wants the program to keep running and supply the string 'UNKNOWN' if the key is ever missing from a shipment record. Which statement should the developer use?

Accepted Answer

shipment.get('destination', 'UNKNOWN'). Reading a dictionary value without risking a KeyError requires a method that accepts a default, and dict.get is the standard tool for that. It returns the stored value when the key is present and the supplied fallback when it is not, without altering the dictionary. Methods that insert or remove keys change the record's contents, which the scenario does not permit.

Answer

shipment['destination'] or 'UNKNOWN'

Answer

shipment.pop('destination', 'UNKNOWN')

Answer

shipment.setdefault('destination', 'UNKNOWN')

Question 10

A developer defines a tuple `config = ('localhost', 8080, True)`. Later, the code attempts `config[1] = 9090`. What happens when this line executes?

Accepted Answer

A TypeError is raised because tuple objects do not support item assignment.. Tuples are immutable, meaning their elements cannot be changed after the tuple is created. The statement config[1] = 9090 tries to assign to an index, which triggers a TypeError. No automatic rebinding or type-based exception occurs. To change a value, you must build a new tuple and assign it to the variable.

Answer

The tuple is updated in place, and config becomes ('localhost', 9090, True).

Answer

The assignment succeeds only if the new value is of the same type as the old value.

Answer

A new tuple is created automatically with the updated value, and config is rebound to it.

Question 11

A developer needs to count how many times each word appears in a list named words. The code starts with counts = {} and then iterates over the list. Which loop body correctly increments the count for each word, creating the key when it is first seen?

Accepted Answer

counts[word] = counts.get(word, 0) + 1. Counting occurrences requires reading a possibly missing key without raising an exception and then storing the incremented value. The get method supplies a fallback of 0 for absent keys, and assigning the sum back to the dictionary both creates and updates the entry. The other forms either raise KeyError on first sight of a word or misuse a dictionary method.

Answer

counts[word] += 1

Answer

counts.setdefault(word) + 1

Answer

counts.update(word, counts[word] + 1)

Question 12

A developer wants to create a tuple that contains a single element, the integer 5. Which of the following expressions produces exactly that?

Accepted Answer

t = (5,). A single-element tuple requires a trailing comma to distinguish it from a parenthesized expression. The expression (5,) creates a tuple containing the integer 5, while (5) is just the integer. The tuple() constructor can also be used with an iterable, but not with a single integer. The two-element tuple is incorrect because it contains two items.

Answer

t = (5)

Answer

t = (5, 5)

Answer

t = tuple(5)

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 developer writes a function `def log_event(message, level='INFO'):` that appends a formatted string to a list. The developer calls `log_event('disk full')` and then `log_event('retrying', level='WARN')`. What is the result of these two calls?

Accepted Answer

The first call uses 'INFO' for level and the second uses 'WARN', because the default applies only when the argument is omitted.. Default arguments make a parameter optional and are bound only when the caller omits that argument. An explicit keyword argument replaces the default for that single call without changing the function's definition, so the first invocation logs at INFO and the second at WARN. Calls that mix positional and keyword arguments are valid when each parameter is filled once.

Answer

The first call raises a TypeError because a function with a default parameter must always receive that argument explicitly.

Answer

The second call raises a TypeError because positional and keyword arguments cannot be mixed in the same call.

Answer

Both calls use 'WARN', because the second call permanently changes the default for later invocations.

Question 15

A developer is writing a function that accepts a dictionary of student names and their scores. The function should return the name of the student with the highest score. If the dictionary is empty, it should return `None`. Which code snippet correctly implements this?

Accepted Answer

def top_student(scores):
    if not scores:
        return None
    return max(scores, key=scores.get). To find the key with the maximum value in a dictionary, pass a key function to max that extracts the value for each key. Using `scores.get` as the key function achieves this. The empty check prevents a ValueError. The other options either return the wrong element or fail on an empty dictionary.

Answer

def top_student(scores):
    if len(scores) == 0:
        return None
    return max(scores.items())

Answer

def top_student(scores):
    return max(scores.values())

Answer

def top_student(scores):
    return max(scores)