Question 1

Basic list comprehension output

Accepted Answer

range(5) produces 0 through 4. Multiplying each by 2 gives 0, 2, 4, 6, 8. A common mistake is assuming range(5) starts at 1, which would yield [2, 4, 6, 8, 10]. Python ranges are always zero-indexed and exclude the stop value.

Question 2

Dict comprehension output

Accepted Answer

A dict comprehension uses curly braces with a key: value expression before the for clause. Here the key is the word itself and the value is its length, so 'hi' maps to 2 and 'hello' maps to 5. The result is a regular dict, not a list of tuples.

Question 3

Where does the filter clause go?

Accepted Answer

The structure is [expression for item in iterable if condition]. The if clause comes last and acts as a filter - elements that do not satisfy it are dropped entirely. A ternary in the expression position is different: it transforms every element rather than removing some.

Question 4

Set comprehension deduplication

Accepted Answer

Every word in the list has length 3, so the set comprehension collects {3}, which has exactly one element. Sets automatically deduplicate, so even though there are five words (including 'cat' twice), all map to the same length. If you expected 5, you were thinking of a list comprehension, not a set comprehension.

Question 5

Nested comprehension flattening

Accepted Answer

The two for clauses read left to right like nested loops: outer loop iterates rows, inner loop iterates elements within each row. This produces elements in row-major order: 1, 2, then 3, 4, then 5, 6. A common mistake is reversing the for clauses, which would try to iterate integers directly and raise a TypeError.

Question 6

Inverting a dict with comprehension

Accepted Answer

d.items() yields (key, value) pairs, so unpacking as k, v gives you both sides. Swapping them to v: k produces the inverted dict. Iterating d directly (without .items()) yields only keys, not pairs, so options that do that would fail.

Question 7

Ternary transform vs. filter

Accepted Answer

The ternary in 'a' keeps the list length the same - every element is either the even number or 0, giving six elements. The filter in 'b' drops odd elements entirely, leaving only [0, 2, 4]. This is the key distinction: a ternary in the expression position transforms, while 'if' at the end filters.

Question 8

Shared row reference bug

Accepted Answer

[[0] * cols] * rows creates rows references to the same inner list object. Mutating one row mutates all of them, so bad shows 99 in every row. The comprehension [[0] * cols for _ in range(rows)] creates a fresh inner list on each iteration, so only row 0 is affected in good. This is one of the most common Python 2D-array bugs in interviews.

Question 9

Generator expression laziness

Accepted Answer

A generator expression is lazy - it does not consume 'data' at creation time. The generator holds a reference to the list object and iterates it only when list(gen) is called. By that point data contains 6 elements including the appended 6, so the output includes 12. This is the critical difference from a list comprehension, which captures the values immediately at construction.

Question 10

Late binding in nested comprehension

Accepted Answer

Each lambda captures the variable x by reference, not by value. After the list comprehension finishes building fns, x is 2 - the final value from range(3). All three lambdas read the same x when called, so every call returns 2. To fix this, use a default argument to capture the current value: lambda x=x: x.

Comprehensions