Building Blocks

Building Blocks Quiz

Quiz

Question 1 of 54 (0 answered)

Question 1

Which data structure allows duplicate values but has immutable keys?

List Set Dictionary Tuple

✓

Correct!

Dictionaries allow duplicate values but require unique, immutable (hashable) keys. Lists and tuples allow duplicates but don’t have keys. Sets don’t allow duplicates at all.

✗

Incorrect

Dictionaries allow duplicate values but require unique, immutable (hashable) keys. Lists and tuples allow duplicates but don’t have keys. Sets don’t allow duplicates at all.

Think about key-value pairs and which part must be unique.

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

✓

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.

✗

Incorrect

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.

Which operations require searching through 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” 9 TypeError

✓

Correct!

The * operator with strings performs repetition, concatenating the string with itself n times. “Ha” * 3 = “HaHaHa”.

✗

Incorrect

The * operator with strings performs repetition, concatenating the string with itself n times. “Ha” * 3 = “HaHaHa”.

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

✓

Correct!

Options 1, 2, 3, and 5 are true. The false statement is option 4: list comprehensions work with any iterable (not just lists). They are faster than loops, support filtering with if, can be nested, and always create new lists in memory.

✗

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” Empty string

✓

Correct!

The .get(key, default) method returns the default value (‘N/A’) if the key doesn’t exist. Without a default, it returns None. It never raises KeyError.

✗

Incorrect

The .get(key, default) method returns the default value (‘N/A’) if the key doesn’t exist. Without a default, it returns None. It never raises KeyError.

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 creates a list with duplicates 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.

✗

Incorrect

Sets automatically enforce uniqueness. Adding a duplicate element is simply ignored—no error, no change. The set remains unchanged.

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 tuple An iterator (map object) A generator function

✓

Correct!

map() returns an iterator (lazy evaluation), not a list. You need to convert it with list() or consume it in a loop to get the actual values.

✗

Incorrect

map() returns an iterator (lazy evaluation), not a list. You need to convert it with list() or consume it in a loop to get the actual values.

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

✓

Correct!

enumerate() returns (index, value) tuples, starts at 0 by default, supports custom start index, and works with any iterable. It does NOT modify the original—it returns a new iterator.

✗

Incorrect

enumerate() returns (index, value) tuples, starts at 0 by default, supports custom start index, and works with any iterable. It does NOT modify the original—it returns a new iterator.

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 Never—map() is always better

✓

Correct!

List comprehensions are more Pythonic and readable, especially when combining mapping and filtering. map() is better for lazy evaluation or when you already have a named function. Example: [x**2 for x in nums if x > 0] is clearer than list(map(lambda x: x**2, filter(lambda x: x > 0, nums))).

✗

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

Arrange these operations from fastest to slowest time complexity for large lists:

Drag to order by speed (fastest to slowest)

⋮⋮ list.append(x)

⋮⋮ list[i] = x

⋮⋮ list.insert(0, x)

⋮⋮ x in list

✓

Correct!

O(1): append() and index assignment. O(n): insert(0) shifts all elements, membership test searches linearly. Order: append ≈ indexing (both O(1)), then insert(0), then membership (both O(n)).

✗

Incorrect

O(1): append() and index assignment. O(n): insert(0) shifts all elements, membership test searches linearly. Order: append ≈ indexing (both O(1)), then insert(0), then membership (both O(n)).

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’s against Python syntax rules It can cause the iterator to skip elements or raise errors It makes the code run slower Lists become immutable during iteration

✓

Correct!

Modifying a list during iteration can cause unpredictable behavior—skipping elements, processing the same element twice, or index errors. Instead, iterate over a copy (for item in list[:]) or use comprehension.

✗

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"][0] 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). Options 2 and 4 use 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.

Quiz Results

Score

0/0

Accuracy

Right

Wrong

Skipped

Last updated on February 23, 2026

Foundation Functions Deep Dive