When values from two iterables need to go into one Python list, the order of the loops determines the order of the results. A list comprehension builds a new list by evaluating an expression for the values its clauses supply.
I’ll explain how the clauses map to nested loops and show how the expression controls whether the result is flat or arranged in rows.
TL;DR
Write one for clause for each loop, in the same order as the equivalent nested loops. For a first conversion, mirror the existing loop order because it matches the flow of the original loops.
- A pair of for clauses creates a flat result unless the expression itself builds a nested list.
- The first iterable is the outer loop, and the last iterable changes fastest.
- Put filtering conditions after the for clauses whose variables they use.
What Does Double Iteration Mean in a List Comprehension?
Double iteration means revisiting values in one iterable for each value in another. The comprehension expression decides what each visit contributes to the new list.
This explanation defines the result before walking through its loop order because each visit needs a clear item to add.
A list comprehension builds a new list by evaluating an expression for values supplied by its clauses. The official list-comprehension tutorial defines this form and shows how nested loops express the same task.
Read the clauses from left to right as loops from the outside in.
A compact trace shows the order:
| Outer value | Inner values visited | Results emitted |
|---|---|---|
| 1 | a, then b | (1, a), then (1, b) |
| 2 | a, then b | (2, a), then (2, b) |
| 3 | a, then b | (3, a), then (3, b) |
A Cartesian product has m multiplied by n pairs when the input lengths are m and n, so check the sizes before storing a large result.
The iterables do not need to be lists. A range can supply numbers, a tuple can supply fixed choices, and a string supplies one character at a time. Pick the iterable that describes the values the expression actually needs.
A string is iterated character by character, so a word used as the inner iterable creates a separate result for each letter. Wrap the whole word in a collection if each result should contain the word as one value.
How to Write Double Iteration in a List Comprehension
The example below compares pair generation, filtering, flattening, and nested rows in one script.
Step 1: Put the outer loop before the inner loop
The pair expression stores both current values as one tuple. I kept the inputs small because the terminal capture shows every pair without clipping, which makes the order visible.
numbers = [1, 2, 3]
letters = ["a", "b"]
pairs = [(number, letter) for number in numbers for letter in letters]
filtered_pairs = [
(number, letter)
for number in numbers
for letter in letters
if number != 2 or letter != "b"
]
matrix = [[1, 2], [3, 4]]
flat = [value for row in matrix for value in row]
doubled_rows = [[value * 2 for value in row] for row in matrix]
print("All pairs:", pairs)
print("Filtered pairs:", filtered_pairs)
print("Flattened values:", flat)
print("Doubled rows:", doubled_rows)
Run the saved file with this command:
python3 double_iteration_demo.py
The command prints these exact results:
All pairs: [(1, 'a'), (1, 'b'), (2, 'a'), (2, 'b'), (3, 'a'), (3, 'b')]
Filtered pairs: [(1, 'a'), (1, 'b'), (2, 'a'), (3, 'a'), (3, 'b')]
Flattened values: [1, 2, 3, 4]
Doubled rows: [[2, 4], [6, 8]]
The output includes the pair list and filtered pairs alongside both result shapes.
Step 2: Choose between flat values and nested rows
The flattening expression emits each value into one list and preserves the row order. I used row and value as separate loop targets so each source level stays visible.
The doubled-rows line places a list comprehension in its result expression, so it creates a list of transformed rows.
Keep rows when later code relies on grouping. Flatten them when the next operation treats every value alike.
Step 3: Add a filter after the loops
filtered = [(a, b) for a in [1, 2] for b in [1, 2] if a != b]
adjusted = [(a, b) if a < b else (b, a) for a in [1, 2] for b in [1, 2]]
After the loops set their targets, a trailing if tests each candidate and skips it when the condition is false. An if-else expression instead selects the value for each candidate and keeps one output per pair.
That distinction matters when later code expects a particular number of results. For compound conditions, put related tests in parentheses and split long expressions across lines. Use named loops if the condition becomes harder to follow than the transformation itself.
Common Errors with Double Iteration
Use this table to distinguish an empty result or unpacking failure from an incorrect loop target.
| Case | Symptom | Fix |
|---|---|---|
| One iterable is empty | The comprehension returns an empty list because no complete pair reaches the expression | Inspect both inputs. An empty result is expected when either has no values. |
| An item does not match an unpacking target | Python raises an unpacking error when the item has a different number of values than the target expects | Inspect one source item, then correct the target or bind the whole item to one name. |
| Both clauses reuse the same loop-target name | The inner loop assigns that name again, so the expression cannot refer to the outer value through it | Give the outer and inner targets distinct names. |
When Should You Use Nested Loops Instead?
Choose named loops when a pass needs several actions or side effects because each step stays visible.
- Pairs by position or choice. Use zip for items that match by position, or Python’s combinations iterator for unique unordered pairs without self-pairs.
- Large output. A list comprehension stores all results. A generator expression yields values on demand when the next operation accepts an iterable. Benchmark the whole task before claiming one form is faster.
- Uneven rows. Flattening can collect every available value, while indexing each row at a fixed position requires that position to exist in every row.
- Long conditions. Parentheses and line breaks can make a compound filter clearer when you review the examples it should keep or remove.
Conclusion: Read the Clauses as Nested Loops
Before passing the list to the next operation, check its first few values against the intended result. This catches a wrong order or shape while the source expression stays in view.
For more on the building block, see AskPython’s list comprehension guide. The Python list iteration guide covers other ways to visit items, and the Python tutorial documents the comprehension syntax.
FAQ
These quick answers cover common questions about two-loop comprehensions.
Can a list comprehension have two for clauses?
Yes. Each for clause adds a loop, and the clauses run in the order they are written, like nested for loops.
How do you flatten a list of lists with a comprehension?
Place a for clause for each row and then a for clause for each value in that row. The expression emits each value into one flat list.
Can you add an if condition after two for clauses?
Yes. Put the filter after the for clauses, so its condition can use variables assigned by those loops.
Are list comprehensions faster than nested for loops?
There is no universal result for every task. Compare the same operation on representative inputs if performance matters, and choose the clearer form when speed is not a measured issue.
