Questions: List Comprehensions

Question 1

What does `[x * 2 for x in range(5) if x % 2 != 0]` evaluate to?

• A. [0, 2, 4, 6, 8]
• B. [2, 6]
• C. [1, 3]
• D. [2, 4, 6, 8, 10]

Answer: (B)

range(5) gives [0, 1, 2, 3, 4]. The condition `x % 2 != 0` keeps only odd numbers: 1 and 3. The expression `x * 2` doubles each: 1*2=2 and 3*2=6. Result: [2, 6]. A common error is forgetting that the expression (x * 2) comes before the for clause, and that the filter applies to the original x, not the transformed value. Reading the comprehension left-to-right: 'give me x*2, for x in range(5), but only if x is odd.'

Question 2

A developer uses a list comprehension `[send_email(user) for user in mailing_list]` to send emails. What is wrong with this usage?

• A. List comprehensions cannot call functions — only expressions are allowed
• B. List comprehensions should express data transformation without side effects; using one to drive API calls obscures intent and produces an unwanted list of return values
• C. The comprehension is missing a filter condition, so it will fail on empty lists
• D. This will execute correctly but is slower than a for loop for external calls

Answer: (B)

List comprehensions are intended to build a new list by transforming data — they signal declarative intent. Using them purely for side effects (sending emails, writing files, modifying state) violates that contract and confuses readers who expect a comprehension to produce a meaningful result list. A for loop is more honest here: it communicates 'I am performing an action for each item,' not 'I am building a collection.' The comprehension also creates a throwaway list of return values, which is wasteful.

Question 3

`[x ** 2 for x in numbers]` and `(x ** 2 for x in numbers)` are interchangeable — both yield the same values and behave identically.

• T. True
• F. False

Answer: False

False — they look similar but are fundamentally different objects. `[...]` is a list comprehension that immediately evaluates all values and stores them in memory as a list. `(...)` is a generator expression that produces values lazily, one at a time on demand. They differ in type (list vs generator), memory usage, and behavior: you cannot check the length of a generator, indexing into it fails, and iterating it a second time yields nothing (it is exhausted). The choice matters especially for large sequences where immediate evaluation would be expensive.

Question 4

A list comprehension `[f(x) for x in seq if pred(x)]` is semantically equivalent to a for loop that appends to a result list only when the condition is true.

• T. True
• F. False

Answer: True

True — this equivalence is the foundation of list comprehensions. The comprehension `[f(x) for x in seq if pred(x)]` is exactly the same logic as: `result = []; for x in seq: if pred(x): result.append(f(x))`. The comprehension is a more concise, declarative way to express the same computation with identical semantics. Understanding this equivalence lets you confidently convert between the two forms and reason about what a comprehension does by imagining the equivalent loop.

Question 5

What does it mean for code to be 'declarative' rather than 'imperative,' and why is this considered an advantage of list comprehensions over equivalent for loops?

Model answer: Imperative code says *how* to build a result: initialize an empty list, loop, check a condition, append. Declarative code says *what* the result should be: give me f(x) for each x where pred(x) holds. A list comprehension is declarative — a reader sees immediately that the result is a new list derived by transforming and filtering existing data, without tracing through loop mechanics. This communicates intent at a glance and reduces cognitive load. A for loop could be doing anything (printing, modifying globals, calling APIs), so the reader must read all its body to understand the purpose.

The readability advantage is the main reason list comprehensions are preferred for straightforward transformations. As a rule of thumb: if the transformation fits clearly on one line and reads like an English sentence, use a comprehension. If the logic requires multiple statements or complex branching, a loop is more honest about the complexity.