Foundation

Foundation Quiz

Quiz

Question 1 of 33 (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] Python raises a ReferenceError 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 {}

✓

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.

✗

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(1) 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?

It will cause a TypeError It will set timeout to 30 when seconds is 0, even though 0 is a valid value It will set timeout to 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²) - Quadratic

✓

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.

✗

Incorrect

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.

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 +.

Quiz Results

Score

0/0

Accuracy

Right

Wrong

Skipped

Last updated on February 23, 2026

Python Building Blocks