Foundation

Foundation Quiz

Quiz

Question 1 of 45 (0 answered)

Question 1

What happens when you execute a = [1, 2, 3] followed by b = a and then b.append(4)?

Only b contains [1, 2, 3, 4], a remains [1, 2, 3] Both a and b contain [1, 2, 3, 4] Both a and b contain [1, 2, 3, 4], but they become separate objects after append triggers a copy-on-write Only a contains [1, 2, 3, 4], b remains [1, 2, 3]

✓

Correct!

In Python, b = a creates a reference to the same list object, not a copy. When you modify b, you’re modifying the same object that a references. To create an independent copy, use b = a.copy().

✗

Incorrect

Think about whether variables hold values or references to objects.

Question 2

Which of the following evaluate to False in a boolean context?

0 [0] "" None False {} "0"

✓

Correct!

Falsy values in Python include: numeric zero (0, 0.0, 0j), empty sequences ("", [], (), {}), None, and False. Note that [0] is a non-empty list containing one element, so it’s truthy. Similarly, "0" (the string containing the character zero) is truthy because it is a non-empty string — only the empty string "" is falsy.

✗

Incorrect

Empty containers are falsy, but containers with items (even if those items are falsy) are truthy.

Question 3

The expression 1 < x < 10 is equivalent to 1 < x and x < 10 in Python.

True False

✓

Correct!

Python supports chained comparisons, which is a Pythonic feature. 1 < x < 10 is syntactic sugar for 1 < x and x < 10, making code more readable.

✗

Incorrect

Python supports chained comparisons, which is a Pythonic feature. 1 < x < 10 is syntactic sugar for 1 < x and x < 10, making code more readable.

This is one of Python’s unique features that makes comparisons more natural.

Question 4

Predict the output:

x = 5
x += 3
x *= 2
print(x)

What will this code output?

10 16 13 11

✓

Correct!

Step by step: x = 5, then x += 3 makes x = 8, then x *= 2 makes x = 16. Assignment operators modify the variable in place.

✗

Incorrect

Step by step: x = 5, then x += 3 makes x = 8, then x *= 2 makes x = 16. Assignment operators modify the variable in place.

Follow each operation step by step: addition first, then multiplication.

Question 5

What operator is used in Python 3.8+ to assign a value AND use it in the same expression?

✓

Correct!

The walrus operator (:=) allows you to assign a value to a variable and use that value in the same expression, e.g., if (n := len(data)) > 10:

✗

Incorrect

The walrus operator (:=) allows you to assign a value to a variable and use that value in the same expression, e.g., if (n := len(data)) > 10:

It’s nicknamed after an animal because of how it looks.

Question 6

What is the output of this code?

for i in range(3):
    count = 0
    count += i
    print(count, end=' ')

What will this code output?

`0 1 2` `0 1 3` `1 2 3` `0 0 0`

✓

Correct!

The variable count is declared inside the loop, so it resets to 0 on every iteration. Then it adds i (0, 1, 2) and prints. If count were declared outside the loop, it would accumulate values.

✗

Incorrect

Pay attention to where count is initialized—inside or outside the loop?

Question 7

Which comparison should you use to check if a variable is None?

x == None x is None bool(x) == False not x

✓

Correct!

Always use is (not ==) for None checks. is checks object identity, while == checks value equality. Since None is a singleton (there is exactly one None object in memory), is None is the correct and idiomatic approach.

✗

Incorrect

Think about identity versus equality.

Question 8

The expression False and expensive_function() will execute expensive_function().

True False

✓

Correct!

Python uses short-circuit evaluation. Since the left side of and is False, the result is already known to be False, so Python never evaluates the right side. This is an optimization that can prevent unnecessary computations.

✗

Incorrect

Consider what ‘short-circuit evaluation’ means.

Question 9

Arrange these Big O complexities from fastest to slowest:

Drag to arrange in order of increasing runtime (fastest to slowest)

⋮⋮ O(1)

⋮⋮ O(n)

⋮⋮ O(log n)

⋮⋮ O(n log n)

⋮⋮ O(n²)

⋮⋮ O(2ⁿ)

✓

Correct!

The order from fastest to slowest is: O(1) < O(log n) < O(n) < O(n log n) < O(n²) < O(2ⁿ). Constant time is fastest, exponential is slowest.

✗

Incorrect

The order from fastest to slowest is: O(1) < O(log n) < O(n) < O(n log n) < O(n²) < O(2ⁿ). Constant time is fastest, exponential is slowest.

Question 10

What is the time complexity of this code?

for i in range(n):
    for j in range(n):
        print(i, j)

O(log n) O(n) O(n log n) O(n²)

✓

Correct!

This is a nested loop where both loops run n times. The outer loop runs n times, and for each iteration of the outer loop, the inner loop also runs n times. Total operations: n × n = n². This is quadratic time complexity.

✗

Incorrect

Count how many times the innermost operation executes relative to the input size.

Question 11

Complete the code to iterate over both indices and values:

Fill in the missing function name

fruits = ['apple', 'banana', 'cherry']
for index, fruit in _____(fruits):
    print(f"{index}: {fruit}")

Your answer:

✓

Correct!

The enumerate() function returns both the index and value while iterating over a sequence. It’s more Pythonic than using range(len(fruits)) and manually indexing.

✗

Incorrect

The enumerate() function returns both the index and value while iterating over a sequence. It’s more Pythonic than using range(len(fruits)) and manually indexing.

Question 12

What is the Walrus Operator and when was it introduced?

The Walrus Operator (:=)

Introduced in Python 3.8+, it allows you to assign a value to a variable AND use that value in the same expression.

General Form:

variable := expression

Example:

if (n := len(data)) > 10:
    print(f"List has {n} elements")

This evaluates len(data), assigns it to n, and uses it in the comparison—all in one line.

Did you get it right?

✓

Correct!

✗

Incorrect

Question 13

Which of the following are valid uses of the else clause with loops in Python?

The else block executes when the loop completes normally (no break) The else block executes only if break is called Both for and while loops support the else clause The else block executes when a continue is encountered

✓

Correct!

In Python, both for and while loops can have an else clause that executes only when the loop completes normally without encountering a break. This is useful for search operations where you want to know if the search completed without finding the target.

✗

Incorrect

Think about what ’normally’ means for loop completion.

Question 14

What does this code print?

result = 0 or 5 or 10
print(result)

What will this code output?

`0` `5` `10` `15`

✓

Correct!

The or operator returns the first truthy value. Since 0 is falsy, it skips to 5, which is truthy, and returns it immediately (short-circuit evaluation). The value 10 is never evaluated.

✗

Incorrect

The or operator returns the first truthy value. Since 0 is falsy, it skips to 5, which is truthy, and returns it immediately (short-circuit evaluation). The value 10 is never evaluated.

Remember that or returns the first truthy value, not True/False.

Question 15

What is the problem with using timeout = seconds or 30 when seconds can legitimately be 0?

The problem only occurs when seconds is None, not when it is 0 It will set timeout to 30 when seconds is 0, even though 0 is a valid value It will always return seconds unchanged because or only applies the default when seconds is None There is no problem with this code

✓

Correct!

Since 0 is falsy in Python, 0 or 30 evaluates to 30. If 0 is a valid timeout value (e.g., no timeout), this breaks the logic. The fix is: timeout = 30 if seconds is None else seconds, which explicitly checks for None only.

✗

Incorrect

Consider that numeric zero is falsy but might be a meaningful value.

Question 16

In Big O notation, O(2n) and O(n) are considered equivalent.

True False

✓

Correct!

Big O notation drops constants because it focuses on how runtime scales with input size, not exact operation counts. Both O(2n) and O(n) scale linearly, so they’re both O(n). The constant factor (2×) becomes negligible for large inputs.

✗

Incorrect

Big O cares about growth rate, not exact counts.

Question 17

What is the time complexity of binary search? (Use Big O notation)

✓

Correct!

Binary search has O(log n) complexity because it halves the search space with each iteration. For an array of 1000 elements, it takes at most ~10 steps (log₂ 1000 ≈ 10).

✗

Incorrect

Binary search has O(log n) complexity because it halves the search space with each iteration. For an array of 1000 elements, it takes at most ~10 steps (log₂ 1000 ≈ 10).

Think about how many times you can divide n by 2 until you reach 1.

Question 18

Predict the output:

x, y = 10, 20
x, y = y, x
print(x, y)

What will this code output?

`10 20` `20 10` `20 20` `10 10`

✓

Correct!

Python supports simultaneous assignment, making swapping trivial. The right side (y, x) is evaluated first as a tuple (20, 10), then unpacked to x, y. No temporary variable needed!

✗

Incorrect

Python supports simultaneous assignment, making swapping trivial. The right side (y, x) is evaluated first as a tuple (20, 10), then unpacked to x, y. No temporary variable needed!

Python evaluates the entire right side before assigning to the left side.

Question 19

What is Short-Circuit Evaluation?

Short-Circuit Evaluation

Python stops evaluating a logical expression as soon as the final result is determined.

With and:

If left side is False, result must be False—don’t evaluate right side
False and expensive_function() → Never calls function

With or:

If left side is True, result must be True—don’t evaluate right side
True or expensive_function() → Never calls function

This is both an optimization and a useful programming pattern for avoiding errors (e.g., x and x.method() won’t fail if x is None).

Did you get it right?

✓

Correct!

✗

Incorrect

Question 20

What is the time complexity of looking up a value in a Python dictionary?

O(1) - Constant O(log n) - Logarithmic O(n) - Linear O(n log n) - Linearithmic

✓

Correct!

Dictionary lookup in Python uses hash tables, providing O(1) average-case lookup time. This makes dictionaries much faster than lists for membership testing when you have many elements. O(log n) would apply to sorted-tree data structures (like a balanced BST), not hash tables.

✗

Incorrect

Dictionaries use hashing for direct access.

Question 21

Complete the code to create an independent copy of a list:

Fill in the method name

original = [1, 2, 3]
independent = original._____()
independent.append(4)

Your answer:

✓

Correct!

The .copy() method creates a shallow copy of a list, making it independent from the original. Modifying the copy won’t affect the original. Alternatively, you could use independent = original[:] or independent = list(original).

✗

Incorrect

Question 22

Which statements about the range() function are correct?

range(5) produces values from 0 to 4 range(5) produces values from 1 to 5 range(2, 7) produces values from 2 to 7 inclusive range(0, 10, 2) produces even numbers from 0 to 8 range() returns a list

✓

Correct!

range() uses zero-based indexing and excludes the stop value. range(5) gives 0-4, range(2, 7) gives 2-6 (not 7). The third parameter is step size: range(0, 10, 2) gives 0, 2, 4, 6, 8. Modern Python returns a range object (not a list) for memory efficiency.

✗

Incorrect

Remember: start is inclusive, stop is exclusive.

Question 23

What is printed?

for num in [1, 2, 3, 4, 5]:
    if num % 2 == 0:
        continue
    print(num, end=' ')

What will this code output?

`1 3 5` `2 4` `1 2 3 4 5` Nothing is printed

✓

Correct!

The continue statement skips the rest of the current iteration and moves to the next one. When num is even (2, 4), it skips the print statement. Only odd numbers (1, 3, 5) are printed.

✗

Incorrect

The continue statement skips the rest of the current iteration and moves to the next one. When num is even (2, 4), it skips the print statement. Only odd numbers (1, 3, 5) are printed.

continue skips to the next iteration.

Question 24

The expression isinstance(3.14, (int, float)) returns True.

True False

✓

Correct!

isinstance() can check against a tuple of types, returning True if the value matches any type in the tuple. Since 3.14 is a float, and float is in the tuple (int, float), it returns True.

✗

Incorrect

isinstance() can check against a tuple of types, returning True if the value matches any type in the tuple. Since 3.14 is a float, and float is in the tuple (int, float), it returns True.

isinstance() accepts either a single type or a tuple of types.

Question 25

What is the Accumulator Pattern?

The Accumulator Pattern

A fundamental programming pattern that builds up a result through iteration:

Initialize a variable before the loop (e.g., total = 0)
Update it inside the loop (e.g., total += num)
Use the final result after the loop

Examples:

# Sum accumulator
total = 0
for num in numbers:
    total += num

# List accumulator
squares = []
for i in range(1, 6):
    squares.append(i ** 2)

The key is that the variable is declared outside the loop so it persists across iterations.

Did you get it right?

✓

Correct!

✗

Incorrect

Question 26

In the nested loops below, how many times does the inner print statement execute?

for i in range(3):
    for j in range(4):
        print(i, j)

3 times 4 times 7 times 12 times

✓

Correct!

The outer loop runs 3 times, and for each iteration of the outer loop, the inner loop runs 4 times. Total executions: 3 × 4 = 12. This is why nested loops often have O(n²) complexity when both loops depend on the same size.

✗

Incorrect

Multiply the number of outer iterations by the number of inner iterations.

Question 27

What does this code output?

numbers = [1, 2, 3, 4, 5]
for num in numbers:
    if num == 3:
        print("Found")
        break
else:
    print("Not found")

What will this code output?

Found Not found Found\nNot found Nothing

✓

Correct!

The loop finds 3 and executes break, which exits the loop. Since break was called, the else clause is skipped. Only ‘Found’ is printed. The else clause only runs when the loop completes normally without break.

✗

Incorrect

The else clause is skipped when break is executed.

Question 28

What keyword is used to skip the current iteration of a loop and move to the next one?

✓

Correct!

The continue keyword skips the remaining code in the current loop iteration and jumps to the next iteration. It’s different from break, which exits the loop entirely.

✗

Incorrect

The continue keyword skips the remaining code in the current loop iteration and jumps to the next iteration. It’s different from break, which exits the loop entirely.

It’s not break or pass.

Question 29

Which operation has O(n²) time complexity?

Searching for a value in a sorted array using binary search Finding the maximum value in an unsorted list Comparing every element with every other element in a list Sorting a list with merge sort

✓

Correct!

Comparing every element with every other element requires nested loops, resulting in O(n²) complexity. Binary search is O(log n), finding max is O(n), and merge sort is O(n log n).

✗

Incorrect

Comparing every element with every other element requires nested loops, resulting in O(n²) complexity. Binary search is O(log n), finding max is O(n), and merge sort is O(n log n).

Think about which operation requires nested loops over the same data.

Question 30

Complete the code to iterate over both parallel lists simultaneously:

Fill in the missing function

names = ['Alice', 'Bob', 'Charlie']
scores = [85, 92, 78]
for name, score in _____(names, scores):
    print(f"{name}: {score}")

Your answer:

✓

Correct!

The zip() function takes multiple iterables and returns an iterator of tuples, pairing up elements from each iterable. It’s perfect for parallel iteration over multiple sequences.

✗

Incorrect

The zip() function takes multiple iterables and returns an iterator of tuples, pairing up elements from each iterable. It’s perfect for parallel iteration over multiple sequences.

Question 31

An algorithm with O(n + n²) time complexity simplifies to O(n) in Big O notation.

True False

✓

Correct!

When combining complexities, we keep the dominant (largest) term. Since n² grows much faster than n, O(n + n²) simplifies to O(n²), not O(n). For example, with n=1000: n=1,000 but n²=1,000,000—the n² term dominates.

✗

Incorrect

Which term grows faster as n increases?

Question 32

What is the difference between == and is in Python?

== vs is

== (Equality Operator):

Compares values
Checks if two objects have the same content
Example: [1, 2, 3] == [1, 2, 3] → True

is (Identity Operator):

Compares object identity (memory address)
Checks if two variables reference the exact same object
Example: a = [1, 2, 3]; b = [1, 2, 3]; a is b → False

Best Practice:

Use is for singleton objects like None: x is None
Use == for value comparisons

Did you get it right?

✓

Correct!

✗

Incorrect

Question 33

You want code to run only when both of these are true:

reason == 'Scheduled'
Either s_time is None or ts < s_time

Which condition is correct?

reason == 'Scheduled' and s_time is None or ts < s_time reason == 'Scheduled' and (s_time is None or ts < s_time) (reason == 'Scheduled' and s_time is None) or ts < s_time Options A and C are equivalent to B

✓

Correct!

Only option B matches the intent. Options A and C are identical after Python applies precedence: since and binds tighter than or, reason == 'Scheduled' and s_time is None or ts < s_time is parsed as (reason == 'Scheduled' and s_time is None) or ts < s_time. This causes the condition to fire whenever ts < s_time, regardless of reason. Explicit parentheses around the or subexpression are required.

✗

Incorrect

and has higher precedence than or—it groups first, just like * before +.

Question 34

Predict the output:

print(15 / 4)
print(15 // 4)

What will this code output?

`3.75` then `3` `3` then `3` `3.75` then `3.75` `4` then `3`

✓

Correct!

In Python 3, / (true division) always returns a float, even when dividing two integers: 15 / 4 = 3.75. The // operator is floor division — it rounds down to the nearest integer: 15 // 4 = 3. This differs from Python 2, where 15 / 4 returned 3. A common bug: expecting an integer from / and getting unexpected decimal results in downstream calculations.

✗

Incorrect

Python 3 changed how / works compared to Python 2 — it no longer truncates.

Question 35

Which of the following is the correct Python ternary (conditional) expression syntax?

status = "adult" if age >= 18 else "minor" status = age >= 18 ? "adult" : "minor" status = if age >= 18: "adult" else: "minor" status = "adult" when age >= 18 else "minor"

✓

Correct!

Python’s ternary expression uses value_if_true if condition else value_if_false. Option B is C/JavaScript ternary syntax (?:), which Python does not support. Option C uses statement syntax (with colons) inside an expression context, which is a SyntaxError. Option D uses when, which is not a Python keyword. Only option A is valid Python.

✗

Incorrect

Python reads like English — the condition comes after the value it guards.

Question 36

The expression name = user_input or 'Anonymous' will set name to 'Anonymous' when user_input is an empty string "", even if an empty string was intentional.

True False

✓

Correct!

Empty string "" is falsy in Python, so "" or 'Anonymous' evaluates to 'Anonymous' — the exact same mechanism as 0 or 30 returning 30. Both 0 and "" are falsy, so the or default pattern silently replaces them. The fix is an explicit None check: name = 'Anonymous' if user_input is None else user_input, which substitutes only when the value is truly absent.

✗

Incorrect

Empty string and numeric zero share the same falsy behavior with or defaults.

Question 37

Predict the output:

count = 0
for i in range(5):
    if i == 2:
        pass
    count += 1
print(count)

What will this code output?

`4` `5` `3` `2`

✓

Correct!

pass is a true no-op — it does absolutely nothing, and execution falls through to the next statement. When i == 2, pass executes (doing nothing), then count += 1 still runs. All 5 iterations increment count, giving 5. If continue were used instead, it would skip count += 1 for i == 2, giving 4. The critical distinction: pass fills syntactic space; continue redirects control flow.

✗

Incorrect

pass does nothing at all — it’s a placeholder, not a loop control statement.

Question 38

Which of the following are valid ways to iterate over d = {'name': 'Alice', 'age': 30}?

for key in d: — iterates over keys for value in d.values(): — iterates over values for key, value in d.items(): — iterates over key-value pairs for key, value in d: — unpacks each entry directly from the dict for value in d.keys(): — iterates over values using the keys method

✓

Correct!

Iterating a dict directly (for x in d) yields its keys only, not key-value pairs — so for key, value in d fails with ValueError: too many values to unpack. d.keys() returns keys, not values, making option E semantically wrong (it yields keys while the variable is named value). The three correct patterns: for key in d: (keys), for value in d.values(): (values), for key, value in d.items(): (both).

✗

Incorrect

Iterating a dict directly yields only keys — you need .items() for key-value pairs.

Question 39

In Python’s match-case statement, execution automatically falls through from a matched case to the next one, similar to switch in C or Java.

True False

✓

Correct!

Unlike C/Java switch, Python’s match-case does not fall through. Only the first matching case executes, then control exits the match block entirely. In C, you need explicit break to prevent fall-through; in Python, there is no fall-through at all — each case is fully isolated. This makes Python’s structural pattern matching safer by default.

✗

Incorrect

Python’s match-case was designed to avoid the fall-through footgun present in C-style switch statements.

Question 40

What does 'age' in {'name': 'Alice', 'age': 30} return?

True — in checks dictionary keys by default False — in checks dictionary values, and 'age' is not a value 30 — in returns the value associated with the matched key True — but this only works because the key happens to be a string

✓

Correct!

The in operator on a dictionary tests keys, not values. 'age' in d is equivalent to 'age' in d.keys(). To check values, use 30 in d.values(). To check a key-value pair, use ('age', 30) in d.items(). This is intentional: key lookup is O(1) via hashing; scanning values would require an O(n) sweep.

✗

Incorrect

Think about what for x in d iterates over — that’s what in also checks.

Question 41

In a match-case statement, what does case _: do?

Matches any value that didn’t match a previous case — acts as a catch-all default Matches only the Python singleton None — it’s the null wildcard Raises a SyntaxError if the variable _ was not defined before the match block Matches all falsy values: None, 0, "", [], False, {}

✓

Correct!

case _: is the wildcard pattern — it matches anything and is equivalent to the else in an if-elif-else chain. Unlike case x: (which captures the matched value into variable x), _ discards the matched value and doesn’t bind it. The wildcard doesn’t require _ to be defined beforehand — it’s pattern syntax, not a variable lookup. It must be the last case, or Python raises SyntaxError for unreachable patterns after it.

✗

Incorrect

The _ convention means ‘anything I don’t care about’ — same as in tuple unpacking like a, _ = (1, 2).

Question 42

What does this code print?

count = 3
while count > 0:
    print(count, end=' ')
    count -= 1

What will this code output?

`3 2 1` `3 2 1 0` `2 1 0` `0 1 2 3`

✓

Correct!

The loop runs while count > 0. Starting at 3: prints 3, decrements to 2 → prints 2, decrements to 1 → prints 1, decrements to 0 → condition 0 > 0 is False, loop exits. The value 0 is never printed because the condition is evaluated before each iteration, not after. Option B is a common off-by-one mistake from thinking the check happens after the body.

✗

Incorrect

The while condition is evaluated before the loop body — if it’s false, the body doesn’t run at all.

Question 43

Which of these two functions has O(n) space complexity?

# Function A
def sum_list(arr):
    total = 0
    for num in arr:
        total += num
    return total

# Function B
def double_list(arr):
    result = []
    for num in arr:
        result.append(num * 2)
    return result

Function A — it iterates over all n elements, so it uses O(n) memory Function B — it creates a new list that grows proportionally with the input size Both A and B — any function that processes an n-element list uses O(n) space Neither — both use the same memory since they share the input list

✓

Correct!

Space complexity measures extra memory allocated inside the function, not the input itself. Function A allocates only one variable (total) regardless of input size — that’s O(1) extra space. Function B builds a new result list that grows to n elements — that’s O(n) extra space. The input array doesn’t count toward either function’s space complexity; it was already in memory before the function ran.

✗

Incorrect

Count only the memory the function itself creates, not what it receives as a parameter.

Question 44

Quick Sort’s worst-case time complexity is O(n²) and can be triggered by an already-sorted input when the first element is always chosen as the pivot.

True False

✓

Correct!

Quick Sort picks a pivot and partitions around it. When the input is already sorted and you always pick the first element as pivot, every partition is maximally unbalanced: one side gets 0 elements, the other gets n−1. This forces n levels of recursion instead of log n, giving O(n²) total work. This is why Python’s built-in sorted() uses Timsort (O(n log n) worst case) rather than naive Quick Sort, and why knowing your data’s shape matters when choosing a sort algorithm.

✗

Incorrect

Think about what happens when the pivot is always the smallest element in the remaining array.

Question 45

You have a blocklist (a list) with 100,000 items. For each of 50,000 urls, you check if url in blocklist. What is the total time complexity of all 50,000 checks, and what is the simplest fix?

O(n²) total — each in on a list is O(n); converting blocklist to a set reduces all 50,000 checks to O(n) total O(n) total — Python’s in operator is internally optimized to O(1) for any sequence O(n log n) total — Python sorts the list internally before searching O(n²) total — the only fix is to implement binary search, reducing it to O(n log n)

✓

Correct!

Membership testing (in) on a list is O(n) — Python scans each element sequentially. Doing 50,000 O(n) checks gives O(n × n) = O(n²) total. Converting to a set uses a hash table, making each in check O(1) average case. The one-time conversion cost is O(n), so all 50,000 checks together cost O(n) total — a dramatic improvement. Binary search (option D) would give O(n log n) but requires keeping the list sorted; using a set is both simpler and faster.

✗

Incorrect

What data structure provides O(1) membership testing, similar to dict key lookup?

Quiz Results

Score

0/0

Accuracy

Right

Wrong

Skipped

Last updated on April 21, 2026

Python Building Blocks