Python Iterators and Generators Exercises: 30 Coding Problems with Solutions

def square_generator(n):
    for i in range(1, n + 1):
        yield i ** 2

for square in square_generator(5):
    print(square, end=" ")Code language: Python (python)

Explanation:

• def square_generator(n): Defines a generator function. The presence of yield anywhere in the body makes it a generator rather than a regular function.
• yield i ** 2: Pauses execution and sends the squared value to the caller. On the next iteration, execution resumes from the line after yield.
• range(1, n + 1): Generates integers from 1 to n inclusive. Without + 1, n itself would be excluded.
• end=" ": Passed to print() to separate values with a space instead of a newline, keeping all output on one line.

class EvenIterator:
    def __init__(self, limit):
        self.limit = limit
        self.current = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.current > self.limit:
            raise StopIteration
        value = self.current
        self.current += 2
        return value

for num in EvenIterator(10):
    print(num, end=" ")Code language: Python (python)

Explanation:

• __init__(self, limit): Sets up the iterator’s state. self.current tracks the next value to be returned, starting at 0.
• __iter__(self): Returns self, which satisfies Python’s requirement that an iterable object return an iterator when iter() is called on it.
• __next__(self): Returns the current even number and advances self.current by 2. This is called automatically by for loops and other iteration constructs.
• raise StopIteration: Signals to the for loop that there are no more values, causing iteration to end cleanly.

def custom_range(start, stop, step=1):
    current = start
    while current < stop:
        yield current
        current += step
for num in custom_range(2, 10, 2):
    print(num, end=" ")Code language: Python (python)

Explanation:

• def custom_range(start, stop, step=1): Defines the generator with a default step of 1, mirroring the signature of Python’s built-in range().
• current = start: Initializes the running counter outside the loop so it persists across yield calls.
• while current < stop: Continues yielding as long as the current value has not reached the stop boundary, which is excluded – consistent with built-in range() behaviour.
• current += step: Advances the counter after each yield. Placing this after yield ensures the current value is produced before being incremented.

class ReverseStringIterator:
    def __init__(self, text):
        self.text = text
        self.index = len(text) - 1
    def __iter__(self):
        return self
    def __next__(self):
        if self.index < 0:
            raise StopIteration
        char = self.text[self.index]
        self.index -= 1
        return char
for char in ReverseStringIterator("hello"):
    print(char, end=" ")Code language: Python (python)

Explanation:

• self.index = len(text) - 1: Sets the starting position to the last valid index of the string. For "hello" (length 5), this is index 4, pointing to 'o'.
• if self.index < 0: Once the index goes below zero, all characters have been yielded. Raising StopIteration cleanly ends the loop.
• char = self.text[self.index]: Retrieves the character at the current position before decrementing, ensuring the correct character is returned.
• self.index -= 1: Moves the pointer one step toward the beginning of the string on each call to __next__.

def vowel_filter(text):
    vowels = "aeiou"
    for char in text:
        if char.lower() in vowels:
            yield char

for vowel in vowel_filter("Hello, World!"):
    print(vowel, end=" ")Code language: Python (python)

Explanation:

• vowels = "aeiou": Stores all lowercase vowels in a string. Using a string for membership testing with in is concise and readable for small character sets.
• char.lower() in vowels: Converts the character to lowercase before checking, so both 'H' and 'h' are handled correctly without needing to list uppercase vowels separately.
• yield char: Produces only the characters that pass the filter condition. Non-vowel characters are silently skipped, demonstrating the generator-as-filter pattern.
• Generator advantage: Because this is a generator, it processes the string one character at a time without building an intermediate list – making it efficient for very long strings or streamed input.

n = 8
powers = (2 ** i for i in range(n))

for value in powers:
    print(value, end=" ")Code language: Python (python)

Explanation:

• (2 ** i for i in range(n)): A generator expression enclosed in parentheses. It behaves like a generator function with yield, but is written as a single expression. No list is built in memory.
• range(n): Produces exponents 0 through n – 1. Since 2 ** 0 = 1, the sequence correctly starts at 1.
• powers: Holds a generator object. The values are not computed until the for loop requests them, one at a time.
• Generator vs. list comprehension: Replacing the outer parentheses with square brackets would produce a list immediately. The generator version defers computation, which matters when n is very large.

def fibonacci(n):
    a, b = 0, 1
    for _ in range(n):
        yield a
        a, b = b, a + b

for num in fibonacci(8):
    print(num, end=" ")Code language: Python (python)

Explanation:

• a, b = 0, 1: Seeds the sequence with the first two Fibonacci values. Both variables persist in the generator’s local scope across every yield.
• yield a: Produces the current Fibonacci number and pauses execution. The next call to the generator resumes on the line immediately after this statement.
• a, b = b, a + b: Advances the sequence in one step. Python evaluates b and a + b simultaneously before assignment, so the old value of a is used in computing the new b.
• for _ in range(n): Limits output to exactly n values. The underscore is a convention indicating the loop variable itself is not needed inside the body.

def infinite_counter(start=1):
    current = start
    while True:
        yield current
        current += 1

for num in infinite_counter():
    if num > 5:
        break
    print(num, end=" ")Code language: Python (python)

Explanation:

• while True: Creates an unbounded loop inside the generator. Because execution pauses at yield each time, this does not cause an infinite loop in the traditional sense – the generator only advances when the caller requests the next value.
• yield current: Suspends the generator and hands the current count to the caller. The while True loop resumes only when next() is called again.
• if num > 5: break: Exits the for loop and closes the generator. Without a guard like this, the loop would run indefinitely and the program would never terminate.
• start=1: A default parameter makes the generator flexible. You can start counting from any number by passing a different value, e.g. infinite_counter(10).

numbers = [10, 20, 30]
iterator = iter(numbers)

while True:
    try:
        value = next(iterator)
        print(value, end=" ")
    except StopIteration:
        breakCode language: Python (python)

Explanation:

• iter(numbers): Calls numbers.__iter__() internally and returns an iterator object. Lists are iterable but not iterators themselves – this step produces the iterator that tracks position.
• next(iterator): Calls iterator.__next__() and returns the next value. Each call advances the internal pointer by one position.
• except StopIteration: break: When the list is exhausted, next() raises StopIteration. Catching it here exits the loop cleanly, which is exactly what a for loop does under the hood.
• What a for loop really does: The pattern iter() then repeated next() until StopIteration is precisely how Python implements every for loop. Writing it manually makes that mechanism explicit.

class FloatStepIterator:
    def __init__(self, start, stop, step):
        self.current = start
        self.stop = stop
        self.step = step

    def __iter__(self):
        return self

    def __next__(self):
        if self.current >= self.stop:
            raise StopIteration
        value = self.current
        self.current = round(self.current + self.step, 10)
        return value

for num in FloatStepIterator(0.0, 1.0, 0.25):
    print(num, end=" ")Code language: Python (python)

Explanation:

• self.current = start: Initializes the running position. Using start directly (rather than a separate index) makes float arithmetic straightforward and keeps the logic close to the custom range from Exercise 3.
• if self.current >= self.stop: Ends iteration when the current value reaches or passes stop, matching the exclusive upper bound of Python’s built-in range().
• round(self.current + self.step, 10): Floating-point addition can accumulate tiny errors (e.g. 0.1 + 0.2 = 0.30000000000000004). Rounding to 10 decimal places corrects this without affecting precision at normal step sizes.
• Why not use range() here: Python’s range() only accepts integers. This class fills that gap, and the same pattern can be extended to support negative float steps by adjusting the stop condition accordingly.

# Create the sample file
with open("sample.txt", "w") as f:
    f.write("Hello, World!\nPython is great.\nGenerators save memory.\n")

# Generator that reads the file line by line
def read_lines(filepath):
    with open(filepath, "r") as f:
        for line in f:
            yield line.rstrip("\n")

for line in read_lines("sample.txt"):
    print(line)Code language: Python (python)

Explanation:

• with open(filepath, "r") as f: Opens the file inside the generator using a context manager. The with block ensures the file is closed automatically, even if the caller stops iterating early.
• for line in f: File objects implement the iterator protocol natively. Python reads one line from disk per iteration, so only a single line occupies memory at any given moment.
• line.rstrip("\n"): Removes the trailing newline character that the file includes at the end of each line. Without this, each printed line would be followed by a blank line.
• Memory advantage: Calling f.readlines() would load every line into a list at once. This generator approach keeps memory usage flat – a 10 GB log file consumes no more memory than a 1 KB file.

# Create the sample CSV file
with open("data.csv", "w") as f:
    f.write("name,age,city\nAlice,30,New York\nBob,25,London\nCarol,35,Sydney\n")

# Generator that parses CSV rows as dictionaries
def csv_row_parser(filepath):
    with open(filepath, "r") as f:
        headers = next(f).strip().split(",")
        for line in f:
            values = line.strip().split(",")
            yield dict(zip(headers, values))

for row in csv_row_parser("data.csv"):
    print(row)Code language: Python (python)

Explanation:

• next(f): Advances the file iterator by one line and returns it. Calling this before the for loop consumes the header row so subsequent iterations only see data rows.
• zip(headers, values): Pairs each header with the corresponding value by position, producing tuples such as ('name', 'Alice'). Passing this to dict() builds the row dictionary in one step.
• .strip().split(","): strip() removes the trailing newline and any surrounding whitespace before split() separates the fields. Skipping strip() would leave "\n" attached to the last value of every row.
• Note on the standard library: Python’s csv.DictReader handles edge cases such as quoted commas and escaped characters. This manual implementation is intentionally simplified to illustrate the underlying pattern rather than replace csv.DictReader in production code.

def number_producer(iterable):
    for item in iterable:
        yield item

def squarer(iterable):
    for num in iterable:
        yield num ** 2

numbers = [1, 2, 3, 4, 5]
pipeline = squarer(number_producer(numbers))

for value in pipeline:
    print(value, end=" ")Code language: Python (python)

Explanation:

• number_producer(iterable): A pass-through generator that yields each item from any iterable unchanged. In a real pipeline this stage would typically filter or transform the source data before passing it on.
• squarer(iterable): Accepts any iterable – including another generator – and yields the square of each value. Because it takes an iterable as input, it is decoupled from the source and can be reused with any producer.
• squarer(number_producer(numbers)): Composes the two generators without executing either. This is lazy composition: no computation happens until the for loop calls next() on pipeline.
• Pipeline scalability: Additional transformation stages can be added by wrapping further generators around pipeline. Each stage processes one value at a time, so the total memory used stays constant regardless of how many stages exist.

def flatten(nested):
    for item in nested:
        if isinstance(item, list):
            yield from flatten(item)
        else:
            yield item

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

for value in flatten(nested):
    print(value, end=" ")Code language: Python (python)

Explanation:

• isinstance(item, list): Checks whether the current item is itself a list. If it is, the function recurses into it. If it is not, the item is a plain value and is yielded directly.
• yield from flatten(item): Delegates to a recursive generator call. Every value the inner call yields is passed straight through to the outermost caller, without needing a loop to collect and re-yield each one manually.
• Arbitrary depth: Because each nested list triggers a new recursive call, the function handles any level of nesting automatically. A three-level nest such as [1, [2, [3, 4]]] is flattened with the same code as a one-level nest.
• yield from vs. a manual loop: Without yield from, you would need for v in flatten(item): yield v. The yield from syntax is not just shorter – it also correctly forwards send() values and exceptions into the sub-generator, which the manual loop cannot do.

def batch(iterable, batch_size):
    items = list(iterable)
    for i in range(0, len(items), batch_size):
        yield items[i : i + batch_size]

for chunk in batch(range(1, 11), 3):
    print(chunk)Code language: Python (python)

Explanation:

• items = list(iterable): Materialises the iterable into a list so it can be sliced by index. This is necessary because generators and other one-shot iterables do not support slicing directly.
• range(0, len(items), batch_size): Produces starting indices 0, 3, 6, 9, … stepping by batch_size. Each index marks the beginning of one chunk.
• items[i : i + batch_size]: Python slicing never raises an IndexError when the upper bound exceeds the list length. The final chunk ([10] in this example) is returned as a shorter slice automatically.
• Practical use: In real applications, each yielded chunk might be sent as a single bulk API request, inserted as one database transaction, or written as one file segment – making the batch size easy to tune without changing the processing logic.

def prime_sieve(limit):
    is_prime = [True] * (limit + 1)
    is_prime[0] = is_prime[1] = False

    for i in range(2, int(limit ** 0.5) + 1):
        if is_prime[i]:
            is_prime[i * i :: i] = [False] * len(is_prime[i * i :: i])

    for i in range(2, limit + 1):
        if is_prime[i]:
            yield i

for prime in prime_sieve(30):
    print(prime, end=" ")Code language: Python (python)

Explanation:

• is_prime = [True] * (limit + 1): Allocates a boolean lookup table indexed by number. Every candidate starts as assumed prime; the sieve progressively marks composites as False.
• range(2, int(limit ** 0.5) + 1): The outer loop only needs to run up to the square root of the limit. Any composite number must have at least one factor at or below its square root, so all composites are guaranteed to be marked before this loop ends.
• is_prime[i * i :: i] = [False] * ...: Slice assignment marks every multiple of i starting from i² in a single operation. Smaller multiples such as 2i and 3i were already marked by earlier primes, so starting at i² avoids redundant work.
• Two-phase design: The sieve marks composites first, then a second loop yields surviving primes. The yield appears only in the second loop, so the generator produces output only after the full table is built – a deliberate trade-off of latency for correctness.

def running_average(iterable):
    total = 0
    count = 0
    for value in iterable:
        total += value
        count += 1
        yield total / count

numbers = [10, 20, 30, 40, 50]

for avg in running_average(numbers):
    print(avg, end=" ")Code language: Python (python)

Explanation:

• total = 0 and count = 0: Both accumulators are declared before the loop. Because they live in the generator’s local scope, their values survive across yield calls and are available on every subsequent iteration.
• total += value and count += 1: Updated before yielding so the average includes the current value. Swapping the order – yielding before updating – would produce a one-step-behind average.
• yield total / count: Python 3’s / operator always returns a float, so the output is 10.0 rather than 10 even for whole-number averages. This is consistent with the expected output and avoids surprises when the average is not a whole number.
• Stateful processing without storage: Only two scalar variables are kept in memory regardless of how many numbers have been processed. Storing all values to recalculate the average from scratch each time would use O(n) memory and O(n) time per step.

def sliding_window(sequence, n):
    items = list(sequence)
    for i in range(len(items) - n + 1):
        yield tuple(items[i : i + n])

sequence = [1, 2, 3, 4, 5]

for window in sliding_window(sequence, 3):
    print(window, end=" ")Code language: Python (python)

Explanation:

• items = list(sequence): Materialises the input into a list so it can be accessed by index and sliced. Without this step, a one-shot iterable such as a generator passed as sequence would be exhausted after the first access.
• range(len(items) - n + 1): Calculates exactly how many full windows fit. For a 5-element list with window size 3, this gives range(3), producing starting indices 0, 1, and 2 – corresponding to the three valid windows.
• tuple(items[i : i + n]): Slices out the window and converts it to a tuple. Tuples signal that the window is a fixed-size, ordered snapshot rather than a mutable collection, which is the conventional output type for windowed data.
• Standard library alternative: From Python 3.12 onward, itertools.sliding_window(iterable, n) provides the same behaviour. This implementation makes the underlying index arithmetic explicit and works on all Python 3 versions.

# Create the sample log file
log_content = (
    "INFO: Server started\n"
    "ERROR: Disk quota exceeded\n"
    "INFO: Request received\n"
    "ERROR: Database connection failed\n"
    "WARNING: High memory usage\n"
)
with open("app.log", "w") as f:
    f.write(log_content)

# Generator that yields only ERROR lines
def error_filter(filepath, keyword="ERROR"):
    with open(filepath, "r") as f:
        for line in f:
            line = line.strip()
            if keyword in line:
                yield line

for entry in error_filter("app.log"):
    print(entry)Code language: Python (python)

Explanation:

• keyword="ERROR": A default parameter makes the generator reusable for any keyword – pass keyword="WARNING" and the same function filters for warnings instead. No code changes are needed for different log levels.
• line = line.strip(): Removes both the trailing newline and any leading or trailing whitespace before the membership check and before yielding. Without this, printed output would include blank lines between entries.
• if keyword in line: A simple substring check. Only lines that contain the keyword are yielded; all others are silently skipped. This is the generator-as-filter pattern from Exercise 5 applied to file input.
• Pipeline readiness: Because the generator yields individual strings, it can be piped directly into another generator – for example, one that extracts timestamps or counts occurrences – without any changes to this stage.

def unique(iterable):
    seen = set()
    for item in iterable:
        if item not in seen:
            seen.add(item)
            yield item

items = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]

for value in unique(items):
    print(value, end=" ")Code language: Python (python)

Explanation:

• seen = set(): An empty set initialised before the loop. It persists across yields in the generator’s local scope, accumulating every element that has been produced so far.
• if item not in seen: Set membership testing runs in O(1) average time because sets use hash-based lookup. Checking the same condition against a list would take O(n) time per element, making the overall algorithm O(n²).
• seen.add(item) then yield item: The item is recorded before being yielded. If the caller stopped iterating early (e.g., with break), any items added to seen up to that point would still correctly block duplicates if iteration resumed later via next().
• Order preservation: Unlike converting to a set directly – which loses insertion order – this generator yields items in the order they first appear. From Python 3.7 onward, dict.fromkeys(iterable) also preserves order, but the generator approach works element by element without materialising any intermediate collection.

def accumulator():
    total = 0
    while True:
        value = yield total
        if value is None:
            break
        total += value

acc = accumulator()
next(acc)  # prime the coroutine

print(acc.send(10), end=" ")  # 10
print(acc.send(20), end=" ")  # 30
print(acc.send(30), end=" ")  # 60Code language: Python (python)

Explanation:

• value = yield total: A two-directional yield. The expression to the right of yield is sent out to the caller as the generator’s current output. The value sent back in via .send() is assigned to value on the left-hand side when the generator resumes.
• next(acc): Primes the coroutine by advancing it to the first yield. At this point total is 0, so the generator pauses and returns 0. The return value is discarded here because we have not sent any data yet.
• acc.send(10): Resumes the generator and assigns 10 to value. The loop adds it to total, making total = 10, then reaches yield total again, pausing and returning 10 to the caller.
• if value is None: break: A clean shutdown guard. Calling acc.send(None) or next(acc) after the coroutine is primed sets value to None, which exits the loop and allows the generator to terminate gracefully via StopIteration.

def custom_zip(iterable_a, iterable_b):
    iter_a = iter(iterable_a)
    iter_b = iter(iterable_b)
    while True:
        try:
            item_a = next(iter_a)
            item_b = next(iter_b)
        except StopIteration:
            return
        yield (item_a, item_b)

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

for pair in custom_zip(a, b):
    print(pair, end=" ")Code language: Python (python)

Explanation:

• iter_a = iter(iterable_a): Converts each input to a stateful iterator. This ensures the function accepts any iterable – lists, generators, strings, or custom classes – not just sequences that support indexing.
• try / except StopIteration: return: When either iterator runs out of values, next() raises StopIteration. Catching it and using return inside a generator is the idiomatic way to end iteration early – Python converts the return statement into a StopIteration that the caller receives.
• yield (item_a, item_b): Produces one paired tuple per loop iteration. The yield is placed after both next() calls succeed, guaranteeing that a partial tuple is never emitted if the second iterator is shorter than the first.
• Shortest-iterable behaviour: If a has 3 elements and b has 2, the generator stops after 2 pairs – exactly like built-in zip(). For longest-iterable behaviour, Python offers itertools.zip_longest(), which fills missing values with a configurable default.

class Node:
    def __init__(self, value):
        self.value = value
        self.left = None
        self.right = None
    def insert(self, value):
        if value < self.value:
            if self.left is None:
                self.left = Node(value)
            else:
                self.left.insert(value)
        else:
            if self.right is None:
                self.right = Node(value)
            else:
                self.right.insert(value)
def inorder(node):
    if node is None:
        return
    yield from inorder(node.left)
    yield node.value
    yield from inorder(node.right)
root = Node(5)
for val in [3, 7, 2, 4, 6, 8]:
    root.insert(val)
for value in inorder(root):
    print(value, end=" ")Code language: Python (python)

Explanation:

• if node is None: return: The base case of the recursion. A plain return inside a generator raises StopIteration silently, so the caller never sees the None leaves – iteration simply ends for that branch.
• yield from inorder(node.left): Delegates all values from the left subtree directly to the outermost caller. Without yield from, a manual loop would be needed to re-yield each value, and send() and throw() semantics would be lost.
• yield node.value: Produces the current node’s value between the two recursive calls. In-order traversal visits left subtree first, then the node itself, then the right subtree – which for a BST always produces values in ascending sorted order.
• Why a generator, not a list: A list-based approach collects all values before returning, requiring O(n) extra memory. The generator yields each value as the recursion unwinds, meaning only the call stack depth (O(log n) for a balanced BST) is needed beyond the tree itself.

def throttle(iterable, n):
    for index, item in enumerate(iterable, start=1):
        if index % n == 0:
            yield item

data = list(range(1, 21))

for value in throttle(data, 4):
    print(value, end=" ")Code language: Python (python)

Explanation:

• enumerate(iterable, start=1): Pairs each item with a 1-based counter. Using start=1 means the first item has index 1, so the modulo check index % n == 0 correctly identifies the 4th, 8th, 12th, … elements rather than the 3rd, 7th, 11th.
• index % n == 0: The modulo operator returns the remainder of dividing index by n. A remainder of zero means the current position is an exact multiple of n, making it a keep position.
• Composability: Because throttle accepts any iterable, it can wrap a live sensor feed, a file reader, or another generator just as easily as a list. The upstream iterable is never fully materialised, keeping memory usage constant.
• Standard library alternative: itertools.islice(iterable, n-1, None, n) achieves the same result. The custom generator is more readable for this specific case and avoids importing itertools, but islice is preferable when working within a broader itertools pipeline.

def traffic_light():
    states = ["Green", "Yellow", "Red"]
    while True:
        for state in states:
            yield state

light = traffic_light()

for _ in range(6):
    print(next(light), end=" ")Code language: Python (python)

Explanation:

• states = ["Green", "Yellow", "Red"]: The ordered list of states defines the transition sequence. Changing this list is all that is needed to modify the machine’s behaviour – no logic elsewhere needs to change.
• while True wrapping for state in states: The inner for loop cycles through all states once; the outer while True restarts it immediately after the last state, producing an endless cycle. The generator never reaches a natural end.
• yield state: Pauses the generator and hands the current state to the caller. Execution resumes from this exact point on the next next() call, advancing to the following state in the sequence.
• for _ in range(6): next(light): Pulls exactly 6 states from the infinite generator. The caller controls how many transitions occur; the generator itself has no knowledge of when it will be stopped, which is the clean separation of concerns that makes this pattern reusable.

_SENTINEL = object()

class PeekableIterator:
    def __init__(self, iterable):
        self._iterator = iter(iterable)
        self._next = next(self._iterator, _SENTINEL)

    def __iter__(self):
        return self

    def peek(self):
        if self._next is _SENTINEL:
            raise StopIteration
        return self._next

    def __next__(self):
        if self._next is _SENTINEL:
            raise StopIteration
        value = self._next
        self._next = next(self._iterator, _SENTINEL)
        return value

data = [10, 20, 30, 40]
pit = PeekableIterator(data)

print("Peek:", pit.peek())
print("Consumed:", next(pit))
print("Peek:", pit.peek())
print("Consumed:", next(pit))
print("Consumed:", next(pit))
print("Consumed:", next(pit))Code language: Python (python)

Explanation:

• _SENTINEL = object(): A module-level sentinel is a unique object that can never appear as a legitimate value in the data stream. Comparing with is _SENTINEL is safe even when the iterable contains None, 0, or False, which would all cause a naive None-based sentinel to mis-fire.
• self._next = next(self._iterator, _SENTINEL): The two-argument form of next() returns the default value instead of raising StopIteration when the iterator is exhausted. This keeps the caching logic inside __init__ and __next__ free of try/except blocks.
• peek(): Returns self._next without advancing the iterator. Calling peek() any number of times between two next() calls always returns the same value, because nothing is consumed.
• __next__ re-primes immediately: After saving the current _next into value, the method fetches the following item from the underlying iterator before returning. This ensures _next always holds the upcoming value so peek() is always accurate.

def resilient_generator(values):
    for value in values:
        try:
            yield value
        except ValueError as e:
            print(f"Caught ValueError: {e} - skipping")

gen = resilient_generator([1, 2, 3])

print("Yielded:", next(gen))
print("Yielded:", next(gen))
print("Yielded:", gen.throw(ValueError, "simulated error"))
print("Generator finished")Code language: Python (python)

Explanation:

• try / except ValueError around yield: Wrapping the yield in a try block is what makes the generator resilient to .throw(). Without this, a thrown exception would propagate uncaught, terminating the generator immediately and raising the exception in the caller’s frame instead.
• gen.throw(ValueError, "simulated error"): Raises ValueError("simulated error") at the exact line where the generator is paused – inside the try block. The generator’s except clause handles it, prints the message, and the loop continues to the next iteration, yielding 3.
• Return value of .throw(): Like next(), .throw() returns the next value yielded by the generator after the exception is handled. Printing its return value directly captures 3 without needing a separate next() call.
• Practical use: In async frameworks such as asyncio, .throw() is used internally to cancel tasks by injecting a CancelledError into a suspended coroutine. Understanding .throw() demystifies how cancellation and timeout logic work beneath the async/await surface.

import os

# Build the test directory tree
os.makedirs("test_dir/subdir", exist_ok=True)
for filename in ["test_dir/file1.txt", "test_dir/file2.txt",
                  "test_dir/subdir/file3.txt", "test_dir/subdir/file4.txt"]:
    open(filename, "w").close()

# Recursive generator
def walk_files(directory):
    for entry in sorted(os.listdir(directory)):
        full_path = os.path.join(directory, entry)
        if os.path.isfile(full_path):
            yield full_path
        elif os.path.isdir(full_path):
            yield from walk_files(full_path)

for path in walk_files("test_dir"):
    print(path)Code language: Python (python)

Explanation:

• os.path.join(directory, entry): Constructs a platform-correct full path by combining the parent directory with the entry name. Using string concatenation instead would break on Windows, where the path separator is a backslash.
• yield full_path vs. yield from walk_files(full_path): Files are yielded directly; directories trigger a recursive call via yield from, which forwards every path produced by the deeper traversal to the outermost caller without any intermediate collection.
• sorted(os.listdir(...)): os.listdir() returns entries in filesystem order, which is not guaranteed to be alphabetical. Wrapping it in sorted() produces consistent, predictable output regardless of the underlying OS or filesystem.
• Standard library alternative: os.walk() and pathlib.Path.rglob("*") both provide recursive directory traversal out of the box. This implementation makes the yield from recursion pattern explicit; in production code, pathlib.Path.rglob() is generally preferred for its cleaner API.

def interleave(iterable_a, iterable_b):
    iter_a = iter(iterable_a)
    iter_b = iter(iterable_b)
    while True:
        try:
            yield next(iter_a)
        except StopIteration:
            yield from iter_b
            return
        try:
            yield next(iter_b)
        except StopIteration:
            yield from iter_a
            return

a = [1, 2, 3]
b = ["a", "b", "c", "d"]

for value in interleave(a, b):
    print(value, end=" ")Code language: Python (python)

Explanation:

• Two separate try/except blocks: Each iterator gets its own guard. This structure ensures that exhaustion of either iterator is caught at the precise moment it occurs – after yielding its last item – rather than at the top of the next loop iteration, which would silently drop one item from the other stream.
• yield from iter_b then return: When iter_a is exhausted, the remaining items in iter_b are drained in one step. return exits the generator cleanly immediately after, preventing the loop from continuing and attempting to read from the already-exhausted iterator again.
• Unequal length handling: Because the drain-and-return logic sits inside each except block independently, the generator correctly handles all three cases: both iterables the same length, iter_a shorter, and iter_b shorter – without any length checks upfront.
• Generalising to n streams: This two-stream approach extends naturally by storing iterators in a list and cycling through them with itertools.cycle, removing exhausted iterators as they raise StopIteration. That pattern underpins round-robin schedulers and multi-source merge utilities.

class FakeDatabase:
    def __init__(self, rows):
        self.rows = rows

    def connect(self):
        print("[DB] Connection opened")

    def disconnect(self):
        print("[DB] Connection closed")

    def fetch_rows(self):
        return iter(self.rows)

def db_row_generator(database):
    database.connect()
    try:
        for row in database.fetch_rows():
            yield row
    finally:
        database.disconnect()

db = FakeDatabase([("Alice", 30), ("Bob", 25), ("Carol", 35)])
gen = db_row_generator(db)

print("Row:", next(gen))
gen.close()Code language: Python (python)

Explanation:

• database.connect() before the try: The connection is opened before entering the try block because there is nothing to clean up if the connection itself fails. Only resources that have been successfully acquired need to be released in finally.
• try / finally around the yield loop: The finally clause runs unconditionally – whether the loop finishes normally, an exception propagates out, or the generator is closed early via .close(). This is the same guarantee provided by a with statement and its __exit__ method.
• gen.close(): Throws a GeneratorExit exception into the generator at its current yield point. The generator must not yield any further values in response – it should only clean up and return. The finally block executes, disconnect() is called, and the generator terminates.
• Relation to context managers: A generator decorated with @contextlib.contextmanager uses exactly this try/finally pattern to implement __enter__ and __exit__. Everything before the single yield runs on entry; the finally clause runs on exit, whether the with block raised an exception or completed normally.