Lambda Functions
List comprehensions are a concise syntax for creating a new list by transforming or filtering elements from an existing list.
A Shorter Route to a New List
A list comprehension is a concise syntax for creating a new list from an existing list. It can transform each source element, filter elements with a condition, or do both. The important idea is not merely that the notation is shorter: the comprehension describes a flow from source items to result items.
The Three Syntax Components
The basic form is [expression for item in iterable if condition]. The condition is optional. The expression describes what is placed in the new list, item names the current element, and iterable identifies the source of elements.
The expression appears first even though it is applied after the optional condition during processing. The for-clause identifies the current item and the iterable. If an if-condition is present, it determines whether the expression is applied for that item.
Following Each Item Through the Pipeline
To trace a list comprehension, take one source item at a time. The item comes from the iterable. If there is a condition, the item is checked against it. An item that does not pass contributes nothing to the new list. An item that passes is sent through the expression, and the expression's result is added to the new list.
What do you think happens?
Suppose the source items are 1, 2, and 3, the condition accepts only even items, and the expression doubles an accepted item. Which values reach the new list?
Reveal answer
Answer: 4
Only 2 passes the even-item condition. The expression then doubles it, so the result added to the new list is 4.
Transforming and Filtering Together
Keep selected values, then transform them
Use the source list 1, 2, 3, and 4. Keep only even items and double each item that is kept.
Choose the iterable: The source list supplies the items 1, 2, 3, and 4.
Apply the condition: The condition keeps 2 and 4 and excludes 1 and 3.
Apply the expression: The expression doubles the accepted items, producing 4 from 2 and 8 from 4.
Build the result: The new list contains the expression results in the order produced.
The resulting list is 4, 8.
This example separates the two jobs clearly. Filtering is handled by the condition, while transformation is handled by the expression. If you remove the condition, every source item reaches the expression. If you change the expression, the same accepted items can produce different results.
Choosing a Clear Construction
Use a list comprehension when the operation can be understood as a direct progression from source items to result items: select an item, optionally test it, and produce a result. Before writing one, state the operation in that order. For example: take each item from the source, keep items satisfying the condition, and apply the expression to each accepted item.
For multiple sources, nested list comprehensions can combine them. In that structure, the outer loop runs first, and for each outer item, the inner loop runs completely. Trace the outer item and inner items separately so that the resulting sequence is easier to predict.
Mistakes Beginners Make
Treating the condition as the transformation
Filtering and transforming are separate roles in the comprehension.
Fix:
Ask two questions: which items pass the condition, and what does the expression produce for each item that passes?Putting the clauses in the wrong conceptual order
The syntax identifies the expression, source item, iterable, and optional condition in defined positions.
Fix:
Write the expression first, then the for-clause with its item and iterable, then add the optional condition.Forgetting that a condition excludes an item entirely
The expression is applied only when the item passes the condition.
Fix:
Trace a failing item to the condition and stop its path there.Losing track of nested-loop order
The outer loop runs first, and the inner loop runs completely for each outer item.
Fix:
Choose one outer item, trace every inner item, then move to the next outer item.
Trace It Yourself
Consider a source list containing 2, 5, 6, and 9. Describe the resulting list when the condition keeps only even items and the expression adds 1 to each accepted item. State which items fail the condition and which transformed values are added.
Hints
- Check each source item against the even-item condition.
- Apply the expression only to the items that pass.
- Keep the transformed values in the order of the accepted source items.
Plan a nested comprehension trace using two outer items, A and B, and two inner items, 1 and 2. Without writing code, list the order in which the inner loop would be completed for each outer item.
Hints
- Start with outer item A and complete all inner items.
- Only after the inner loop is complete for A should you move to outer item B.
The Working Mental Model
- A list comprehension creates a new list by transforming or filtering elements from an existing list.
- Its basic syntax is expression, for item in iterable, followed optionally by if condition.
- Each source item is checked by the condition before the expression is applied.
- A failing item contributes no result; a passing item contributes the expression's result.
- In nested comprehensions, the outer loop runs first and the inner loop completes for each outer item.
Key Takeaways
- List comprehensions provide concise syntax for creating a new list from source elements.
- The expression produces result values, the iterable supplies items, and the optional condition filters items.
- Processing follows a source-item path: obtain the item, test the condition if present, transform it with the expression, and add the result.
- Debugging becomes easier when filtering, transformation, clause order, and nested-loop order are examined separately.