Python Iterators and Generators Exercises

In Python, iterators and generators are tools that let you loop over data one item at a time without needing to load everything into memory at once. These are essential when dealing with large datasets or streams of data where memory efficiency is important.

An iterator is any object that implements the __iter__() and __next__() methods. It remembers its state and returns items one by one when next() is called, raising StopIteration when done.

A generator, on the other hand, is a special type of iterator that is defined using a function and the yield keyword. It simplifies the creation of iterators by managing the state internally and pausing/resuming execution automatically.

Consider the following question:

Which of the following best describes the difference between an iterator and a generator in Python?

What will the following code print?

def counter():
    i = 0
    while i < 3:
        yield i
        i += 1

gen = counter()
print(next(gen))
print(next(gen))

The following class intends to implement an iterator, but throws an error during iteration. Identify the correction needed.

class ReverseList:
    def __init__(self, data):
        self.data = data
        self.index = len(data)

    def __iter__(self):
        return self

    def next(self):
        self.index -= 1
        if self.index < 0:
            raise StopIteration
        return self.data[self.index]

for item in ReverseList([1, 2, 3]):
    print(item)

Which of the following generator functions creates an infinite sequence of even numbers starting from 0?

def evens():
    for i in range(0, 100, 2):
        yield i

def evens():
    i = 0
    while True:
        yield i
        i += 2

def evens():
    return [i for i in range(0, 100, 2)]

def evens():
    yield from range(0, 100, 2)

Which of the following generator functions mimics the behavior of the built-in enumerate() function?

def custom_enum(iterable):
    index = 0
    for item in iterable:
        yield index, item
        index += 1

def custom_enum(iterable):
    return [(i, x) for i, x in enumerate(iterable)]

def custom_enum(iterable):
    for i in range(len(iterable)):
        yield i, iterable[i]

def custom_enum(iterable):
    yield from enumerate(iterable)

Review the following generator function and determine what it yields:

def pairwise_sum(seq):
    for i in range(len(seq) - 1):
        yield seq[i] + seq[i + 1]

sums = list(pairwise_sum([10, 20, 30, 40]))

What is the value of sums?

You’re designing a data pipeline that processes streamed log lines. To avoid memory issues, you decide to implement it as a generator. Here's a partially completed function:

def log_stream(file_path):
    with open(file_path) as f:
        _____

Which of the following best completes the function so it yields lines one by one?

for line in f:
    yield line

yield from f.readlines()

return [line for line in f]

lines = f.read()
yield lines

You're working on a generator that yields the square of each number from a given list, but you want the function to stop if a square exceeds 100. Consider this function:

def limited_squares(nums):
    for num in nums:
        square = num ** 2
        if square > 100:
            break
        yield square

What is the result of running list(limited_squares([5, 8, 11]))?

You're simplifying a nested generator using yield from. Here's an existing setup:

def first():
    yield 1
    yield 2

def second():
    yield -1
    _____

Which of the following correctly fills in the blank to yield values from first()?

for i in first():
    yield i

yield first()

yield from first()

yield *first()

You are designing a function that reuses an iterator multiple times. Here's the current code:

def repeat_iterator(it):
    result1 = list(it)
    result2 = list(it)
    return result1, result2

nums = iter([1, 2, 3])
print(repeat_iterator(nums))

What will this function return?

You're building a custom iterator that returns characters of a string in reverse. Here's the incomplete implementation:

class ReverseString:
    def __init__(self, s):
        self.s = s
        self.index = len(s)

    def __iter__(self):
        return self

    def __next__(self):
        if self.index == 0:
            raise StopIteration
        self.index -= 1
        return self.s[self.index]

What will be the output of this code?

rev = ReverseString("abc")
print(list(rev))

You want to create a generator pipeline that filters even numbers and then doubles them. Which of the following accomplishes this correctly?

def double_gen(nums):
    for n in nums:
        if n % 2 == 0:
            yield n * 2

def double_gen(nums):
    return [n * 2 for n in nums if n % 2 == 0]

def double_gen(nums):
    yield from (n * 2 for n in nums if n % 2 == 0)

def double_gen(nums):
    yield [n * 2 for n in nums if n % 2 == 0]

You’re implementing a generator to track running totals as values are received. Here’s the partial function:

def running_total():
    total = 0
    while True:
        value = yield total
        total += value

What is the correct way to use this generator to send values into it?

gen = running_total()
gen.send(5)
gen.send(10)

gen = running_total()
next(gen)
gen.send(5)
gen.send(10)

gen = running_total()
gen.send(0)
gen.send(5)
gen.send(10)

gen = running_total()
gen.send(None)
gen.send(5)
gen.send(10)

You’re debugging a case where a generator expression is used inside a list comprehension. Examine the code below:

result = [x for x in (i for i in range(3))]

What will be stored in result?

You want to design a function that accepts multiple iterables and yields their elements one after another (like itertools.chain). Which implementation is valid?

def chain_iterables(*iterables):
    for iterable in iterables:
        yield iterable

def chain_iterables(*iterables):
    for iterable in iterables:
        for item in iterable:
            yield item

def chain_iterables(*iterables):
    yield from iterables

def chain_iterables(*iterables):
    yield from [item for iterable in iterables]