Python Comprehensions Exercises: list, dict, set, generator comprehensions exercises

squares = [n ** 2 for n in range(1, 21)]

print(squares)
# [1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361, 400]Code language: Python (python)

Explanation:

• [n ** 2 for n in range(1, 21)]: The three parts of a list comprehension are the output expression (n ** 2), the loop variable (n), and the iterable (range(1, 21)). Python evaluates the expression for each value of n and collects all results into a new list in one step.
• range(1, 21): Generates integers from 1 up to but not including 21, so the last value is 20. This is a common off-by-one point: the stop argument is always exclusive in Python ranges.
• Equivalent loop: The comprehension replaces three lines — squares = [], a for loop, and squares.append(n ** 2) — with a single expression. Both produce identical results, but the comprehension communicates intent more directly: “a list of squares.”
• Performance: List comprehensions are generally faster than equivalent append loops in CPython because the interpreter can optimise the internal list-building operation. For most code the difference is negligible, but the readability benefit alone justifies preferring comprehensions for straightforward transformations.

numbers = [3, 7, 2, 14, 9, 8, 11, 6, 5, 10]

evens = [n for n in numbers if n % 2 == 0]

print(evens)   # [2, 14, 8, 6, 10]Code language: Python (python)

Explanation:

• if n % 2 == 0: The condition is evaluated for every element before the output expression is applied. When it is True the element passes through; when it is False the element is silently skipped. The output expression and the filter condition are independent — you can transform and filter in the same comprehension.
• Order of clauses: In a list comprehension the order is always: [expression for variable in iterable if condition]. The if clause comes last and acts as a gate. Placing the condition before the for keyword (as in a Python ternary expression) would mean something different — it would be a conditional expression on the output value, not a filter.
• Original order preserved: The output list contains elements in the same order they appeared in the input. Unlike a set, a list comprehension does not sort or deduplicate — it simply iterates and selects.
• Equivalent loop: This replaces evens = []; for n in numbers: if n % 2 == 0: evens.append(n). The comprehension version is not only shorter but also signals the reader immediately that the result is a filtered subset of the input.

words = ["python", "list", "comprehension", "is", "powerful"]

lengths = [len(word) for word in words]

print(lengths)   # [6, 4, 13, 2, 8]Code language: Python (python)

Explanation:

• len(word): Called once per element, it returns the number of characters in the string. Because len() accepts any sequence, the same comprehension pattern works unchanged if the input list contained tuples, sub-lists, or any other sized objects.
• Positional correspondence: The output list has exactly the same number of elements as the input and in the same order. lengths[0] is the length of words[0], and so on. This one-to-one mapping is guaranteed by list comprehensions when there is no if filter clause.
• Pairing with zip(): To display word-length pairs side by side you can write list(zip(words, lengths)), which produces [('python', 6), ('list', 4), ...]. Alternatively, [(word, len(word)) for word in words] produces the same result in a single comprehension.
• Real-world use: Projecting a list of objects onto a property is one of the most common comprehension patterns: extracting email addresses from a list of user dictionaries, pulling timestamps from log entries, or converting a list of file paths to their base names with os.path.basename().

fruits = ["apple", "banana", "cherry", "date", "elderberry"]

uppercased = [fruit.upper() for fruit in fruits]

print(uppercased)   # ['APPLE', 'BANANA', 'CHERRY', 'DATE', 'ELDERBERRY']
print(fruits)       # ['apple', 'banana', 'cherry', 'date', 'elderberry'] -- unchangedCode language: Python (python)

Explanation:

• fruit.upper(): Calls the str.upper() method on each element. Python strings are immutable, so upper() always returns a brand-new string rather than modifying the original. The comprehension collects these new strings into a new list.
• Original list unchanged: The comprehension creates a completely separate list object. Printing fruits after the comprehension confirms that the source data is unaffected. This is a key property to understand: comprehensions are non-destructive by design.
• Method chaining in the expression: The output expression can chain multiple method calls: [fruit.strip().upper().replace("A", "@") for fruit in fruits] is valid and still reads as a single comprehension. Keep chaining reasonable to preserve readability.
• Generalising the pattern: Any string transformation method works the same way: .lower(), .title(), .strip(), .replace(). The same pattern also applies to objects: [user.get_full_name() for user in users] extracts a derived value from each object in a list.

matrix = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]

flat = [item for row in matrix for item in row]

print(flat)   # [1, 2, 3, 4, 5, 6, 7, 8, 9]Code language: Python (python)

Explanation:

• for row in matrix: The outer loop iterates over the three sublists. On the first pass row = [1, 2, 3], on the second row = [4, 5], and on the third row = [6, 7, 8, 9].
• for item in row: The inner loop iterates over every element within the current row. Each item is appended to the output list by the leading expression. The two for clauses together visit every element across all rows in order.
• Reading order vs. nesting order: A common point of confusion is that [item for row in matrix for item in row] reads left to right with the outermost loop first — the same order as the equivalent nested for loops written top to bottom. This is different from nested list comprehensions that generate lists of lists, where the inner comprehension is written inside square brackets.
• Jagged rows are handled automatically: Because the inner loop iterates over whatever is in row, sublists of different lengths work without any special handling. [4, 5] contributes two elements and [6, 7, 8, 9] contributes four, and the output reflects that naturally.

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

odd_squares = [n ** 2 for n in numbers if n % 2 != 0]

print(odd_squares)   # [1, 9, 25, 49, 81]Code language: Python (python)

Explanation:

• if n % 2 != 0: The filter is evaluated first for each element. Numbers where the remainder after dividing by 2 is not zero are odd. Even numbers (where n % 2 == 0) never reach the squaring step and are absent from the output entirely.
• Single-pass efficiency: The comprehension visits each element once, applies the condition, and computes the square only for those that pass. This is more efficient than first filtering into an intermediate list and then mapping a square operation over it, because no temporary list is created.
• Alternative odd check: n % 2 == 1 is equivalent to n % 2 != 0 for positive integers. For code clarity, n % 2 != 0 is preferred because it also correctly handles negative odd numbers (e.g., -3 % 2 is 1 in Python, but -3 % 2 != 0 is still True regardless of sign).
• Template for real-world use: The pattern [transform(x) for x in data if condition(x)] is one of the most reusable templates in Python. Examples include extracting discounted prices only for items in stock, converting only non-empty strings, or formatting only rows that meet a threshold – all expressible in a single readable line.

words = ["apple", "banana", "apple", "cherry", "banana", "apple", "date"]

frequency = {word: words.count(word) for word in set(words)}

print(frequency)
# {'apple': 3, 'banana': 2, 'cherry': 1, 'date': 1}  (key order may vary)Code language: Python (python)

Explanation:

• {word: words.count(word) for word in set(words)}: The dict comprehension syntax is {key_expr: value_expr for var in iterable}. Here the key is each unique word and the value is how many times that word appears in the original list. Using set(words) as the iterable ensures each word is processed exactly once as a key.
• words.count(word): Scans the entire list and returns the number of occurrences of word. It is called once per unique word, making the overall approach O(n * k) where n is the list length and k is the number of unique words.
• More efficient alternative – collections.Counter: from collections import Counter; Counter(words) produces the same result in a single O(n) pass and is the idiomatic tool for frequency counting in Python. The comprehension approach is shown here to demonstrate the dict comprehension pattern; use Counter in production code.
• Key order: From Python 3.7 onward, dictionaries maintain insertion order. However, set(words) is unordered, so the keys of frequency may appear in any sequence. To preserve the first-occurrence order of words from the original list, replace set(words) with dict.fromkeys(words), which yields unique words in their original order.

codes = {
    "USD": "US Dollar",
    "EUR": "Euro",
    "GBP": "British Pound",
    "JPY": "Japanese Yen",
}

inverted = {value: key for key, value in codes.items()}

print(inverted)
# {'US Dollar': 'USD', 'Euro': 'EUR', 'British Pound': 'GBP', 'Japanese Yen': 'JPY'}
print(codes)    # original unchangedCode language: Python (python)

Explanation:

• codes.items(): Returns a view of all key-value pairs as two-element tuples. Unpacking each pair into key, value in the for clause gives direct access to both components, making the swap in the expression natural to read.
• {value: key ...}: Places the original value on the left of the colon (making it the new key) and the original key on the right (making it the new value). The comprehension produces a fresh dictionary object — the original codes is untouched.
• Uniqueness requirement: Dictionary keys must be unique. If the original dict has duplicate values — for example, two currencies both named "Dollar" — the last one encountered during iteration wins and the earlier mapping is lost without any warning. Always verify value uniqueness before inverting.
• Hashability requirement: New keys must be hashable. Strings, numbers, and tuples are hashable; lists and dicts are not. If the original values are lists, a direct inversion will raise TypeError. In that case, convert values to tuples first: {tuple(v): k for k, v in d.items()}.

sentence = "the quick brown fox jumps over the lazy dog"

unique_vowels = {char for char in sentence if char in "aeiou"}

print(unique_vowels)   # {'a', 'e', 'i', 'o', 'u'} -- order may varyCode language: Python (python)

Explanation:

• {...} vs. [...]: Replacing the square brackets with curly braces changes the output from a list to a set. The rest of the syntax is identical. A set stores each unique value once, so even though the letter e appears many times in the sentence, it appears only once in the result.
• char in "aeiou": Python’s in operator tests membership in any iterable, including strings. This is equivalent to writing char == 'a' or char == 'e' or ... but far more concise. For case-insensitive matching, preprocess with sentence.lower() before the comprehension.
• Output order: Sets are unordered in Python. The printed representation may show the vowels in any sequence. If you need a sorted result, wrap the set in sorted(): sorted(unique_vowels) returns a list in alphabetical order.
• Distinguishing from a dict comprehension: Both dict and set comprehensions use curly braces. Python tells them apart by the colon: {k: v for ...} is a dict comprehension, while {expr for ...} without a colon is a set comprehension. An empty {} is always a dict, never an empty set — use set() for that.

squares_map = {n: n ** 2 for n in range(1, 11)}

print(squares_map)
# {1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81, 10: 100}

# O(1) lookup
print(squares_map[7])   # 49Code language: Python (python)

Explanation:

• {n: n ** 2 for n in range(1, 11)}: The key expression (n) and value expression (n ** 2) are separated by a colon, and both are evaluated for each item produced by range(1, 11). The result is a fully populated dictionary in a single line.
• Lookup table use case: Once built, squares_map[7] returns 49 instantly. If squaring were a slow operation — say, loading a pre-trained model result for each input — building the table once and reusing it would be a significant optimisation. This is the memoisation pattern applied manually.
• Key and value can be different expressions: The key and value expressions are entirely independent. You could write {n: n ** 3 for n in range(1, 11)} for cubes, or {n: f"square of {n} is {n**2}" for n in range(1, 11)} for a string-valued map. Any combination of hashable key expression and arbitrary value expression is valid.
• Filtering in a dict comprehension: Like list comprehensions, dict comprehensions accept an if clause: {n: n ** 2 for n in range(1, 11) if n % 2 == 0} produces a map of only the even numbers. The filter, loop, and key-value expressions all live in the same single-line structure.

fizzbuzz = [
    "FizzBuzz" if n % 15 == 0 else
    "Fizz"     if n % 3  == 0 else
    "Buzz"     if n % 5  == 0 else
    n
    for n in range(1, 51)
]

print(fizzbuzz)Code language: Python (python)

Explanation:

• Nested ternary as the output expression: Python evaluates the ternary chain from left to right, taking the first branch whose condition is true. Writing the expression across multiple indented lines does not change the logic — it only improves readability. The entire multi-line block before for n in range(1, 51) is still one expression.
• n % 15 == 0 must come first: A number divisible by 15 is also divisible by 3 and by 5. If n % 3 == 0 were tested first, multiples of 15 would match that branch and return "Fizz" instead of "FizzBuzz". Testing the most specific condition first prevents it from being swallowed by a less specific one.
• Mixed output types: The list contains both strings and integers. Python lists are heterogeneous, so this is valid. The integer fallback n is returned as-is rather than converted to a string — str(n) would make the list uniformly typed if that is preferred.
• Readability vs. cleverness: Nested ternaries inside comprehensions can become hard to parse quickly. For anything beyond three branches, a helper function is clearer: def fizzbuzz_label(n): ... called as [fizzbuzz_label(n) for n in range(1, 51)]. The comprehension stays clean and the logic lives in a testable, named function.

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9],
]

transposed = [[matrix[i][j] for i in range(3)] for j in range(3)]

print("Original:  ", matrix)
print("Transposed:", transposed)
# Transposed: [[1, 4, 7], [2, 5, 8], [3, 6, 9]]Code language: Python (python)

Explanation:

• Structure of the nested comprehension: [[inner] for j in range(3)] is the outer comprehension — it produces three rows. [matrix[i][j] for i in range(3)] is the inner comprehension — it produces the elements of each row by walking down column j across all original rows. The result is a list of lists, not a flat list.
• Flattening vs. nesting: Exercise 5 used [item for row in matrix for item in row] — two for clauses in one comprehension — to produce a flat list. Transposition uses [[inner] for outer] — an inner comprehension nested inside square brackets — to produce a list of lists. The placement of the inner brackets is the key structural difference.
• Generalising beyond 3×3: Replace the hardcoded 3 with len(matrix) and len(matrix[0]) to handle any rectangular matrix: [[matrix[i][j] for i in range(len(matrix))] for j in range(len(matrix[0]))].
• Built-in alternative: list(map(list, zip(*matrix))) is the idiomatic one-liner for transposition. zip(*matrix) unpacks the rows as arguments to zip, which groups elements by column position, and map(list, ...) converts each zip tuple to a list. The comprehension approach is shown here because it makes the row-column index logic explicit.

xs = [1, 2, 3]
ys = ["a", "b", "c"]

product = [(x, y) for x in xs for y in ys]

for pair in product:
    print(pair, end="  ")

# (1, 'a')  (1, 'b')  (1, 'c')  (2, 'a')  (2, 'b')  (2, 'c')  (3, 'a')  (3, 'b')  (3, 'c')Code language: Python (python)

Explanation:

• for x in xs for y in ys: Two for clauses in a single comprehension produce the same result as two nested for loops. The left-most loop is outermost: x takes the value 1 while y cycles through "a", "b", "c"; then x advances to 2, and so on. The total number of pairs is len(xs) * len(ys).
• Tuple output expression: (x, y) creates a tuple for each combination. Tuples are the natural container for fixed-size heterogeneous pairs. If you need a list of lists instead, replace (x, y) with [x, y].
• Adding a filter: You can exclude certain pairs with an if clause: [(x, y) for x in xs for y in ys if x != 2] omits all pairs where x is 2. The condition can reference both loop variables, making it possible to enforce diagonal or relational constraints.
• When to use itertools.product: For two lists the comprehension is perfectly clear. For three or more lists, itertools.product(xs, ys, zs) is cleaner and avoids deeply nested for clauses. It also works lazily, which matters when the product is very large.

strings = ["abc123", "hello", "42px", "year2024", "no-digits"]

digits = [char for s in strings for char in s if char.isdigit()]

print(digits)   # ['1', '2', '3', '4', '2', '4', '2', '0', '2', '4']Code language: Python (python)

Explanation:

• for s in strings: The outer loop visits each string in the input list. Strings with no digits — like "hello" and "no-digits" — contribute zero elements to the output because none of their characters pass the if condition. The comprehension handles sparse input gracefully without any special-case logic.
• for char in s: The inner loop iterates over every character in the current string. Python strings are iterable sequences of single-character strings, so this works without any explicit indexing or slicing.
• char.isdigit(): Returns True for characters that represent a digit. For standard ASCII input this is equivalent to checking char in "0123456789". The result characters are kept as single-character strings — convert with int(char) in the output expression if you need integers: [int(char) for s in strings for char in s if char.isdigit()].
• Three-clause comprehension pattern: [expr for outer in collection for inner in outer if condition] is the general template for simultaneously flattening and filtering a nested structure. It combines the techniques from Exercise 5 (flattening with two for clauses) and Exercise 2 (filtering with an if clause) into one expression.

groups = [[1, 2, 3], [-1, 4, 5], [6, 7, 8], [0, 9, 10], [-3, -1, 2], [4, 5, 6]]

all_positive = [group for group in groups if all(n > 0 for n in group)]

print(all_positive)   # [[1, 2, 3], [6, 7, 8], [4, 5, 6]]Code language: Python (python)

Explanation:

• all(n > 0 for n in group): The argument to all() is a generator expression that yields True or False for each element. all() short-circuits on the first False it encounters, so it stops iterating as soon as a non-positive number is found — making it efficient for sub-lists that fail early.
• Output expression is the whole sub-list: The output expression is simply group, not any transformation of it. The comprehension acts purely as a filter — it decides whether each sub-list is included, not how it looks. This is the same [x for x in data if condition] form from Exercise 2, applied one level up in a nested structure.
• all() on an empty sub-list: By mathematical convention, all() returns True for an empty iterable (vacuous truth). This means an empty list [] would pass the filter and appear in the output. Add and group to the condition — if group and all(n > 0 for n in group) — if you want to exclude empty sub-lists.
• Counterpart with any(): Replacing all() with any() keeps sub-lists where at least one element is positive. The two built-ins cover the two most common whole-group conditions and eliminate the need for manual flag variables or nested loops.

scores = {
    "Alice":   82,
    "Bob":     45,
    "Charlie": 91,
    "Diana":   37,
    "Eve":     55,
    "Frank":   49,
}

passed = {name: score for name, score in scores.items() if score >= 50}

print(passed)   # {'Alice': 82, 'Charlie': 91, 'Eve': 55}Code language: Python (python)

Explanation:

• scores.items(): Returns all key-value pairs as (name, score) tuples. Unpacking into two variables in the for clause gives direct, readable access to both the key and the value — avoiding the less clear pattern of looking up the value separately with scores[name].
• if score >= 50: The condition is evaluated against the value (score), but it could reference the key, the value, or both. For example, if score >= 50 and name != "Eve" would additionally exclude Eve. The full key-value context is available throughout the comprehension.
• Original dictionary unchanged: Like all comprehensions, this produces a new dictionary object. The original scores dict is unmodified, so you can derive multiple filtered views from the same source without any risk of data loss.
• Transforming the value in the same step: You can filter and transform simultaneously: {name: score - 50 for name, score in scores.items() if score >= 50} produces a dict of passing margins. The key expression, value expression, and filter condition are all independent and can each be as complex as needed.

keys   = ["name", "age", "city", "email"]
values = ["Alice", 30, None, None]

record = {k: (v if v is not None else "N/A") for k, v in zip(keys, values)}

print(record)
# {'name': 'Alice', 'age': 30, 'city': 'N/A', 'email': 'N/A'}Code language: Python (python)

Explanation:

• zip(keys, values): Pairs elements at the same index from both lists, producing ("name", "Alice"), ("age", 30), ("city", None), ("email", None). Unpacking each pair into k, v in the for clause gives clean named access to both. zip() stops at the shorter list if the two differ in length.
• v if v is not None else "N/A": This is a ternary expression used as the value side of the dict comprehension. When v holds an actual value — including 0, False, or an empty string — it is kept as-is. Only the literal None is replaced. Using is not None instead of a truthiness check (if v) is important here: 0 and False are falsy but should not be replaced with "N/A".
• Shorter alternative with or: v or "N/A" is a tempting shortcut, but it replaces any falsy value — including 0, False, and empty strings — not just None. This is almost always the wrong behaviour for missing-data substitution. The explicit ternary with is not None is safer and communicates intent clearly.
• Building records from CSV rows: This pattern scales directly to CSV parsing: headers comes from the first row and row_values from each subsequent row. A dict comprehension with zip turns each row into a named record, which can then be appended to a list or passed to downstream processing.

list_a = [1, 2, 3, 4, 5, 3, 2]
list_b = [3, 4, 5, 6, 7, 4, 5]

common = {n for n in list_a if n in list_b}

print(common)   # {3, 4, 5}

# Built-in equivalent for comparison
print(set(list_a) & set(list_b))   # {3, 4, 5}Code language: Python (python)

Explanation:

• {n for n in list_a if n in list_b}: Iterates over every element of list_a and includes it in the output set only if it also exists in list_b. The set container automatically discards duplicates, so even though 3 and 2 each appear twice in list_a, only one copy of each can ever be in the result.
• n in list_b — performance note: Checking membership in a list is O(n) — Python scans from the start until it finds a match or exhausts the list. For a short list_b this is fine, but for thousands of elements the quadratic behaviour becomes noticeable. Replacing list_b with set(list_b) reduces each membership test to O(1).
• Built-in intersection: set(list_a) & set(list_b) produces the same result using Python’s optimised set intersection algorithm in O(min(len(a), len(b))) time. Prefer this in production code. The comprehension form is shown here because it makes the filter logic explicit and is easier to extend — for example, adding a second condition such as if n in list_b and n > 2.
• Difference and union with comprehensions: Set difference (elements in A but not B) is {n for n in list_a if n not in list_b}. Union (elements in either) is harder to express purely as a comprehension — the built-in set(list_a) | set(list_b) is clearer and more efficient for that case.

sentence = "comprehension makes python powerful"

repeated = {char for char in sentence if char != " " and sentence.count(char) > 1}

print(sorted(repeated))   # sorted for consistent display
# e.g. ['e', 'h', 'i', 'n', 'o', 'p', 's']Code language: Python (python)

Explanation:

• sentence.count(char) > 1: str.count() scans the entire string and returns how many times the substring appears. Calling it inside the comprehension condition means it is invoked once per unique character position — so for a sentence with 35 characters it is called 35 times. For short strings this is perfectly acceptable; for very long text, precompute a Counter first and look up counts in O(1).
• char != " ": Explicitly excludes the space character, which typically appears many times in a sentence. This condition can be extended with char.isalpha() to also exclude punctuation and digits if you want only letter characters.
• Set deduplication does the heavy lifting: The comprehension visits every character in the sentence, including many repeats. Because the container is a set, each character that passes the filter is stored only once. There is no need to check whether the character is already in the result — the set handles that automatically.
• Efficient alternative with Counter: from collections import Counter; {char for char, count in Counter(sentence).items() if char != " " and count > 1} computes all character frequencies in a single O(n) pass and then filters the result. This avoids the repeated str.count() scans and is the recommended approach for longer strings.

import sys
import itertools

# Generator expression -- nothing is computed yet
gen = (n ** 2 for n in range(1, 1_000_001))

# Pull only the first 10 values
first_ten = list(itertools.islice(gen, 10))
print("First 10 squares:", first_ten)

# Memory comparison
gen_size  = sys.getsizeof(n ** 2 for n in range(1, 1_000_001))
list_size = sys.getsizeof([n ** 2 for n in range(1, 1_000_001)])

print(f"Generator size:  {gen_size:,} bytes")
print(f"List size:       {list_size:,} bytes")Code language: Python (python)

Explanation:

• Parentheses create a generator, brackets create a list: The only syntactic difference between (n ** 2 for n in range(...)) and [n ** 2 for n in range(...)] is the delimiter. The parentheses produce a generator object that holds a reference to the iteration state and the expression to evaluate — no computed values are stored. The brackets build a fully materialised list in memory immediately.
• itertools.islice(gen, 10): Pulls values from the generator one at a time until 10 have been retrieved, then stops. The generator is paused at that point — if you called islice(gen, 5) again on the same object, you would get squares 11 through 15 because the generator remembers where it was.
• sys.getsizeof(): Returns the memory footprint of the Python object itself in bytes. For the generator this is a fixed ~200 bytes regardless of how many values remain. For the list it scales with the number of elements — roughly 8 bytes per integer reference plus a small header, giving about 8 MB for one million integers.
• Practical guidance: Use a generator expression when you only need to iterate over the results once and do not need random access or a known length. Use a list comprehension when you need to index into the result, check its length, iterate it multiple times, or pass it to a function that requires a sequence rather than an iterator.

import itertools
def fibonacci():
    a, b = 1, 1
    while True:
        yield a
        a, b = b, a + b
limit = 200
result = list(itertools.takewhile(lambda n: n < limit, fibonacci()))
print(result)
# [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144]Code language: Python (python)

Explanation:

• yield a inside while True: Each time the caller requests the next value, execution resumes after the yield, updates a and b with the simultaneous assignment, and loops back to yield again. The simultaneous assignment a, b = b, a + b evaluates both right-hand sides before either variable is updated, so the old value of a is used correctly in the sum.
• itertools.takewhile(predicate, iterable): Pulls values from iterable one at a time. While the predicate returns True, the value is passed through to the caller. The moment the predicate returns False for any value, takewhile stops immediately — it does not check subsequent values. The stopping value itself is consumed and discarded.
• Separation of concerns: The generator knows only how to produce Fibonacci numbers. The takewhile knows only the stopping condition. Either can be swapped independently: change the limit without touching the generator, or reuse the generator with itertools.islice(fibonacci(), 20) to take a fixed count instead.
• Memory efficiency: At any moment, only the current a and b values exist in memory regardless of how many numbers have been yielded. Collecting the result with list() does allocate all qualifying values at once — if the limit is very large, consider processing them one at a time with a for loop over the takewhile iterator instead.

import itertools
def is_prime(n):
    if n < 2:
        return False
    for i in range(2, int(n ** 0.5) + 1):
        if n % i == 0:
            return False
    return True
# Stage 1: source numbers
numbers = (n for n in range(2, 101))
# Stage 2: filter primes
primes = (n for n in numbers if is_prime(n))
# Stage 3: format as strings
formatted = (f"Prime: {n}" for n in primes)
# Pull 10 values through the whole pipeline
result = list(itertools.islice(formatted, 10))
print(result)Code language: Python (python)

Explanation:

• Each stage wraps the previous one: numbers, primes, and formatted are three nested generator objects. Defining them creates no computation — each is just a description of what to do when values are requested. Only when islice pulls a value from formatted does the chain wake up: formatted asks primes for the next value, which asks numbers, which yields an integer, which is tested for primality, and if it passes, is formatted and returned.
• Single-pass, no intermediate storage: At any moment exactly one integer exists in the pipeline as it moves through the three stages. There is no list of all integers, no list of all primes — just the current value being evaluated. The memory footprint is O(1) regardless of the range size.
• is_prime as a helper function: The primality check is too complex for a single expression inside a generator condition, so it lives in a named function. This is good practice: keep generator expressions simple and delegate logic to named, testable helpers. The generator pipeline remains readable while the helper can be unit-tested independently.
• Extending the pipeline: Adding a fourth stage is as simple as writing another generator expression that references formatted. No existing stage needs to change. This open-ended composability — adding stages without modifying the pipeline — is the key architectural advantage over a loop-based approach where all stages are interleaved in one block of code.

csv_data = """name, age, city
Alice, 30, New York
Bob, 25, London
Charlie, 35, Tokyo
Diana, 28, Paris"""

lines = csv_data.strip().splitlines()[1:]   # skip header

rows = ([field.strip() for field in line.split(",")] for line in lines)

for row in rows:
    print(row)Code language: Python (python)

Explanation:

• splitlines()[1:]: splitlines() splits the string on newline characters and returns a list of lines without the newline characters themselves. Slicing with [1:] discards the header row so the generator only processes data rows. This list of lines is small and created once — the lazy evaluation happens in the generator expression that iterates over it.
• Nested list comprehension inside a generator expression: The outer structure (... for line in lines) is a generator expression — lazy, O(1) memory. The inner structure [field.strip() for field in line.split(",")] is a list comprehension — it fully evaluates one row at a time as the generator is consumed. This combination is idiomatic: the row-level list is small and finite, while the line-level iteration stays lazy.
• Field-level stripping: Applying .strip() to each individual field after splitting handles CSV files where values are padded with spaces around commas ("Alice, 30, New York"). Stripping only the whole line would leave leading spaces on fields after the first comma.
• Scaling to real files: Replace the string with an open file object and the same generator pattern works unchanged: rows = ([field.strip() for field in line.split(",")] for line in open("data.csv")). Python’s file objects are themselves lazy iterators, so the entire pipeline — open, iterate, split, strip — processes one line at a time with constant memory. For production CSV parsing with quoting and escaping, use the standard library’s csv.reader, which wraps the same lazy pattern.

from collections import defaultdict

words = ["eat", "tea", "tan", "ate", "nat", "bat", "tab"]

# Build the grouped dict using defaultdict
grouped = defaultdict(list)
for word in words:
    key = tuple(sorted(word))
    grouped[key].append(word)

# Convert to a regular dict for display
result = dict(grouped)
print(result)

# Show the comprehension approach -- demonstrates the key idea
# (last-write-wins, so groups are lost without defaultdict)
key_demo = {tuple(sorted(w)): w for w in words}
print("\nComprehension only (last word per group):")
print(key_demo)Code language: Python (python)

Explanation:

• tuple(sorted(word)): sorted(word) returns a list of the word’s characters in alphabetical order — the same list for every anagram in the group. Wrapping it in tuple() makes it hashable so it can be used as a dictionary key. For example, "eat", "tea", and "ate" all produce ('a', 'e', 't').
• Why a plain dict comprehension cannot group: A dict comprehension evaluates one key-value pair per iteration and stores the result immediately. If two iterations produce the same key, the second overwrites the first — there is no way to accumulate values under a shared key. defaultdict(list) solves this by initialising a new empty list automatically the first time a key is seen, allowing .append() to build up the group across multiple iterations.
• The comprehension’s role here: While defaultdict does the accumulation, the key insight — using tuple(sorted(word)) as a canonical fingerprint — is the comprehension-style thinking. This same key expression could power a groupby in a pipeline: itertools.groupby(sorted(words, key=lambda w: sorted(w)), key=lambda w: tuple(sorted(w))) achieves the same grouping lazily.
• Alternative with itertools.groupby: Sorting the word list by the canonical key first and then applying groupby produces the same groups lazily without a defaultdict: {k: list(v) for k, v in itertools.groupby(sorted(words, key=lambda w: tuple(sorted(w))), key=lambda w: tuple(sorted(w)))}. This is a genuine dict comprehension that groups correctly, because groupby has already collected consecutive equal-key items into groups before the comprehension runs.

import sys
import timeit
from collections import deque

N = 100_000
RUNS = 1000

# --- Memory comparison ---
list_comp = [x ** 2 for x in range(1, N + 1) if x % 2 == 0]
gen_expr  = (x ** 2 for x in range(1, N + 1) if x % 2 == 0)

print("--- Memory ---")
print(f"List  size: {sys.getsizeof(list_comp):,} bytes")
print(f"Gen   size: {sys.getsizeof(gen_expr):,} bytes")

# --- Construction time ---
list_build_time = timeit.timeit(
    lambda: [x ** 2 for x in range(1, N + 1) if x % 2 == 0],
    number=RUNS
)
gen_build_time = timeit.timeit(
    lambda: (x ** 2 for x in range(1, N + 1) if x % 2 == 0),
    number=RUNS
)

print("\n--- Construction time ({} runs) ---".format(RUNS))
print(f"List  build: {list_build_time:.4f}s")
print(f"Gen   build: {gen_build_time:.4f}s")

# --- Full iteration time ---
# List: iterate a pre-built list
list_iter_time = timeit.timeit(
    lambda: deque([x ** 2 for x in range(1, N + 1) if x % 2 == 0], maxlen=0),
    number=RUNS
)
# Generator: build and fully consume in the same call
gen_iter_time = timeit.timeit(
    lambda: deque((x ** 2 for x in range(1, N + 1) if x % 2 == 0), maxlen=0),
    number=RUNS
)

print("\n--- Full iteration time ({} runs) ---".format(RUNS))
print(f"List  iter:  {list_iter_time:.4f}s")
print(f"Gen   iter:  {gen_iter_time:.4f}s")Code language: Python (python)

Explanation:

• Memory: generator wins decisively: sys.getsizeof() on a list returns the size of the list object plus its internal pointer array — roughly 8 bytes per element. For 50,000 even-number squares that is around 400 KB. The generator object is a fixed ~200 bytes regardless of how many values it would produce, because it stores only the iteration state (the current position in range) and the expression to evaluate, not the values themselves.
• Construction time: generator wins: Creating a list comprehension computes all 50,000 squares immediately, allocates memory for them, and stores every result. Creating a generator expression takes microseconds because nothing is computed — it just records the recipe. This difference matters when the pipeline is set up many times but each instance is consumed partially or not at all.
• Full iteration time: list wins slightly: Once you need every value, a list is faster to iterate because its elements are stored contiguously in memory (cache-friendly) and Python’s list iterator is implemented in optimised C. A generator incurs a small per-value overhead from resuming the generator frame and re-evaluating the expression each time. The gap is modest — typically 10-30% slower for generators — but it is real and worth knowing.
• Decision guide: Use a generator expression when you need to iterate once, process a large or infinite sequence, or embed the expression inside a function like sum(), max(), or any() that consumes it in one pass. Use a list comprehension when you need to iterate multiple times, index by position, check the length, pass the result to a function that requires a sequence, or when the full result must be available before any downstream processing can begin.