Building Blocks

Building Blocks Quiz

Quiz

Question 1 of 66 (0 answered)

Question 1

Dictionary keys can hold any Python object, including lists and other dictionaries.

True False

✓

Correct!

Dictionary keys must be hashable (immutable). Lists and dicts are mutable and therefore unhashable — using one as a key raises TypeError. Values, on the other hand, can be any Python object, including lists and nested dicts.

✗

Incorrect

Can you use a list as a dictionary key? Try it.

Question 2

Predict the output:

s = "Python"
print(s[::2])

What will this code output?

"Pto" "Pth" "yhn" "Pto" with quotes

✓

Correct!

The slice [::2] starts at index 0, goes to the end, with step 2 (every 2nd character). This gives: P(0), t(2), o(4) = “Pto”.

✗

Incorrect

The slice [::2] starts at index 0, goes to the end, with step 2 (every 2nd character). This gives: P(0), t(2), o(4) = “Pto”.

The syntax is [start:stop:step]. What does step=2 mean?

Question 3

Which of the following operations have O(1) average time complexity?

Accessing a list element by index: list[i] Checking membership in a list: x in list Appending to a list: list.append(x) Dictionary key lookup: dict[key] Set membership test: x in set Removing the first element: list.pop(0)

✓

Correct!

O(1) operations: list indexing, list.append(), dict access, and set membership. List membership (x in list) is O(n) because it requires linear search. list.pop(0) is also O(n) — removing from the front shifts every remaining element.

✗

Incorrect

Which operations require searching through or shifting all elements?

Question 4

What string method converts ‘hello world’ to ‘Hello World’ (capitalizing each word)?

✓

Correct!

The .title() method capitalizes the first letter of each word. .capitalize() only capitalizes the first letter of the entire string.

✗

Incorrect

The .title() method capitalizes the first letter of each word. .capitalize() only capitalizes the first letter of the entire string.

It’s a method that treats each word like a book title.

Question 5

Complete the code to join a list of words with commas:

Fill in the missing method

words = ['apple', 'banana', 'cherry']
result = ', '._____(words)

Your answer:

✓

Correct!

The join() method is called on the separator string and takes an iterable as argument: separator.join(iterable). This produces ‘apple, banana, cherry’.

✗

Incorrect

The join() method is called on the separator string and takes an iterable as argument: separator.join(iterable). This produces ‘apple, banana, cherry’.

Question 6

Strings in Python are mutable, meaning you can change individual characters after creation.

True False

✓

Correct!

Strings are immutable in Python. Once created, you cannot modify them in place. Operations like .replace() or .upper() return new strings.

✗

Incorrect

Strings are immutable in Python. Once created, you cannot modify them in place. Operations like .replace() or .upper() return new strings.

Try running: s = ‘hello’; s[0] = ‘H’

Question 7

What is the result of "Ha" * 3?

“HaHaHa” “Ha3” “Ha Ha Ha” TypeError

✓

Correct!

The * operator with strings performs repetition, concatenating the string with itself n times. “Ha” * 3 = “HaHaHa”. No spaces are inserted between copies.

✗

Incorrect

The * operator with strings performs repetition, concatenating the string with itself n times. “Ha” * 3 = “HaHaHa”. No spaces are inserted between copies.

String repetition is a built-in operation in Python.

Question 8

What does this code print?

numbers = [1, 2, 3]
numbers.append(4)
numbers.extend([5, 6])
print(len(numbers))

What will this code output?

3 4 5 6

✓

Correct!

Start with [1, 2, 3] (length 3). append(4) adds one element → [1, 2, 3, 4] (length 4). extend([5, 6]) adds two elements → [1, 2, 3, 4, 5, 6] (length 6).

✗

Incorrect

Start with [1, 2, 3] (length 3). append(4) adds one element → [1, 2, 3, 4] (length 4). extend([5, 6]) adds two elements → [1, 2, 3, 4, 5, 6] (length 6).

append() adds one item, extend() adds multiple items.

Question 9

What is the key difference between .remove() and .pop() for lists?

.remove(value) removes the first occurrence of a value and raises ValueError if not found.

.pop(index) removes and returns the element at an index (default: last item) and raises IndexError if index is out of range.

Key differences:

remove() searches by value, pop() removes by position
pop() returns the removed item, remove() returns None
Different error types when operation fails

Did you get it right?

✓

Correct!

✗

Incorrect

Question 10

Which statements about list comprehensions are true?

List comprehensions are generally faster than equivalent for loops You can include an if condition to filter elements You can nest multiple comprehensions List comprehensions can only iterate over lists List comprehensions always create new lists in memory List comprehensions evaluate lazily and don’t create a list until needed

✓

Correct!

Options 1, 2, 3, and 5 are true. Option 4 is false: list comprehensions work with any iterable. Option 6 is also false: list comprehensions eagerly create a new list immediately — if you want lazy evaluation, use a generator expression (x for x in ...) instead.

✗

Incorrect

Think about what ‘comprehension’ means and what iterables are.

Question 11

What is the output?

matrix = [[j for j in range(2)] for i in range(2)]
print(matrix[1][0])

What will this code output?

0 1 2 [0, 1]

✓

Correct!

The comprehension creates [[0, 1], [0, 1]]. matrix[1] accesses the second sublist [0, 1], then [0] gets the first element = 0.

✗

Incorrect

The comprehension creates [[0, 1], [0, 1]]. matrix[1] accesses the second sublist [0, 1], then [0] gets the first element = 0.

Build the matrix step by step, then access [row][column].

Question 12

The .sort() method returns a new sorted list without modifying the original.

True False

✓

Correct!

.sort() sorts the list in-place and returns None. To get a new sorted list without modifying the original, use the sorted() function instead.

✗

Incorrect

.sort() sorts the list in-place and returns None. To get a new sorted list without modifying the original, use the sorted() function instead.

What does ‘in-place’ mean?

Question 13

Why must you use (1,) instead of (1) to create a single-element tuple?

Python syntax requires it for all tuples Without the comma, (1) is just the integer 1 in parentheses The comma makes it immutable To distinguish it from a list

✓

Correct!

Parentheses don’t create tuples — the comma does. Parentheses are just grouping syntax, not tuple syntax. (1) is just integer 1 with parentheses (grouping). (1,) uses the comma to signal a tuple. This is necessary because parentheses are used for grouping in Python.

✗

Incorrect

What makes a tuple a tuple—the parentheses or the comma?

Question 14

What method would you use to find the first index of value 3 in a tuple t = (1, 2, 3, 2, 4)?

✓

Correct!

The .index(value) method returns the index of the first occurrence of a value. For t = (1, 2, 3, 2, 4), t.index(3) returns 2.

✗

Incorrect

The .index(value) method returns the index of the first occurrence of a value. For t = (1, 2, 3, 2, 4), t.index(3) returns 2.

This method exists for both tuples and lists.

Question 15

Why can tuples be used as dictionary keys but lists cannot?

Dictionary keys must be hashable (immutable).

Tuples are immutable → can be hashed → valid as keys

Lists are mutable → cannot be hashed → TypeError if used as keys

Example:

# Valid
locations = {(0, 0): "Origin", (1, 2): "Point A"}

# Invalid - TypeError
# bad_dict = {[0, 0]: "Origin"}

Hashability ensures the key’s hash value never changes, which is critical for dictionary lookup performance.

Did you get it right?

✓

Correct!

✗

Incorrect

Question 16

Complete the tuple unpacking to extract the first element and the rest:

Fill in the unpacking syntax

numbers = (1, 2, 3, 4)
first, _____ = numbers
# first = 1, rest = [2, 3, 4]

Your answer:

✓

Correct!

The * operator in unpacking captures remaining elements into a list. first, *rest = (1, 2, 3, 4) assigns 1 to first and [2, 3, 4] to rest.

✗

Incorrect

The * operator in unpacking captures remaining elements into a list. first, *rest = (1, 2, 3, 4) assigns 1 to first and [2, 3, 4] to rest.

Question 17

What does user.get('email', 'N/A') return if the key ’email’ doesn’t exist?

None KeyError “N/A” The key ’email’ is inserted into the dict with value ‘N/A’

✓

Correct!

The .get(key, default) method returns the default value (‘N/A’) if the key doesn’t exist — and does not modify the dictionary. Without a default, it returns None. It never raises KeyError. To also insert the default, use .setdefault() instead.

✗

Incorrect

The second argument to .get() is the default value.

Question 18

What is printed?

counts = {}
counts.setdefault('apple', 0)
counts['apple'] += 1
print(counts['apple'])

What will this code output?

0 1 KeyError None

✓

Correct!

setdefault('apple', 0) sets counts[‘apple’] = 0 (key doesn’t exist yet). Then counts['apple'] += 1 increments it to 1.

✗

Incorrect

setdefault('apple', 0) sets counts[‘apple’] = 0 (key doesn’t exist yet). Then counts['apple'] += 1 increments it to 1.

setdefault() inserts the key with default value if missing, then returns the value.

Question 19

Which operations modify a dictionary in place?

dict[key] = value dict.get(key, default) del dict[key] dict.keys() dict.update(other_dict)

✓

Correct!

In-place modifications: assigning dict[key] = value, deleting with del, and merging with .update(). .get() and .keys() only read data without modification.

✗

Incorrect

In-place modifications: assigning dict[key] = value, deleting with del, and merging with .update(). .get() and .keys() only read data without modification.

Which operations change the dictionary vs just reading from it?

Question 20

Arrange the dictionary methods in order from ‘safest’ (won’t raise errors) to ‘most likely to raise errors’:

Drag to arrange from safest to most error-prone

⋮⋮ dict[key]

⋮⋮ dict.get(key)

⋮⋮ dict.get(key, default)

✓

Correct!

.get(key, default) never raises errors (returns default). .get(key) returns None if missing (no error). dict[key] raises KeyError if missing.

✗

Incorrect

.get(key, default) never raises errors (returns default). .get(key) returns None if missing (no error). dict[key] raises KeyError if missing.

Question 21

Complete the dictionary comprehension to create {1: ‘a’, 2: ‘b’}:

Fill in the comprehension

original = {'a': 1, 'b': 2}
reversed_dict = {_____ for k, v in original.items()}

Your answer:

✓

Correct!

Dictionary comprehension syntax is {key_expr: value_expr for ...}. To reverse keys and values, use {v: k for k, v in original.items()}.

✗

Incorrect

Dictionary comprehension syntax is {key_expr: value_expr for ...}. To reverse keys and values, use {v: k for k, v in original.items()}.

Question 22

What’s the difference between dict.keys(), dict.values(), and dict.items()?

.keys() → Returns view of all keys

Example: dict_keys(['name', 'age'])

.values() → Returns view of all values

Example: dict_values(['Alice', 30])

.items() → Returns view of (key, value) pairs as tuples

Example: dict_items([('name', 'Alice'), ('age', 30)])

All return dictionary views (not lists) that reflect changes to the original dictionary. Use list() to convert if needed.

Did you get it right?

✓

Correct!

✗

Incorrect

Question 23

In Python 3.7+, dictionaries maintain insertion order.

True False

✓

Correct!

Since Python 3.7, dictionaries are ordered and maintain the order in which keys were inserted. This is now part of the language specification.

✗

Incorrect

Since Python 3.7, dictionaries are ordered and maintain the order in which keys were inserted. This is now part of the language specification.

Check the data structure comparison table in the notes.

Question 24

What happens when you try to add a duplicate element to a set?

It raises a ValueError It raises a TypeError because sets only accept hashable elements Nothing—the set ignores duplicates silently It overwrites the existing element

✓

Correct!

Sets automatically enforce uniqueness. Adding a duplicate element is simply ignored—no error, no change. The set remains unchanged. (TypeError is what you get for adding an unhashable element like a list, not a duplicate.)

✗

Incorrect

Sets are defined as collections of unique elements.

Question 25

What is the result?

a = {1, 2, 3, 4}
b = {3, 4, 5, 6}
print(a - b)

What will this code output?

{1, 2} {5, 6} {1, 2, 5, 6} {3, 4}

✓

Correct!

The - operator (or .difference()) returns elements in a that are NOT in b. Elements 1 and 2 are only in a, so the result is {1, 2}.

✗

Incorrect

The - operator (or .difference()) returns elements in a that are NOT in b. Elements 1 and 2 are only in a, so the result is {1, 2}.

Difference means ‘in a but not in b’.

Question 26

Which set operations return a new set (rather than modifying in place)?

a | b (union) a.add(x) a & b (intersection) a.remove(x) a ^ b (symmetric difference)

✓

Correct!

Operators |, &, and ^ return new sets. Methods .add() and .remove() modify the set in place and return None.

✗

Incorrect

Operators |, &, and ^ return new sets. Methods .add() and .remove() modify the set in place and return None.

Operators typically return new objects; methods often modify in place.

Question 27

What set method removes an element without raising an error if it doesn’t exist?

✓

Correct!

.discard(x) removes element x if present, but does nothing (no error) if x doesn’t exist. .remove(x) raises KeyError if x is not in the set.

✗

Incorrect

.discard(x) removes element x if present, but does nothing (no error) if x doesn’t exist. .remove(x) raises KeyError if x is not in the set.

Think about ‘safe removal’ that won’t crash your program.

Question 28

What’s the difference between a | b and a & b for sets?

a | b (Union) → All unique elements from both sets

Example: {1, 2} | {2, 3} = {1, 2, 3}
Can also use a.union(b)

a & b (Intersection) → Only elements present in BOTH sets

Example: {1, 2} & {2, 3} = {2}
Can also use a.intersection(b)

Think: Union = everything, Intersection = common elements

Did you get it right?

✓

Correct!

✗

Incorrect

Question 29

What does this print?

items = [1, 2, 2, 3, 3, 3, 4]
print(len(set(items)))

What will this code output?

7 4 3 1

✓

Correct!

Converting to a set removes duplicates: set([1, 2, 2, 3, 3, 3, 4]) = {1, 2, 3, 4}. The length is 4 unique elements.

✗

Incorrect

Converting to a set removes duplicates: set([1, 2, 2, 3, 3, 3, 4]) = {1, 2, 3, 4}. The length is 4 unique elements.

Sets automatically remove duplicates.

Question 30

Sets maintain the order of elements as they were inserted.

True False

✓

Correct!

Sets are unordered collections. They don’t maintain insertion order. If you need ordered unique elements, use dict.fromkeys() or Python 3.7+ dict keys.

✗

Incorrect

Sets are unordered collections. They don’t maintain insertion order. If you need ordered unique elements, use dict.fromkeys() or Python 3.7+ dict keys.

Check the data structure comparison table.

Question 31

What does map() return in Python 3?

A list A generator object An iterator (map object) A generator function

✓

Correct!

map() returns an iterator (a map object), not a list. This is similar to a generator in that it uses lazy evaluation, but it is its own distinct type. You need to convert it with list() or consume it in a loop to get the actual values.

✗

Incorrect

Think about lazy evaluation and memory efficiency.

Question 32

What is printed?

names = ['alice', 'bob']
result = list(map(str.upper, names))
print(result[1])

What will this code output?

'alice' 'ALICE' 'bob' 'BOB'

✓

Correct!

map(str.upper, names) applies .upper() to each name, creating [‘ALICE’, ‘BOB’]. result[1] accesses the second element = ‘BOB’.

✗

Incorrect

map(str.upper, names) applies .upper() to each name, creating [‘ALICE’, ‘BOB’]. result[1] accesses the second element = ‘BOB’.

map() applies the function to each element. Index 1 is the second element.

Question 33

Why do we need to wrap map() with list() in Python 3?

map() returns an iterator (lazy evaluation), not a list.

Without list():

result = map(str.upper, names)
print(result)  # <map object at 0x...>

With list():

result = list(map(str.upper, names))
print(result)  # ['ALICE', 'BOB']

Benefits of lazy evaluation:

Memory efficient (processes one item at a time)
Only computes when needed
Can work with infinite sequences

When to use list(): When you need the complete result immediately or need to use it multiple times.

Did you get it right?

✓

Correct!

✗

Incorrect

Question 34

Complete the code to filter even numbers:

Fill in the lambda function

numbers = [1, 2, 3, 4, 5, 6]
evens = list(filter(lambda x: _____, numbers))

Your answer:

✓

Correct!

filter() keeps elements where the function returns True. lambda x: x % 2 == 0 returns True for even numbers (divisible by 2).

✗

Incorrect

filter() keeps elements where the function returns True. lambda x: x % 2 == 0 returns True for even numbers (divisible by 2).

Question 35

What happens when zip() receives iterables of different lengths?

It raises a ValueError It pads the shorter ones with None It stops at the shortest iterable It repeats the shorter iterables

✓

Correct!

zip() stops when the shortest iterable is exhausted. Example: zip([1, 2, 3], ['a', 'b']) produces [(1, 'a'), (2, 'b')]. The 3 is ignored.

✗

Incorrect

zip() stops when the shortest iterable is exhausted. Example: zip([1, 2, 3], ['a', 'b']) produces [(1, 'a'), (2, 'b')]. The 3 is ignored.

Think about parallel iteration—what happens when one sequence runs out?

Question 36

What does this print?

pairs = [('a', 1), ('b', 2), ('c', 3)]
letters, numbers = zip(*pairs)
print(numbers)

What will this code output?

[1, 2, 3] (1, 2, 3) ['a', 'b', 'c'] ('a', 'b', 'c')

✓

Correct!

zip(*pairs) unpacks the list and ‘unzips’ it into separate tuples. letters = ('a', 'b', 'c') and numbers = (1, 2, 3). Note: zip returns tuples, not lists.

✗

Incorrect

zip(*pairs) unpacks the list and ‘unzips’ it into separate tuples. letters = ('a', 'b', 'c') and numbers = (1, 2, 3). Note: zip returns tuples, not lists.

The * operator unpacks the list. What does zip return?

Question 37

Which statements about enumerate() are true?

It returns tuples of (index, value) The default starting index is 0 You can specify a custom starting index with the start parameter It modifies the original iterable It works with any iterable, not just lists enumerate() requires the iterable to support integer indexing

✓

Correct!

enumerate() returns (index, value) tuples, starts at 0 by default, supports custom start index, and works with any iterable — including strings, generators, and files. It does NOT modify the original, and does NOT require the iterable to support indexing.

✗

Incorrect

enumerate() is a non-destructive iterator function.

Question 38

What function returns a new sorted list without modifying the original?

✓

Correct!

The sorted() function returns a new sorted list. The .sort() method sorts in-place and returns None.

✗

Incorrect

The sorted() function returns a new sorted list. The .sort() method sorts in-place and returns None.

Is it a function or a method?

Question 39

What is the output?

words = ['apple', 'pie', 'banana']
result = max(words, key=len)
print(result)

What will this code output?

"apple" "banana" "pie" 6

✓

Correct!

max(words, key=len) finds the word with maximum length. ‘banana’ has 6 characters (longest), so it returns ‘banana’, not the length.

✗

Incorrect

max(words, key=len) finds the word with maximum length. ‘banana’ has 6 characters (longest), so it returns ‘banana’, not the length.

max() with key=len returns the element itself, not the length.

Question 40

any([False, False, False]) returns True.

True False

✓

Correct!

any() returns True if at least one element is True. Since all elements are False, it returns False. any([False, False, True]) would return True.

✗

Incorrect

any() returns True if at least one element is True. Since all elements are False, it returns False. any([False, False, True]) would return True.

any() means ‘at least one True’.

Question 41

What’s the difference between any() and all()?

any(iterable) → True if at least one element is True

any([False, False, True]) = True
any([False, False, False]) = False
Short-circuits: stops at first True

all(iterable) → True if all elements are True

all([True, True, True]) = True
all([True, False, True]) = False
Short-circuits: stops at first False

Common patterns:

# Check if string has any digits
any(c.isdigit() for c in "abc3x")  # True

# Check if all numbers are positive
all(n > 0 for n in [1, 2, 3])  # True

Did you get it right?

✓

Correct!

✗

Incorrect

Question 42

Complete the lambda function to sort points by their second element:

Fill in the lambda

points = [(1, 5), (3, 2), (2, 8)]
sorted_points = sorted(points, key=lambda x: _____)

Your answer:

✓

Correct!

To sort by the second element of each tuple, the lambda should return x[1]. This gives [(3, 2), (1, 5), (2, 8)] sorted by second values: 2, 5, 8.

✗

Incorrect

To sort by the second element of each tuple, the lambda should return x[1]. This gives [(3, 2), (1, 5), (2, 8)] sorted by second values: 2, 5, 8.

Question 43

When should you prefer a list comprehension over map()?

When you need lazy evaluation When you want more readable code with filtering When working with infinite sequences When you already have a named function to apply (e.g., str.upper)

✓

Correct!

List comprehensions are more Pythonic and readable, especially when combining mapping and filtering. map() is often cleaner when you already have a named function — map(str.upper, names) vs [str.upper(n) for n in names]. For lazy evaluation or infinite sequences, map() (or a generator expression) is the right choice.

✗

Incorrect

Consider readability and the Zen of Python.

Question 44

What does this code produce?

numbers = [1, 2, 3, 4]
result = all(n > 0 for n in numbers)
print(result)

What will this code output?

True False [True, True, True, True] 4

✓

Correct!

all() checks if all elements satisfy the condition. Since all numbers (1, 2, 3, 4) are greater than 0, it returns True.

✗

Incorrect

all() checks if all elements satisfy the condition. Since all numbers (1, 2, 3, 4) are greater than 0, it returns True.

all() returns a single boolean, not a list.

Question 45

Which of these list operations run in O(1) time for large lists?

list.append(x) list[i] = x list.insert(0, x) x in list

✓

Correct!

list.append(x) — O(1) amortized: adds to the end with no shifting. list[i] = x — O(1): direct index access, no traversal. list.insert(0, x) — O(n): every existing element must shift right by one. x in list — O(n): Python scans from the first element until it finds a match or exhausts the list.

✗

Incorrect

Check the time complexity tables in the notes.

Question 46

The expression [1, 2, 3] + [4, 5] creates a new list without modifying the original lists.

True False

✓

Correct!

The + operator for lists creates a new list containing all elements. The original lists remain unchanged. To modify in place, use .extend().

✗

Incorrect

The + operator for lists creates a new list containing all elements. The original lists remain unchanged. To modify in place, use .extend().

Concatenation with + always creates new objects.

Question 47

Why should you avoid modifying a list while iterating over it?

It raises a RuntimeError: ’list changed size during iteration' It can cause the iterator to skip elements or raise errors It makes the code run slower Lists become immutable during iteration

✓

Correct!

Python does NOT automatically detect or block list modification during iteration. The iterator simply tracks an internal index; when elements are removed, that index jumps over items silently. The result is skipped elements or wrong output — no RuntimeError is raised. (Note: dicts and sets do raise RuntimeError for this; lists do not.)

✗

Incorrect

Think about what happens when you remove an element that the iterator is pointing to.

Question 48

Fix this code to safely remove even numbers while iterating:

Replace the problematic line

numbers = [1, 2, 3, 4, 5]
# Bad approach (causes issues):
# for num in numbers:
#     if num % 2 == 0:
#         numbers.remove(num)

# Good approach:
numbers = [_____ for n in numbers if _____]

Your answer:

✓

Correct!

Use list comprehension to create a new list with only odd numbers: numbers = [n for n in numbers if n % 2 != 0]. This avoids modifying the list during iteration.

✗

Incorrect

Use list comprehension to create a new list with only odd numbers: numbers = [n for n in numbers if n % 2 != 0]. This avoids modifying the list during iteration.

Question 49

What’s the gotcha with .append() when adding multiple items to a list?

.append() takes exactly ONE argument!

Wrong:

my_list = []
my_list.append(1, 2, 3)  # TypeError!

Correct options:

One at a time:

my_list.append(1)
my_list.append(2)

Use .extend() for multiple items:

my_list.extend([1, 2, 3])  # [1, 2, 3]

Append a single structured item (e.g., dict):

log = []
log.append({'ip': '192.168.1.1', 'method': 'GET'})

Key: append = one item, extend = multiple items

Did you get it right?

✓

Correct!

✗

Incorrect

Question 50

You need to modify list elements in-place based on their current values. What’s the safest approach?

for item in my_list: my_list[i] = transform(item) for i, item in enumerate(my_list): my_list[i] = transform(item) for i, item in enumerate(my_list[:]): my_list[i] = transform(item) my_list = [transform(item) for item in my_list]

✓

Correct!

Option 3 is correct: enumerate(my_list[:]) iterates over a COPY while modifying the original by index. Option 2 might work for simple cases but can fail with insertions/deletions. Option 4 creates a new list (not in-place). Option 1 has a bug (undefined i).

✗

Incorrect

When modifying in-place, what should you iterate over?

Question 51

Given:

students = {
    "student1": {"name": "Alice", "age": 16, "classes": ["Math", "Physics"]},
    "student2": {"name": "Bob",   "age": 17, "classes": ["Chemistry", "Biology"]}
}

Which expression accesses "Math"?

students["student1"]["classes"][1] students["student1"]["classes"]["Math"] students["student1"]["classes"][0] students["classes"]["student1"][0]

✓

Correct!

Nested access works left to right: students["student1"] → Alice’s dict → ["classes"] → the list ["Math", "Physics"] → [0] → first element "Math". Option 1 gets "Physics" (index 1). Option 2 tries to index a list with a string key, raising TypeError. Option 4 uses the wrong key order.

✗

Incorrect

Follow the chain: dict → nested dict → list → index.

Question 52

Given:

students = {
    "student1": {"name": "Alice", "age": 16, "classes": ["Math", "Physics"]},
    "student2": {"name": "Bob",   "age": 17, "classes": ["Chemistry", "Biology"]}
}

"grade" in students["student1"] returns True because students["student1"] is a non-empty dictionary.

True False

✓

Correct!

The in operator checks key existence, not whether the dict is non-empty. students["student1"] has keys "name", "age", "classes" — but no "grade" key. Result is False. Compare: "classes" in students["student2"] → True.

✗

Incorrect

What exactly does in check on a dictionary?

Question 53

What does this raise?

scores = {}
scores["alice"]["math"] = 95

What will this code output?

No error — creates `{"alice": {"math": 95}}` KeyError: 'alice' TypeError: 'dict' object does not support item assignment ValueError: missing nested key

✓

Correct!

scores["alice"] raises KeyError immediately — the key doesn’t exist yet, so there’s no nested dict to assign into. Fix: initialize first with scores["alice"] = {} then scores["alice"]["math"] = 95, or in one step: scores["alice"] = {"math": 95}.

✗

Incorrect

What does scores["alice"] return when "alice" isn’t in the dict yet?

Question 54

You’re processing a log file where multiple lines can belong to the same pod. You want to track the first Scheduled and Killing timestamps per pod. Which initialization pattern is correct?

pod_events[pod] = {'s_time': None, 'k_time': None} (before the loop) if pod not in pod_events: pod_events[pod] = {'s_time': None, 'k_time': None} (inside the loop) pod_events[pod] = {'s_time': None, 'k_time': None} (inside the loop, unconditionally) pod_events.get(pod, {})['s_time'] = None

✓

Correct!

Option 2 is correct: initialize the entry only on first encounter inside the loop. Option 1 fails because pod isn’t known before the loop. Option 3 resets the dict on every log line, wiping previously recorded timestamps for that pod. Option 4 calls .get() which returns a temporary {} that gets discarded — the assignment never reaches pod_events.

✗

Incorrect

The init should happen once per pod, not once per log line.

Question 55

What does this print?

s = "Python"
print(s[::-1])

What will this code output?

"nohtyP" "Python" "Pto" "nhtoy"

✓

Correct!

The slice [::-1] uses step -1, which traverses the string from end to start. “Python” reversed is “nohtyP”. This is the idiomatic Python way to reverse any sequence — works on lists and tuples too.

✗

Incorrect

A negative step means you move backwards through the sequence.

Question 56

What does this print?

name = "Alice"
score = 95.5
print(f"{name} scored {score:.2f}")

What will this code output?

"Alice scored 95.5" "Alice scored 95.50" "{name} scored {score:.2f}" "Alice scored 95.55"

✓

Correct!

f-strings evaluate expressions inside {} at runtime. {score:.2f} formats the float with exactly 2 decimal places, so 95.5 becomes "95.50" — the trailing zero is always included. Without a format spec, {score} would produce "95.5".

✗

Incorrect

The .2f format spec means ‘fixed-point notation, 2 decimal places’.

Question 57

"hello".find("x") returns None when the substring is not found.

True False

✓

Correct!

.find() returns -1 (not None) when the substring isn’t found. This allows safe checks like if s.find('x') != -1. In contrast, .index() raises ValueError for a missing substring. Neither method returns None — that’s a common mix-up with .get() on dicts.

✗

Incorrect

What integer sentinel value signals ’not found’ in many C-style functions?

Question 58

What does this print?

s = "  hello   world  "
print(len(s.split()))

What will this code output?

1 2 3 18

✓

Correct!

Called with no argument, .split() splits on any whitespace and automatically discards the empty strings that leading, trailing, and consecutive spaces would produce. " hello world ".split() → ['hello', 'world'] — length 2. By contrast, .split(' ') with an explicit space would give ['', '', 'hello', '', '', 'world', '', ''] — length 8.

✗

Incorrect

The no-argument form of .split() collapses all whitespace runs into a single split.

Question 59

What set method returns elements in either set A or B, but not in both (equivalent to the ^ operator)?

✓

Correct!

.symmetric_difference(other) returns elements that belong to exactly one of the two sets. Example: {1, 2, 3}.symmetric_difference({2, 3, 4}) = {1, 4}. The operator shorthand is ^. Contrast with difference (-), which is directional: a - b gives elements in a not in b, while symmetric difference goes both ways.

✗

Incorrect

Think of it as the set equivalent of XOR — elements exclusive to one side.

Question 60

A lambda function can contain multiple statements separated by semicolons.

True False

✓

Correct!

Lambda functions are restricted to a single expression — no statements, no assignments, no loops, no return keyword. The expression’s value is automatically returned. lambda x: x**2 is valid; lambda x: y = x**2; y is a SyntaxError. If you need multiple steps, use a regular def function.

✗

Incorrect

Lambda is designed to be an expression, not a function body.

Question 61

s = {} creates an empty set.

True False

✓

Correct!

{} creates an empty dictionary, not a set. The {} syntax was used for dicts before sets got their own literal form. To create an empty set, you must use set(). Non-empty set literals work fine — {1, 2, 3} is a set — but {} is always a dict. This is a common silent bug when you expect set uniqueness behavior.

✗

Incorrect

What does type({}) return? Try it.

Question 62

What does this print?

a = [1, 2, 3]
b = a
b.append(4)
print(len(a))

What will this code output?

3 4 Error None

✓

Correct!

b = a creates a reference to the same list object — not a copy. Both a and b point to the same memory. Appending to b modifies the shared list, so a has 4 elements too. To create an independent copy, use a[:], a.copy(), or list(a). This is the same gotcha as the mutable default argument — Python never implicitly copies objects.

✗

Incorrect

Is b a new list, or just another name for the same list?

Question 63

max([]) raises a ValueError.

True False

✓

Correct!

Calling max() or min() on an empty iterable raises ValueError: max() arg is an empty sequence. This surprises many developers because sum([]) returns 0 and len([]) returns 0 without errors. To guard against empty input, pass a default: max([], default=0) returns 0 instead of raising.

✗

Incorrect

What can max() report when there are no elements to compare?

Question 64

What does this print?

items = ["a", "b", "a", "c", "a"]
counts = {}
for item in items:
    counts[item] = counts.get(item, 0) + 1
print(counts["a"])

What will this code output?

1 2 3 KeyError

✓

Correct!

Tracing ‘a’ encounters: first — counts.get('a', 0) returns 0 (missing), sets counts['a'] = 1; second — returns 1, sets 2; third — returns 2, sets 3. The pattern counts.get(key, 0) + 1 is the idiomatic one-liner for frequency counting: it handles the ‘first occurrence’ case without a pre-check or setdefault.

✗

Incorrect

Trace counts[‘a’] after each iteration where item == ‘a’.

Question 65

Which expression safely retrieves config["db"]["timeout"] and returns 30 if either "db" or "timeout" is missing?

config["db"]["timeout"] or 30 config.get("db").get("timeout", 30) config.get("db", {}).get("timeout", 30) config.get("db", {"timeout": 30}).get("timeout")

✓

Correct!

Option C is correct. config.get("db", {}) returns an empty dict if "db" is missing, giving the chained .get("timeout", 30) a safe target. Option B fails with AttributeError when "db" is absent — None has no .get(). Option A raises KeyError if "db" doesn’t exist at all. Option D works but is misleading — burying the default inside the first .get() obscures intent and is easy to mis-read.

✗

Incorrect

If .get(‘db’) returns None, what happens when you call .get(’timeout’) on None?

Question 66

What does this print?

scores = {"Alice": 85, "Bob": 92, "Charlie": 78}
top = sorted(scores.items(), key=lambda x: x[1], reverse=True)[0]
print(top[0])

What will this code output?

"Alice" "Bob" "Charlie" 92

✓

Correct!

scores.items() yields [('Alice', 85), ('Bob', 92), ('Charlie', 78)]. Sorting by x[1] (the score) descending gives [('Bob', 92), ('Alice', 85), ('Charlie', 78)]. [0] selects the first tuple ('Bob', 92), then [0] on that tuple yields the key 'Bob' — not the score 92. This is the idiomatic pattern for ‘find the key with the highest value’.

✗

Incorrect

After sorting, [0] is the top entry. What is top[0] vs top[1] on a (key, value) tuple?

Quiz Results

Score

0/0

Accuracy

Right

Wrong

Skipped

Last updated on April 21, 2026

Foundation Functions Deep Dive