PCEP · topic practice

Functions, Tuples, Dictionaries and Exceptions practice questions

Q: How should I use these Functions, Tuples, Dictionaries and Exceptions practice questions?

Read each scenario carefully and choose your answer before revealing the explanation. Then check why your choice was right or wrong. Repeat until the reasoning feels automatic.

Q: Can I practise just Functions, Tuples, Dictionaries and Exceptions questions in a focused session?

Yes — use the session launcher on this page to start a 10-, 20-, 30- or 50-question session drawn entirely from the Functions, Tuples, Dictionaries and Exceptions domain.

This domain covers defining and calling functions, positional and keyword arguments, tuple immutability and indexing, dictionary operations, and handling built-in exceptions with try/except. PCEP questions present short code snippets and ask you to predict output, identify the exact error raised, or select correct syntax from options.

Courseiva uses original exam-style practice questions designed for learning and revision. The goal is to understand the concepts, recognise exam patterns, and improve through explanations — not memorise copied exam dumps.

Editorial oversight:Johnson Ajibi· MSc IT Security, IEEE Senior Member

20 questionsDomain: Functions, Tuples, Dictionaries and Exceptions

Practice 10 questions Browse domain →

What the exam tests

What to know about Functions, Tuples, Dictionaries and Exceptions

Be able to read short Python snippets and state the exact result or exception. The key skill is knowing that tuples cannot be changed after creation and that argument order rules make foo(y=2, 3) a SyntaxError.

Defining functions with def, return values, and default or keyword parameters

Tuple creation, indexing, slicing, len(), and immutable element assignment

Dictionary creation, key access, methods like keys(), values(), and get()

Built-in exceptions such as TypeError, ValueError, KeyError, and IndexError

Watch out for

Common Functions, Tuples, Dictionaries and Exceptions exam traps

▸Assuming tuples support item assignment; modifying t[0] raises TypeError because tuples are immutable
▸Mixing positional and keyword arguments incorrectly, such as foo(y=2, 3), which raises SyntaxError
▸Confusing KeyError from a missing dictionary key with IndexError from an out-of-range sequence index

Practice set

Functions, Tuples, Dictionaries and Exceptions questions

20 questions · select your answer, then reveal the explanation

Question 1hardmultiple choice

Read the full Functions, Tuples, Dictionaries and Exceptions explanation →

A server logs are stored as a list of tuples: `logs = [('2024-01-10', 'INFO', 'Started'), ('2024-01-10', 'ERROR', 'Disk full')]`. A developer wants to count how many ERROR logs exist. Which code snippet correctly counts them?

Trap 1: count = logs.count(('ERROR',))

list.count compares whole elements, so it searches for a one-element tuple ('ERROR',), which never matches the three-element log tuples. It is tempting because count is the obvious counting method, but it would be correct only if each element were exactly that tuple.

Trap 2: count = [log for log in logs if log[1] == 'ERROR']

This list comprehension filters matching tuples but returns the tuples themselves, not a count; len() is missing. It is tempting because the condition log[1] == 'ERROR' correctly identifies error entries, but it would be correct once wrapped in len() to produce an integer.

Trap 3: count = len(logs)

len(logs) returns the total number of log entries, including INFO records, so it ignores the ERROR filter entirely. It is tempting because len() is the standard way to count list items, but it would be correct only if every entry in the list were an ERROR log.

Study all Functions, Tuples, Dictionaries and Exceptions common traps →

A
count = logs.count(('ERROR',))
Why it fails: list.count compares whole elements, so it searches for a one-element tuple ('ERROR',), which never matches the three-element log tuples. It is tempting because count is the obvious counting method, but it would be correct only if each element were exactly that tuple.
B
count = sum(log[1] == 'ERROR' for log in logs)
The generator expression yields a boolean per tuple, and sum() treats True as 1, counting entries whose index 1 equals 'ERROR'. This avoids manual counters and correctly handles the tuple structure, returning 1 for the sample logs.
C
count = [log for log in logs if log[1] == 'ERROR']
Why it fails: This list comprehension filters matching tuples but returns the tuples themselves, not a count; len() is missing. It is tempting because the condition log[1] == 'ERROR' correctly identifies error entries, but it would be correct once wrapped in len() to produce an integer.
D
count = len(logs)
Why it fails: len(logs) returns the total number of log entries, including INFO records, so it ignores the ERROR filter entirely. It is tempting because len() is the standard way to count list items, but it would be correct only if every entry in the list were an ERROR log.

Full breakdown with real-world context →

Question 2mediummultiple choice

Read the full Functions, Tuples, Dictionaries and Exceptions explanation →

A developer writes a function that returns multiple values as a tuple. Which of the following is a valid way to unpack the result into separate variables?

Trap 1: result = func(); a, b = result[0], result[1]

This works but is not unpacking.

Trap 2: a, b, c = func()

Unpacking mismatch if function returns only two values.

Trap 3: a = func()[0]; b = func()[1]

This calls the function twice.

Study all Functions, Tuples, Dictionaries and Exceptions common traps →

A
result = func(); a, b = result[0], result[1]
Why it fails: This works but is not unpacking.
B
a, b, c = func()
Why it fails: Unpacking mismatch if function returns only two values.
C
a = func()[0]; b = func()[1]
Why it fails: This calls the function twice.
D
a, b = func()
Tuple unpacking assigns each element of the returned tuple to the corresponding name on the left, so `a, b = func()` binds the first value to `a` and the second to `b` in a single statement. This satisfies the stem's requirement to unpack multiple return values into separate variables, provided the tuple length matches the target count.

Full breakdown with real-world context →

Question 3hardmultiple choice

Study the full Python automation breakdown →

A Python script processes a list of tuples representing coordinates: `points = [(1,2), (3,4), (5,6)]`. The developer wants to create a dictionary mapping each coordinate to its distance from origin. Which code correctly creates the dictionary?

Trap 1: distances = {}; for point in points: distances[point] =…

This option computes squared distance, not actual distance, so it is incorrect.

Trap 2: distances = {point: point[0]**2 + point[1]**2 for point in points}

This option computes squared distance, not actual distance, so it is incorrect.

Trap 3: distances = [(point, (point[0]**2 + point[1]**2)**0.5) for point in…

This produces a list of tuples, not a dictionary, so it is incorrect.

Study all Functions, Tuples, Dictionaries and Exceptions common traps →

A
distances = {}; for point in points: distances[point] = (point[0]**2 + point[1]**2)
Why it fails: This option computes squared distance, not actual distance, so it is incorrect.
B
distances = {}; for point in points: distances[point] = (point[0]**2 + point[1]**2)**0.5
Technically correct because it computes the Euclidean distance correctly using **0.5 and assigns it to a dictionary with a loop. However, the exam considers option C as the correct answer because it uses a dictionary comprehension, which is more idiomatic and succinct. Therefore, option B is not the intended correct answer.
C
distances = {point: (point[0]**2 + point[1]**2)**0.5 for point in points}
The dictionary comprehension iterates over each tuple in `points`, using the tuple itself as the key and computing its Euclidean distance from the origin via `(point[0]**2 + point[1]**2)**0.5`. This satisfies the requirement to map every coordinate to its distance, producing `{(1,2): 2.236..., (3,4): 5.0, (5,6): 7.810...}`.
D
distances = {point: point[0]**2 + point[1]**2 for point in points}
Why it fails: This option computes squared distance, not actual distance, so it is incorrect.
E
distances = [(point, (point[0]**2 + point[1]**2)**0.5) for point in points]
Why it fails: This produces a list of tuples, not a dictionary, so it is incorrect.

Full breakdown with real-world context →

Question 4mediummultiple choice

Read the full Functions, Tuples, Dictionaries and Exceptions explanation →

A script uses a dictionary to store counts of words. The code `counts['apple'] += 1` raises a KeyError the first time because the key doesn't exist. Which approach best solves this?

Trap 1: Use `try-except` to catch KeyError and then set the key.

Works but not the best practice.

Trap 2: Use `counts['apple'] = counts.get('apple') + 1`

get returns None if missing, causing TypeError.

Trap 3: Use `if 'apple' in counts:` before incrementing.

Does not handle the first occurrence.

Study all Functions, Tuples, Dictionaries and Exceptions common traps →

A
Use `counts.setdefault('apple', 0)` then increment.
`setdefault('apple', 0)` inserts the key with a default of 0 only when absent, then returns the existing value, so the subsequent increment never encounters a missing key. This directly satisfies the stem's KeyError constraint, though it requires two statements rather than one atomic operation.
B
Use `try-except` to catch KeyError and then set the key.
Why it fails: Works but not the best practice.
C
Use `counts['apple'] = counts.get('apple') + 1`
Why it fails: get returns None if missing, causing TypeError.
D
Use `if 'apple' in counts:` before incrementing.
Why it fails: Does not handle the first occurrence.

Full breakdown with real-world context →

Question 5hardmulti select

Study the full Python automation breakdown →

Which THREE of the following are valid ways to handle an exception in Python?

Trap 1: Using a `finally` block without a `try` block.

`finally` must be associated with a `try`.

Trap 2: Using a `try` block with an `else` block but no `except` block.

`else` requires an `except` block.

Study all Functions, Tuples, Dictionaries and Exceptions common traps →

A
Using a `try` block with both `except` and `finally` blocks.
Combining `except` with `finally` handles the raised exception while guaranteeing cleanup code runs regardless of outcome. The `except` clause catches and processes the error, satisfying the requirement to handle it, while `finally` executes unconditionally for resource release.
B
Using a `finally` block without a `try` block.
Why it fails: `finally` must be associated with a `try`.
C
Using a `try` block with an `else` block but no `except` block.
Why it fails: `else` requires an `except` block.
D
Using a `try` block with a `finally` block.
A `try` block paired solely with `finally` runs the cleanup suite whether or not an exception occurs, but it does not catch or suppress the exception itself. The error still propagates after `finally` completes, so this remains a valid handling construct.
E
Using a `try` block with one or more `except` blocks.
A try block encloses code that may raise, and one or more except clauses catch matching exception types, allowing graceful recovery rather than program termination. This is the primary structured mechanism Python provides for handling runtime errors.

Full breakdown with real-world context →

Question 6easymulti select

Read the full Functions, Tuples, Dictionaries and Exceptions explanation →

Which THREE of the following dictionary methods return a view object that changes when the dictionary changes?

Trap 1: `dict.get()`

dict.get() returns the value for a key, not a view object. Incorrect.

Trap 2: `dict.copy()`

dict.copy() returns a shallow copy of the dictionary, not a view. Incorrect.

Study all Functions, Tuples, Dictionaries and Exceptions common traps →

A
`dict.keys()`
dict.keys() returns a view object that dynamically reflects changes to the dictionary. Correct.
B
`dict.get()`
Why it fails: dict.get() returns the value for a key, not a view object. Incorrect.
C
`dict.values()`
dict.values() returns a view object that dynamically reflects changes. Correct.
D
`dict.copy()`
Why it fails: dict.copy() returns a shallow copy of the dictionary, not a view. Incorrect.
E
`dict.items()`
dict.items() returns a view object of key-value pairs that dynamically reflects changes. Correct.

Full breakdown with real-world context →

Question 7mediummultiple choice

Read the full Functions, Tuples, Dictionaries and Exceptions explanation →

What is the output of the code?

Exhibit

Refer to the exhibit.

def divide(a, b):
    try:
        return a / b
    except ZeroDivisionError:
        return float('inf')
    except TypeError:
        return None

result = divide(10, '5')
print(result)

Trap 1: None

Incorrect. The function does not return None because an unhandled exception is raised before the function completes.

Trap 2: inf

Incorrect. Python does not return inf for division by zero; it raises ZeroDivisionError.

Trap 3: 2.0

Incorrect. 2.0 is not the result because the division by zero raises an exception.

Study all Functions, Tuples, Dictionaries and Exceptions common traps →

A
None
Why it fails: Incorrect. The function does not return None because an unhandled exception is raised before the function completes.
B
inf
Why it fails: Incorrect. Python does not return inf for division by zero; it raises ZeroDivisionError.
C
2.0
Why it fails: Incorrect. 2.0 is not the result because the division by zero raises an exception.
D
An unhandled ZeroDivisionError is raised.
Dividing by zero raises Python's built-in `ZeroDivisionError`, and because the code contains no `try`/`except` block to intercept it, the interpreter halts execution and propagates the exception to the caller, producing an unhandled traceback rather than any printed value.

Full breakdown with real-world context →

Question 8hardmultiple choice

Read the full Functions, Tuples, Dictionaries and Exceptions explanation →

What is the output of this code?

Exhibit

Refer to the exhibit.

data = {'a': 1, 'b': 2, 'c': 3}
for key, value in data.items():
    if value % 2 == 0:
        data.pop(key)
print(data)

Trap 1: {}

Not the output.

Trap 2: {'b': 2}

Not the output.

Trap 3: {'a': 1, 'c': 3}

Modification during iteration raises error.

Study all Functions, Tuples, Dictionaries and Exceptions common traps →

A
RuntimeError: dictionary changed size during iteration
Mutating a dictionary while iterating it raises RuntimeError, because CPython tracks the dict's version tag and aborts when the size changes mid-loop. The stem's code adds or removes keys inside a `for` loop, so iteration detects the altered size and halts immediately rather than silently skipping entries.
B
{}
Why it fails: Not the output.
C
{'b': 2}
Why it fails: Not the output.
D
{'a': 1, 'c': 3}
Why it fails: Modification during iteration raises error.

Full breakdown with real-world context →

Question 9hardmultiple choice

Read the full Functions, Tuples, Dictionaries and Exceptions explanation →

You are a developer for a financial application that processes transactions. The application uses a dictionary to store account balances where keys are account numbers (strings) and values are floats. A function `transfer(from_acc, to_acc, amount)` is supposed to subtract amount from `from_acc` and add it to `to_acc`. However, some transfers are resulting in incorrect balances: the `from_acc` balance is reduced but the `to_acc` balance is not increased. The code uses `try-except` to catch KeyError if an account does not exist. Upon inspection, the function first checks if both accounts exist, then performs subtraction, then addition, and finally returns success. No exceptions are raised during the problematic transfers. The accounts definitely exist. What is the most likely cause?

Trap 1: The function catches KeyError and silently returns without…

No KeyError is raised.

Trap 2: The function does not check if the from_acc has sufficient balance…

Insufficient balance would cause negative balance but not missing addition.

Trap 3: The balances are stored as strings instead of floats, causing…

If strings, concatenation would increase both balances, not cause missing addition.

Study all Functions, Tuples, Dictionaries and Exceptions common traps →

A
The dictionary is being modified concurrently by multiple threads or processes without synchronization, leading to race conditions.
The subtraction-then-addition sequence is not atomic, so interleaved threads can read and write the same balance entries concurrently. Without a lock, one thread's addition can be overwritten by another's stale read, leaving the destination balance unchanged while the source debit persists.
B
The function catches KeyError and silently returns without completing the transfer.
Why it fails: No KeyError is raised.
C
The function does not check if the from_acc has sufficient balance before subtracting.
Why it fails: Insufficient balance would cause negative balance but not missing addition.
D
The balances are stored as strings instead of floats, causing concatenation instead of arithmetic.
Why it fails: If strings, concatenation would increase both balances, not cause missing addition.

Full breakdown with real-world context →

Question 10mediummultiple choice

Read the full Functions, Tuples, Dictionaries and Exceptions explanation →

A team is building a configuration parser that reads a file containing key=value pairs. They use a dictionary to store the configuration. The parser function `load_config(filename)` opens the file, reads line by line, splits on '=', and populates a dictionary. Some lines have comments starting with '#'. The developer wants to ensure that the dictionary is not polluted with comment lines. They write: `if line.startswith('#'): continue`. However, after parsing, the dictionary contains an entry with key '#' because some lines have no '=' sign. For example, a line like `#comment` is being added as a key with value None. The developer wants to fix this. Which modification should be made?

Trap 1: Use `key, value = line.split('=', 1)` and catch ValueError if less…

Unpacking would raise ValueError if no '=', but catching it would skip the line. Actually this could work, but not the best because it relies on exception handling for control flow.

Trap 2: Strip the line of whitespace before checking for comments.

Stripping does not prevent lines without '='.

Trap 3: Replace `startswith('#')` with `line.lstrip().startswith('#')` and…

Does not handle lines without '='.

Study all Functions, Tuples, Dictionaries and Exceptions common traps →

A
Use `key, value = line.split('=', 1)` and catch ValueError if less than two parts.
Why it fails: Unpacking would raise ValueError if no '=', but catching it would skip the line. Actually this could work, but not the best because it relies on exception handling for control flow.
B
Strip the line of whitespace before checking for comments.
Why it fails: Stripping does not prevent lines without '='.
C
Check `if '=' not in line: continue` before splitting.
Lines lacking '=' cannot form key=value pairs, so skipping them before splitting prevents malformed entries such as '#' with value None. This directly satisfies the requirement that comment and non-pair lines never pollute the configuration dictionary.
D
Replace `startswith('#')` with `line.lstrip().startswith('#')` and also skip empty lines.
Why it fails: Does not handle lines without '='.

Full breakdown with real-world context →

Question 11mediummatching

Study the full Python automation breakdown →

Match each Python function to its description.

Drag a concept onto its matching description — or click a concept then click the description.

Concepts

Matches

Outputs objects to the console

Reads a string from standard input

Returns the number of items in a container

Returns the type of an object

Converts a value to an integer

Trap 1: str: Returns the length of a string

Incorrect — the length of a string is returned by len(), not str(). str() converts an object to a string.

Trap 2: input: Outputs data to the console

Incorrect — input() reads a line from user input; it does not output data (print() does).

Study all Functions, Tuples, Dictionaries and Exceptions common traps →

A
len: Returns the number of items in an object
The len() function returns the length (number of items) of an object like a list, string, etc.
B
print: Outputs data to the standard output
The print() function writes data to the console.
C
int: Converts a value to an integer
The int() function converts a number or string to an integer type.
D
str: Returns the length of a string
Why it fails: Incorrect — the length of a string is returned by len(), not str(). str() converts an object to a string.
E
input: Outputs data to the console
Why it fails: Incorrect — input() reads a line from user input; it does not output data (print() does).

Full breakdown with real-world context →

Question 12mediummatching

Study the full Python automation breakdown →

Match each Python string method to its action.

Drag a concept onto its matching description — or click a concept then click the description.

Concepts

Matches

Converts all characters to uppercase

Converts all characters to lowercase

Removes leading and trailing whitespace

Splits a string into a list of substrings

Joins elements of an iterable into a single string

Trap 1: .upper(): Splits the string into a list of substrings

Incorrect — .upper() converts to uppercase, not splits. The split action belongs to .split().

Trap 2: .strip(): Returns a copy of the string converted to uppercase

Incorrect — .strip() removes whitespace, not converts case. The uppercase action belongs to .upper().

Study all Functions, Tuples, Dictionaries and Exceptions common traps →

A
.upper(): Returns a copy of the string converted to uppercase
.upper() converts all lowercase letters in the string to uppercase.
B
.lower(): Returns a copy of the string converted to lowercase
.lower() converts all uppercase letters in the string to lowercase.
C
.strip(): Returns a copy of the string with leading and trailing whitespace removed
.strip() removes whitespace characters from the beginning and end of the string.
D
.split(): Splits the string into a list of substrings based on a delimiter
.split() divides the string at the specified delimiter and returns a list of parts.
E
.upper(): Splits the string into a list of substrings
Why it fails: Incorrect — .upper() converts to uppercase, not splits. The split action belongs to .split().
F
.strip(): Returns a copy of the string converted to uppercase
Why it fails: Incorrect — .strip() removes whitespace, not converts case. The uppercase action belongs to .upper().

Full breakdown with real-world context →

Question 13easymultiple choice

Read the full Functions, Tuples, Dictionaries and Exceptions explanation →

A developer writes a function that should return the sum of two numbers, but the code returns 0 instead. What is the most likely cause?

def add(a, b):

result = a + b

print(add(3, 4))

Trap 1: The function is not defined before the call.

The function is defined before the print statement.

Trap 2: The variable 'result' is not defined.

The variable is defined and assigned inside the function.

Trap 3: The function parameters are of incompatible types.

Both parameters are integers, no type conflict.

Study all Functions, Tuples, Dictionaries and Exceptions common traps →

A
The function is not defined before the call.
Why it fails: The function is defined before the print statement.
B
The variable 'result' is not defined.
Why it fails: The variable is defined and assigned inside the function.
C
The function parameters are of incompatible types.
Why it fails: Both parameters are integers, no type conflict.
D
The function does not have a return statement.
The function computes the sum but does not return it, returning None instead.

Full breakdown with real-world context →

Question 14hardmultiple choice

Read the full Functions, Tuples, Dictionaries and Exceptions explanation →

Based on the exhibit, where did the exception originate?

Exhibit

Refer to the exhibit.

Error log output:
Traceback (most recent call last):
  File "app.py", line 10, in <module>
    result = divide(10, 0)
  File "app.py", line 5, in divide
    return a / b
ZeroDivisionError: division by zero

Trap 1: In the main module outside any function.

Module-level code executes before any function call, so an exception raised there would terminate the program immediately with no function frames on the traceback. The exhibit shows a call stack, meaning the error arose inside a called function, not in the main module body.

Trap 2: In the ZeroDivisionError exception handler.

An exception handler runs only after an exception has already propagated, so it cannot be the point of origin. The ZeroDivisionError was raised by the division operation itself; the handler merely catches it, and the traceback's final frame identifies the raising line.

Trap 3: At line 10 in app.py, where the function was called.

The traceback reports the line where the exception was raised, not the call site that invoked the function. Line 10 merely transferred control; the ZeroDivisionError originated inside the function body where the division executed, so the call site is not the origin.

Study all Functions, Tuples, Dictionaries and Exceptions common traps →

A
At line 5 in the divide function inside app.py.
The traceback's deepest frame points to the divide function at line 5 of app.py, where the failing operation was raised. That frame is the origin of the exception, satisfying the exhibit's requirement to identify where it was thrown.
B
In the main module outside any function.
Why it fails: Module-level code executes before any function call, so an exception raised there would terminate the program immediately with no function frames on the traceback. The exhibit shows a call stack, meaning the error arose inside a called function, not in the main module body.
C
In the ZeroDivisionError exception handler.
Why it fails: An exception handler runs only after an exception has already propagated, so it cannot be the point of origin. The ZeroDivisionError was raised by the division operation itself; the handler merely catches it, and the traceback's final frame identifies the raising line.
D
At line 10 in app.py, where the function was called.
Why it fails: The traceback reports the line where the exception was raised, not the call site that invoked the function. Line 10 merely transferred control; the ZeroDivisionError originated inside the function body where the division executed, so the call site is not the origin.

Full breakdown with real-world context →

Question 15mediummultiple choice

Read the full Functions, Tuples, Dictionaries and Exceptions explanation →

What is the output of the code in the exhibit?

Exhibit

Refer to the exhibit.

def process(data):
    return {item: len(item) for item in data}

print(process(['apple', 'banana', 'cherry']))

Trap 1: {5:'apple', 6:'banana', 6:'cherry'}

Swapped keys and values.

Trap 2: {'apple':5, 'banana':7, 'cherry':6}

Banana length is 6, not 7.

Trap 3: {0:'apple', 1:'banana', 2:'cherry'}

Uses index instead of length.

Study all Functions, Tuples, Dictionaries and Exceptions common traps →

A
{5:'apple', 6:'banana', 6:'cherry'}
Why it fails: Swapped keys and values.
B
{'apple':5, 'banana':7, 'cherry':6}
Why it fails: Banana length is 6, not 7.
C
{0:'apple', 1:'banana', 2:'cherry'}
Why it fails: Uses index instead of length.
D
{'apple':5, 'banana':6, 'cherry':6}
Correct mapping of items to their lengths.

Full breakdown with real-world context →

Question 16easymultiple choice

Read the full Functions, Tuples, Dictionaries and Exceptions explanation →

What is the output of the code?

Exhibit

Refer to the exhibit.

config = {
    'host': 'localhost',
    'port': 8080,
    'timeout': 30
}

try:
    value = config['debug']
except KeyError:
    print('Key not found')

Trap 1: AttributeError

AttributeError is not raised because the code uses the get() method, which does not raise an exception for missing keys.

Trap 2: The program exits with no output

The program does produce output because get() returns a default value.

Trap 3: None

The default value is not None because the get() call specifies 'Key not found' as the default.

Study all Functions, Tuples, Dictionaries and Exceptions common traps →

A
AttributeError
Why it fails: AttributeError is not raised because the code uses the get() method, which does not raise an exception for missing keys.
B
The program exits with no output
Why it fails: The program does produce output because get() returns a default value.
C
None
Why it fails: The default value is not None because the get() call specifies 'Key not found' as the default.
D
Key not found
The get() method returns the default value 'Key not found' when the key is absent, so this is printed.

Full breakdown with real-world context →

Question 17easymultiple choice

Read the full Functions, Tuples, Dictionaries and Exceptions explanation →

Refer to the exhibit. What exception is raised when this code is executed?

Exhibit

def divide(a, b):
    return a / b

result = divide(10, 0)

Trap 1: ValueError

ValueError is for inappropriate argument value, not for division by zero.

Trap 2: ArithmeticError

ArithmeticError is the base class; the actual exception is ZeroDivisionError.

Trap 3: TypeError

TypeError is for operation on inappropriate type, not for division by zero.

Study all Functions, Tuples, Dictionaries and Exceptions common traps →

A
ValueError
Why it fails: ValueError is for inappropriate argument value, not for division by zero.
B
ZeroDivisionError
Correct: Division by zero raises ZeroDivisionError.
C
ArithmeticError
Why it fails: ArithmeticError is the base class; the actual exception is ZeroDivisionError.
D
TypeError
Why it fails: TypeError is for operation on inappropriate type, not for division by zero.

Full breakdown with real-world context →

Question 18hardmultiple choice

Read the full Functions, Tuples, Dictionaries and Exceptions explanation →

Refer to the exhibit. What happens when this code is executed?

Exhibit

d = {'a':1, 'b':2}
for k, v in d.items():
    if k == 'a':
        del d[k]
print('done')

Trap 1: Prints 'done' with no error

Deleting an item during iteration raises RuntimeError.

Trap 2: KeyError: 'a'

KeyError would occur if accessing a missing key, but here we are deleting an existing key.

Trap 3: Nothing; the code runs silently

The code raises an exception.

Study all Functions, Tuples, Dictionaries and Exceptions common traps →

A
Prints 'done' with no error
Why it fails: Deleting an item during iteration raises RuntimeError.
B
RuntimeError: dictionary changed size during iteration
Correct: The dictionary size changed during iteration.
C
KeyError: 'a'
Why it fails: KeyError would occur if accessing a missing key, but here we are deleting an existing key.
D
Nothing; the code runs silently
Why it fails: The code raises an exception.

Full breakdown with real-world context →

Question 19mediummultiple choice

Read the full Functions, Tuples, Dictionaries and Exceptions explanation →

A function returns a tuple. Which code correctly unpacks the tuple?

def min_max(numbers):
    return min(numbers), max(numbers)

result = min_max([3, 1, 2])

Trap 1: a = result[0]; b = result[1]

Incorrect: This accesses elements by index, not tuple unpacking.

Trap 2: a = result[1]; b = result[0]

Incorrect: This accesses elements by index and swaps the order.

Study all Functions, Tuples, Dictionaries and Exceptions common traps →

A
a = result[0]; b = result[1]
Why it fails: Incorrect: This accesses elements by index, not tuple unpacking.
B
(a, b) = result
Correct: Parenthesized target list unpacks the tuple into a and b.
C
a, b = result
Correct: Bare target list unpacks the tuple — the most concise form.
D
a = result[1]; b = result[0]
Why it fails: Incorrect: This accesses elements by index and swaps the order.

Full breakdown with real-world context →

Question 20mediummultiple choice

Read the full Functions, Tuples, Dictionaries and Exceptions explanation →

Which code sorts a list of strings by their length in descending order?

lst = ['aa', 'b', 'ccc']

Trap 1: sorted(lst, reverse=True)

Incorrect: Sorts alphabetically in reverse order, not by length.

Trap 2: sorted(lst, key=lambda s: len(s), reverse=True)

Incorrect in this context: While it produces the same result as A, using a lambda for `len` is redundant; the simplest correct answer is A.

Trap 3: sorted(lst, key=lambda s: len(s))

Incorrect: Sorts by length in ascending order because `reverse` defaults to False.

Study all Functions, Tuples, Dictionaries and Exceptions common traps →

A
sorted(lst, key=len, reverse=True)
Correct: Uses `key=len` to sort by length and `reverse=True` for descending order.
B
sorted(lst, reverse=True)
Why it fails: Incorrect: Sorts alphabetically in reverse order, not by length.
C
sorted(lst, key=lambda s: len(s), reverse=True)
Why it fails: Incorrect in this context: While it produces the same result as A, using a lambda for `len` is redundant; the simplest correct answer is A.
D
sorted(lst, key=lambda s: len(s))
Why it fails: Incorrect: Sorts by length in ascending order because `reverse` defaults to False.

Full breakdown with real-world context →

Continue with 20-question session →

Free account

Track your progress over time

Create a free account to save your results and see which topics improve across sessions.

Focused Functions, Tuples, Dictionaries and Exceptions sessions

Start a Functions, Tuples, Dictionaries and Exceptions only practice session

Every question in these sessions is drawn from the Functions, Tuples, Dictionaries and Exceptions domain — nothing else.

10 questions 20 questions 30 questions 50 questions

Browse all Functions, Tuples, Dictionaries and Exceptions questions →Mixed PCEP session

Frequently asked questions

What does the PCEP exam test about Functions, Tuples, Dictionaries and Exceptions?: Be able to read short Python snippets and state the exact result or exception. The key skill is knowing that tuples cannot be changed after creation and that argument order rules make foo(y=2, 3) a SyntaxError.
How should I use these practice questions?: Select your answer before revealing the explanation. Then read why each option is right or wrong — this active recall approach builds retention far faster than re-reading notes.
Can I practise just Functions, Tuples, Dictionaries and Exceptions questions in a focused session?: Yes — the session launcher on this page draws every question from the Functions, Tuples, Dictionaries and Exceptions domain. Use a 10-question session first to gauge your baseline, then move to 20 or 30 once the weak spots are clear.
Where can I practise other PCEP topics?: Use the topic links above to move to related areas, or go back to the PCEP question bank to see all topics.
Are these real exam questions or dumps?: These are original practice questions written to test the same concepts the PCEP exam covers. They are not copied from any real exam or dump site.

Functions, Tuples, Dictionaries and Exceptions only

10 questions 20 questions 30 questions 50 questions

Mixed PCEP session

Track your progress

A free account saves results across sessions and highlights which topics need work.

Study resources

All PCEP questions Functions, Tuples, Dictionaries and Exceptions domain overview PCEP exam guide

Exam traps to avoid

▸Assuming tuples support item assignment; modifying t[0] raises TypeError because tuples are immutable
▸Mixing positional and keyword arguments incorrectly, such as foo(y=2, 3), which raises SyntaxError
▸Confusing KeyError from a missing dictionary key with IndexError from an out-of-range sequence index

Functions, Tuples, Dictionaries and Exceptions practice questions

What to know about Functions, Tuples, Dictionaries and Exceptions

Common Functions, Tuples, Dictionaries and Exceptions exam traps

Functions, Tuples, Dictionaries and Exceptions questions

A server logs are stored as a list of tuples: `logs = [('2024-01-10', 'INFO', 'Started'), ('2024-01-10', 'ERROR', 'Disk full')]`. A developer wants to count how many ERROR logs exist. Which code snippet correctly counts them?

A developer writes a function that returns multiple values as a tuple. Which of the following is a valid way to unpack the result into separate variables?

A Python script processes a list of tuples representing coordinates: `points = [(1,2), (3,4), (5,6)]`. The developer wants to create a dictionary mapping each coordinate to its distance from origin. Which code correctly creates the dictionary?

A script uses a dictionary to store counts of words. The code `counts['apple'] += 1` raises a KeyError the first time because the key doesn't exist. Which approach best solves this?

Which THREE of the following are valid ways to handle an exception in Python?

Which THREE of the following dictionary methods return a view object that changes when the dictionary changes?

What is the output of the code?

Exhibit

What is the output of this code?

Exhibit

Match each Python function to its description.

Match each Python string method to its action.

Based on the exhibit, where did the exception originate?

Exhibit

What is the output of the code in the exhibit?

Exhibit

What is the output of the code?

Exhibit

Refer to the exhibit. What exception is raised when this code is executed?

Exhibit

Refer to the exhibit. What happens when this code is executed?

Exhibit

Track your progress over time

Start a Functions, Tuples, Dictionaries and Exceptions only practice session

Related PCEP topic practice pages

Control Flow, Loops, Lists and Logic practice questions

Computer Programming and Python Fundamentals practice questions

Data Types, Variables, Basic I/O and Operators practice questions