Iteration in Python

Question 1

What makes an object iterable? Give the simple AND Pythonic explanation, and give 3 examples.

Answer 1

Simple: Can be looped (iterated) over

Pythonic: Returns an iterator when passed to iter(), i.e. the object has dunder methods \_\_iter\_\_() and/or \_\_getitem\_\_() defined.

Examples: str, list, dict

iterable stuff
more on how iter() uses \_\_getitem\_\_()

Question 2

What is an iterator? Give the simple AND Pythonic explanation.

Answer 2

Simple: An iterable object that has two main actions:
* Returns data one item at a time
* Keeps track of current and visited items

Pythonic: An iterable object that implements the iterator protocol, i.e. defines \_\_next\_\_() and returns itself within \_\_iter\_\_()

Question 3

What is the purpose of \_\_next\_\_()?

Answer 3

It’s used by an iterator to:
* Define exactly how it will traverse through its stored values
* Return the next value in the iteration
* Keep track of which values have already been called
* Raise a StopIteration exception when no more values are available

Question 4

What’s one memory-related benefit of using iterators?

Answer 4

Iterators allow you to process the entire dataset one item at a time, which removes the need to store the entire dataset into memory.

Question 5

What are the functions of the 3 types of iterators?

Answer 5

1. Take stream of data, yield original data (classic iterator)
2. Take stream of data, transform original data and yield new data
3. Take no input data, yield results from a computation

Question 6

What does it mean when you get a StopIteration error when calling an iterator with next()?

Answer 6

The iterator object is consumed, i.e. it has iterated through all of its values and you’ll need to create another one if you want to perform another iteration.

Question 7

Implement a classic iterator that takes a sequence of values as an input and yields each value sequentially

Answer 7

create an iterator that takes a sequence of values at instantiation and is

class SequenceIterator:
    # store the sequence and set the index to 0 at initialization
    def \_\_init\_\_(self, sequence):
        self._sequence = sequence
        self._index = 0

    # per iterator protocol, iterators will always return itself in \_\_iter\_\_()
    def \_\_iter\_\_(self):
        return self

    # return the current value of the sequence and increment the index by 1
    # if index is incremented past the sequence, raise StopIteration
    def \_\_next\_\_(self):
        if self._index < len(self._sequence):
            item = self._sequence[self._index]
            self._index += 1
            return item
        raise StopIteration

Question 8

What does iter() do?

Answer 8

Calls an iterable object’s \_\_iter\_\_() method to return an iterator. If \_\_iter\_\_() doesn’t exist but \_\_getitem\_\_() does, it will return an iterator that calls \_\_getitem\_\_() with i = range(inf) until a StopIteration exception is raised

Question 9

T/F: An object isn’t iterable without \_\_iter\_\_() defined

Answer 9

False, as long as \_\_getitem\_\_() exists instead. If both don’t exist, then it’s True.

Question 10

Implement Python’s for loop using the iterator protocol

Answer 10

iterator = sequence.\_\_iter\_\_()

while True:
    try:
        # get the next item using \_\_next\_\_()
        item = iterator.\_\_next\_\_()
    except StopIteration:
        break
    else:
        # the loop's code goes here
        print(item)

Question 11

What does it mean when an iterator is lazy?

Answer 11

It means that an iterator will only calculate and/or return one value at a time. It is hugely efficient in terms of memory consumption because your code will only require memory for a single item at a time.

Question 12

How do you create an infinite iterator?

Answer 12

Create a normal iterator, but don’t include the StopIteration exception

Question 13

Which of Python’s abstract base classes (ABCs) can you inherit to more easily create custom iterators?

Answer 13

collections.abc.Iterator, which

Question 14

What is a generator function?

Answer 14

A unique function that returns a generator iterator and keeps track of its state with the yield keyword

Question 15

How do generator functions/expressions differ from custom iterable classes?

Question 16

Write a generator function that yields an infinite sequence of numbers, then state the built-in one from Python

Answer 16

def infinite_sequence():
    num = 0
    while True:
        yield num
        num += 1

itertools.count()

Question 17

How does the syntax differ between a generator expression and list comprehension?

Answer 17

Generator expression uses (), while list comprehension uses []

Question 18

What’s a downside of using generator expressions in place of list comprehension?

Answer 18

Since generator expressions are equivalent to creating a generator function and then calling it, there is added overhead of calling the function. Because of this, generator expressions are slightly slower than list comprehension

Question 19

T/F: Generator expressions are more performant than generator functions

Answer 19

False, expressions just allow you to define simple generators in a single line with an assumed yield at the end of each inner iteration

Question 20

How does yield work in a generator function?

Answer 20

When the generator from a generator function is called, the code within the function is executed up to the yield statement. The program then suspends the function, returns the yielded value to the caller, and then saves the state of the function (i.e. the local variables, instruction pointer, internal stack, and exception handling). When the generator is called again, the function continues off from yield until it hits another yield, or when StopIteration is returned

Question 21

What happens when you use return in a generator function?

Answer 21

It will stop the function execution completely. It’s useful if you want more control over function termination than just hitting StopIteration

Question 22

What are the main differences between yield and return?

Answer 22

• return stops the function execution completely, while yield suspends function execution
• return returns the entire output of a function, while yield returns a generator object
• yield keeps track of the state of the function execution, while return does not

Question 23

Explain what’s happening in the code below, assuming that is_palindrome(num) returns True or False depending on whether num is a palendrome:
~~~
def infinite_palindromes():
num = 0
while True:
if is_palindrome(num):
i = (yield num)
if i is not None:
num = i
num += 1
~~~
and you execute the code below:
~~~
pal_gen = infinite_palindromes()
for j in pal_gen:
print(f”current palendrome: {i}”)
digits = len(str(j))
pal_gen.send(10 ** (digits))
~~~

Answer 23

1. pal_gen is the generator returned by the infinite_palindromes() gen function.
2. pal_gen will find the next palindrome in the sequence, set variable i to the yielded result within the gen function with i = (yield num), and then yield the result as j in the for loop.
3. digits stores the number of digits in the current palindrome.
4. 10 ** digits is then sent back to pal_gen using .send() where i is now updated.
5. The gen function resumes execution, now with an updated num value.

current palendrome: 11
current palendrome: 111
current palendrome: 1111
current palendrome: 10101
current palendrome: 101101

Question 24

If pal_gen is a generator, what’s the difference between the following methods?
~~~
pal_gen.throw(ValueError(“We don’t like large palindromes!”))
~~~
and
~~~
pal_gen.close()
~~~

Answer 24

Both methods will cause the generator to finish, however .throw() will tell pal_gen to throw the given exception, while .close() will always tell pal_gen to throw StopIteration