Iterators, generators and decorators

Make a day18 folder for today’s files, open it in your editor, and run each script from its terminal, as on earlier days. A few programs read small text files; save each one into day18 beside the script, with the name shown.

Phase 4 is about the habits of programmers whose code other people rely on. It starts with three tools you have already used without seeing inside. Every for loop you have written follows a hidden two-step agreement; today you see it and make your own objects follow it. Day 11’s generator expressions have a bigger sibling, the generator function, which can produce an endless stream of values or work through a file far too big for memory. And Day 17’s @property was a decorator; today you find out what a decorator is by writing your own, which needs one more idea first: a function that remembers.

A for loop works on a list, a string, a dictionary, a range, a file, and a generator. Those are very different things, so how can one statement handle them all? And why does a second loop over a list start again from the beginning, while a second loop over a generator (Day 11) or a file (Day 14) finds nothing left? Both questions have the same answer.

Day 10 named anything a for loop can go through an iterable. Day 14 said a file object keeps a bookmark of how far it has read. That bookmark is the key. Before a for loop starts, it asks the iterable for a bookmark object. Then, on every pass, it asks the bookmark for “the next item, please”, until the bookmark says there are none left.

Python has two built-in functions for those two requests:

• iter(iterable) returns an iterator: an object that produces the iterable’s items one at a time and remembers which one comes next. It is the bookmark.
• next(iterator) returns the iterator’s next item and moves the bookmark on by one. When there are no items left, it raises a StopIteration exception, which means “finished”.

The agreement that an iterable hands out an iterator through iter(), and that the iterator hands out items through next() until it raises StopIteration, is called the iteration protocol. A protocol is just an agreed way of doing something, like the order of steps in a handshake.

>>> colors = ["red", "green", "blue"]
>>> bookmark = iter(colors)
>>> next(bookmark)
'red'
>>> next(bookmark)
'green'
>>> next(bookmark)
'blue'
>>> next(bookmark)
Traceback (most recent call last):
  ...
StopIteration
>>> next(bookmark, "no more")
'no more'

• bookmark = iter(colors) makes an iterator for the list. The list itself does not change.
• Each next(bookmark) gives the next color, in order.
• The fourth next has nothing to give, so it raises StopIteration. A traceback here is not a bug in the list; it is how an iterator says “done”.
• next(iterator, default) with a second argument returns default instead of raising when the iterator is finished, like get() with a default on a dictionary (Day 8).

scores = [85, 92, 78]

for score in scores:
    print("for loop:", score)

bookmark = iter(scores)
while True:
    try:
        score = next(bookmark)
    except StopIteration:
        break
    print("by hand:", score)

for loop: 85
for loop: 92
for loop: 78
by hand: 85
by hand: 92
by hand: 78

Now the second question. A list is an iterable, but it is not an iterator: it keeps no bookmark of its own. Every call to iter() on a list makes a fresh iterator that starts at the first item. So every for loop over a list starts from the beginning. A generator, on the other hand, is its own iterator: iter() on a generator hands back the very same generator, bookmark and all. Once the bookmark reaches the end, every later loop finds it there, which is why a generator can be used only once. A file object works the same way.

>>> scores = [85, 92, 78]
>>> first = iter(scores)
>>> second = iter(scores)
>>> next(first)
85
>>> next(first)
92
>>> next(second)
85
>>> iter(scores) is scores
False
>>> squares = (n * n for n in scores)
>>> iter(squares) is squares
True

first and second are two independent bookmarks on one list, so second still starts at 85 after first has moved on. iter(scores) is scores is False (Day 4’s is asks “the same object?”): the list hands out a new object. iter(squares) is squares is True: the generator hands out itself.

>>> names = ["Ana", "Ben"]
>>> next(names)
Traceback (most recent call last):
  ...
TypeError: 'list' object is not an iterator
>>> people = iter(names)
>>> next(people)
'Ana'

letters = iter("cat")
print(next(letters))
for letter in letters:
    print(letter.upper())
print(next(letters, "end"))

c
A
T
end

A rocket launch counts down 3, 2, 1. You would like to write for number in Countdown(3): with a class of your own, the way you loop over a range. Day 17 showed how to plug your objects into Python’s built-ins: len(obj) calls obj.__len__(), and a < b calls a.__lt__(b). The iteration protocol works the same way. iter(obj) calls the special method __iter__, and next(obj) calls __next__. A class that defines both is an iterator, and for loops, list(), sum(), and every other tool that loops will accept it.

The rules for the two methods come straight from 18.1:

• __iter__(self) must return an iterator. An object that is its own bookmark simply returns self.
• __next__(self) must return the next value and update the bookmark, or raise StopIteration (Day 15’s raise) when there are no values left.

class Countdown:
    def __init__(self, start):
        self.current = start

    def __iter__(self):
        return self

    def __next__(self):
        if self.current <= 0:
            raise StopIteration
        value = self.current
        self.current -= 1
        return value


for number in Countdown(3):
    print(number)
print("Liftoff!")

launch = Countdown(2)
print(list(launch))
print(list(launch))

3
2
1
Liftoff!
[2, 1]
[]

That is a lot of bookkeeping for “count down from 3”. The class has to store its position in an attribute, update it on every call, and remember to raise StopIteration at the end. If the raise line were missing, __next__ would return None forever (Day 9: a function that reaches its end returns None), and the for loop would never stop until you pressed Ctrl+C. The next subsection shows a much shorter way to write the same thing, but this is what happens underneath it.

class Countdown:
    def __init__(self, start):
        self.current = start

    def __next__(self):
        if self.current <= 0:
            raise StopIteration
        value = self.current
        self.current -= 1
        return value


for number in Countdown(3):
    print(number)

Traceback (most recent call last):
  File ".../day18/countdown_no_iter.py", line 13, in <module>
    for number in Countdown(3):
                  ~~~~~~~~~^^^
TypeError: 'Countdown' object is not iterable

class Evens:
    def __init__(self, limit):
        self.limit = limit
        self.number = 0

    def __iter__(self):
        return self

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


evens = Evens(5)
print(next(evens))
print(list(evens))
print(sum(Evens(6)))

0
[2, 4]
12

Here is the same countdown with none of the bookkeeping:

def countdown(start):
    current = start
    while current > 0:
        yield current
        current -= 1


for number in countdown(3):
    print(number)
print("Liftoff!")

launch = countdown(2)
print(list(launch))
print(list(launch))

3
2
1
Liftoff!
[2, 1]
[]

The output is identical to countdown_class.py, from five lines instead of thirteen. The new keyword is yield. A def whose body contains yield anywhere is a generator function. It looks like an ordinary function, but it behaves differently in two ways:

1. Calling it does not run its body. countdown(3) runs none of the lines inside. It immediately returns a generator (the same kind of object a Day 11 generator expression makes), which is an iterator ready to run the body later.
2. Each next() runs the body only as far as the next yield. yield value hands value to whoever called next(), and then the function pauses right there, keeping all its local variables. The next next() resumes on the line after the yield. When the body reaches its end, the generator raises StopIteration for you.

So the generator function keeps its bookmark automatically: the bookmark is “which line it paused on, and what its local variables held”. In countdown_gen.py, current stays alive between calls, which is exactly what the class had to store in self.current.

def three_steps():
    print("start")
    yield 1
    print("after the first yield")
    yield 2
    print("after the second yield")


steps = three_steps()
print("made the generator")
print(next(steps))
print(next(steps))
print(next(steps, "finished"))

made the generator
start
1
after the first yield
2
after the second yield
finished

Now compare yield with the return you have used since Day 9. Both functions below produce the squares of 1 to 4:

def squares_list(limit):
    result = []
    for n in range(1, limit + 1):
        result.append(n * n)
    return result


def squares_gen(limit):
    for n in range(1, limit + 1):
        yield n * n


print(squares_list(4))
print(list(squares_gen(4)))
print(sum(squares_gen(4)))

[1, 4, 9, 16]
[1, 4, 9, 16]
30

squares_list builds a whole list, then returns it in one go. squares_gen yields each square as it is asked for and never builds a list. list(squares_gen(4)) collects the yielded values into a list, and sum adds them one at a time (1 + 4 + 9 + 16 = 30) without one. A generator expression, (n * n for n in range(1, limit + 1)), is a one-line short form of squares_gen; a generator function is what you write when the work needs more than one expression, such as several lines, an if, or a while loop.

A return inside a generator function just ends it early: the generator raises StopIteration, and any value after return is not given to the loop.

def evens(numbers):
    for n in numbers:
        if n % 2 == 0:
            return n


print(evens([3, 4, 7, 6, 8]))

4

def evens(numbers):
    for n in numbers:
        if n % 2 == 0:
            yield n


print(list(evens([3, 4, 7, 6, 8])))

[4, 6, 8]

def snacks():
    print("A")
    yield "apple"
    print("B")
    yield "pear"
    print("C")


menu = snacks()
print("ready")
for snack in menu:
    print(snack)
print("done")

ready
A
apple
B
pear
C
done

A shop hands out ticket numbers T-100, T-101, T-102, and so on, for as long as customers keep arriving. How many should a function make? A list has to stop somewhere, and you cannot know where. A generator does not have to stop at all.

Day 11 called a generator lazy: it does the work only when a value is asked for. The proper name for this is lazy evaluation: working out each value at the moment it is needed, not before. Its opposite, working everything out up front, is eager evaluation, which is what a list comprehension does. Lazy evaluation gives generators two powers a list cannot have.

Endless sequences

Because a generator only works out the values it is asked for, its body can loop forever with while True:. Each next() runs one pass and pauses at the yield; values nobody asks for are never made.

To take only the first few values of an endless generator, use islice from the standard library module itertools (tools for iterators). islice(iterator, n) gives the first n items of an iterator, lazily, like slicing [:n] on a list. A list slice does not work here, because a generator cannot be indexed (Day 11).

from itertools import islice


def ticket_numbers(start):
    number = start
    while True:
        yield f"T-{number}"
        number += 1


tickets = ticket_numbers(100)
print(next(tickets))
print(next(tickets))
print(list(islice(tickets, 3)))
print(next(tickets))

T-100
T-101
['T-102', 'T-103', 'T-104']
T-105

Files bigger than memory

A server writes a line to its log every time something happens, and a busy server’s log can be gigabytes long, far more than a program should load with read() or readlines() (Day 14). Day 14 showed that for line in file: reads one line at a time. Generators let you build several processing steps on top of that, and keep the one-line-at-a-time property.

Save this as server_log.txt in day18:

INFO server started
INFO user ana signed in
ERROR disk almost full
INFO user ben signed in
ERROR payment service timed out
INFO backup finished
ERROR disk almost full

def error_lines(lines):
    for line in lines:
        if line.startswith("ERROR"):
            yield line.strip()


def messages(lines):
    for line in lines:
        yield line[6:]


with open("server_log.txt", encoding="utf-8") as file:
    errors = messages(error_lines(file))
    for number, message in enumerate(errors, 1):
        print(number, message)

1 disk almost full
2 payment service timed out
3 disk almost full

def error_lines(lines):
    for line in lines:
        if line.startswith("ERROR"):
            yield line.strip()


with open("server_log.txt", encoding="utf-8") as file:
    errors = error_lines(file)

for line in errors:
    print(line)

Traceback (most recent call last):
  File ".../day18/log_closed.py", line 10, in <module>
    for line in errors:
                ^^^^^^
  File ".../day18/log_closed.py", line 2, in error_lines
    for line in lines:
                ^^^^^
ValueError: I/O operation on closed file.

from itertools import islice


def multiples(step):
    total = 0
    while True:
        total += step
        yield total


fives = multiples(5)
print(next(fives))
print(list(islice(fives, 2)))
print(next(fives) + next(fives))

5
[10, 15]
45

A teacher wants several test functions for scores: “at least 60” to pass, “at least 80” for honors, “at least 90” for a prize. Writing is_passing, is_honors, and is_prize repeats the same line with a different number each time. It would be better to have one function that makes the others: you tell it the limit, and it hands back a ready-made test.

Day 10 showed that functions are values: you can pass a function as an argument, and a function can also return one. And Day 9 said that a function’s local variables are thrown away when the call ends. Today’s idea seems to break that rule, so read carefully.

You can write a def inside another function’s body. The inner function is a nested function, and it exists only inside the outer function, like any other local variable. A nested function can read the outer function’s local variables. When Python looks up a name inside the nested function, it searches the nested function’s own locals first, then the enclosing function’s locals, then the globals (Day 9), then the built-in names such as print.

def make_multiplier(factor):
    def multiply(number):
        return number * factor

    return multiply


double = make_multiplier(2)
triple = make_multiplier(3)
print(double(10), triple(10))
print(double(7))

20 30
14

Step 3 is the new idea. Normally factor would be thrown away when make_multiplier returns. But the returned function uses factor, so Python keeps that variable alive, attached to the function. A function that remembers variables from the enclosing function it was made in, even after that function has returned, is called a closure. Think of a closure as a function carrying a small backpack: the backpack holds the outer variables it uses, and every call can look inside it. Each call to make_multiplier packs a new backpack, which is why double and triple do not interfere.

Here is the teacher’s problem solved with a closure. The made functions are passed around like any other function value:

def at_least(limit):
    def check(score):
        return score >= limit

    return check


scores = [55, 72, 90, 64, 81]
passing = at_least(60)
honors = at_least(80)
print([score for score in scores if passing(score)])
print([score for score in scores if honors(score)])
print(passing(59), honors(80))

[72, 90, 64, 81]
[90, 81]
False True

at_least(60) returns a check function that remembers limit = 60, and at_least(80) returns another that remembers 80. Each comprehension (Day 11) calls its own test on every score. A prize test is now one more line, prize = at_least(90), not one more function.

def make_multiplier(factor):
    def multiply(number):
        return number * factor

    return multiply()


double = make_multiplier(2)
print(double(10))

Traceback (most recent call last):
  File ".../day18/return_called.py", line 8, in <module>
    double = make_multiplier(2)
  File ".../day18/return_called.py", line 5, in make_multiplier
    return multiply()
           ~~~~~~~~^^
TypeError: make_multiplier.<locals>.multiply() missing 1 required positional argument: 'number'

def make_greeter(greeting):
    punctuation = "!"

    def greet(name):
        return f"{greeting}, {name}{punctuation}"

    return greet


hello = make_greeter("Hello")
hola = make_greeter("Hola")
print(hello("Ana"))
print(hola("Ben"))
print(hello(hola("Cy")))

Hello, Ana!
Hola, Ben!
Hello, Hola, Cy!!

A web page wants to count its clicks. A closure can remember a count between calls, so the plan is a function make_counter that returns an increment function, where each call adds 1 to the remembered count and returns it. The first try fails:

def make_counter():
    count = 0

    def increment():
        count += 1
        return count

    return increment


clicks = make_counter()
print(clicks())

Traceback (most recent call last):
  File ".../day18/counter_no_nonlocal.py", line 12, in <module>
    print(clicks())
          ~~~~~~^^
  File ".../day18/counter_no_nonlocal.py", line 5, in increment
    count += 1
    ^^^^^
UnboundLocalError: cannot access local variable 'count' where it is not associated with a value

You have seen this error before, on Day 9, with a global variable. The rule is the same: a name that is assigned anywhere in a function is local to that function. count += 1 assigns to count, so inside increment, count is a brand-new local variable, not the enclosing one, and it has no value yet when += 1 reads it. A closure can read an enclosing variable freely, but assigning to it makes a local instead.

Day 9’s fix for a global was the global statement. For an enclosing function’s variable, the statement is nonlocal: nonlocal count inside the nested function means “count here is the variable of the enclosing function, not a new local”. Then assigning to it changes the remembered variable.

def make_counter():
    count = 0

    def increment():
        nonlocal count
        count += 1
        return count

    return increment


clicks = make_counter()
views = make_counter()
print(clicks(), clicks(), clicks())
print(views())
print(clicks())

1 2 3
1
4

Do you always need nonlocal to change something remembered? Only when you assign to the name. Changing a remembered list in place, with append, assigns nothing, so it needs no nonlocal, just as a function could append to a list passed in on Day 9.

def make_counter():
    count = 0

    def increment():
        global count
        count += 1
        return count

    return increment


clicks = make_counter()
print(clicks())

Traceback (most recent call last):
  File ".../day18/counter_global.py", line 13, in <module>
    print(clicks())
          ~~~~~~^^
  File ".../day18/counter_global.py", line 6, in increment
    count += 1
    ^^^^^
NameError: name 'count' is not defined. Did you mean: 'round'?

def make_running_total():
    total = 0

    def add(amount):
        total = total + amount
        return total

    return add


till = make_running_total()
print(till(5))
print(till(3))

UnboundLocalError: cannot access local variable 'total' where it is not associated with a value

def make_running_total():
    total = 0

    def add(amount):
        nonlocal total
        total = total + amount
        return total

    return add


till = make_running_total()
print(till(5))
print(till(3))

5
8

def make_recorder():
    history = []

    def record(item):
        history.append(item)
        return len(history)

    return record


songs = make_recorder()
games = make_recorder()
print(songs("Help"), songs("Yellow"))
print(games("chess"))
print(songs("Rain"))

1 2
1
3

While testing a program, you want every call of certain functions to print a line saying which function is running. You could add two print lines to each function, but that changes code that already works, repeats itself, and has to be undone afterwards. It would be better to keep each function exactly as it is and wrap it: make a new function that prints the message, calls the original, and passes its result back.

You now have everything this needs. A function can take a function as an argument (Day 10). A nested function can remember a variable from the function that made it (18.5), including a parameter holding a function. And *args and **kwargs (Day 10) let one function accept any arguments at all and pass them on unchanged.

One more fact: every function has an attribute __name__ that holds the name it was defined with, just as every module has a __name__ (Day 13). For def add(a, b):, add.__name__ is "add".

A decorator is a function that takes a function and returns a replacement for it, usually a wrapper: a nested function that does some extra work and calls the original. Here is one, applied by hand:

def log_calls(func):
    def wrapper(*args, **kwargs):
        print("Calling", func.__name__)
        result = func(*args, **kwargs)
        print("Finished", func.__name__)
        return result

    return wrapper


def add(a, b):
    return a + b


add = log_calls(add)
print(add(2, 3))

Calling add
Finished add
5

Line 15’s pattern, name = decorator(name) right after the def, is so common that Python has a short form. Writing @log_calls on the line directly above def add means exactly “define add, then do add = log_calls(add)”. This is the @ you met on Day 17: @property above a method is area = property(area), with a decorator that comes with Python. The @ line runs once, when the def runs, not each time the function is called.

def log_calls(func):
    def wrapper(*args, **kwargs):
        print("Calling", func.__name__)
        result = func(*args, **kwargs)
        print("Finished", func.__name__)
        return result

    return wrapper


@log_calls
def greet(name, greeting="Hello"):
    return f"{greeting}, {name}!"


@log_calls
def area(width, height):
    return width * height


print(greet("Ana"))
print(greet("Ben", greeting="Hi"))
print(area(4, 3))

Calling greet
Finished greet
Hello, Ana!
Calling greet
Finished greet
Hi, Ben!
Calling area
Finished area
12

One decorator, written once, wraps two quite different functions. greet("Ben", greeting="Hi") arrives in the wrapper as args = ("Ben",) and kwargs = {"greeting": "Hi"}, and line 4 passes both on, so the original greet gets its keyword argument. Because the wrapper accepts anything, it fits any function. To stop wrapping a function, delete the @ line; the function’s own code never changed.

A wrapper can also change the result instead of just reporting. This decorator rounds whatever the wrapped function returns:

def two_decimals(func):
    def wrapper(*args, **kwargs):
        return round(func(*args, **kwargs), 2)

    return wrapper


@two_decimals
def average(*scores):
    return sum(scores) / len(scores)


@two_decimals
def with_tax(price, rate=0.08):
    return price * (1 + rate)


print(average(85, 90, 78))
print(with_tax(19.99))
print(with_tax(5, rate=0.2))

84.33
21.59
6.0

average(85, 90, 78) is 84.333…, which the wrapper rounds to 84.33 with Day 2’s round. with_tax(19.99) is 21.5892, rounded to 21.59. Each function stays focused on its own job, and the rounding rule lives in one place. Programmers use decorators like this for logging, for checking arguments, for counting calls, and for timing how long a function takes, which is today’s third practice exercise.

def log_calls(func):
    def wrapper(*args, **kwargs):
        print("Calling", func.__name__)
        func(*args, **kwargs)

    return wrapper


@log_calls
def area(width, height):
    return width * height


print(area(4, 3))

Calling area
None

def fence(func):
    def wrapper(*args, **kwargs):
        print("+-----+")
        result = func(*args, **kwargs)
        print("+-----+")
        return result

    return wrapper


@fence
def show(word):
    print("|", word)
    return len(word)


size = show("hi")
print(size)

+-----+
| hi
+-----+
2

Decorating has a side effect you have not seen yet. After @log_calls, the name area refers to the wrapper, so everything Python can tell you about area now describes the wrapper instead. Day 9’s help() and docstrings show the problem. A function’s docstring is stored in its attribute __doc__:

def log_calls(func):
    def wrapper(*args, **kwargs):
        print("Calling", func.__name__)
        return func(*args, **kwargs)

    return wrapper


@log_calls
def area(width, height):
    """Return the area of a rectangle."""
    return width * height


print(area.__name__)
print(area.__doc__)
help(area)

wrapper
None
Help on function wrapper in module __main__:

wrapper(*args, **kwargs)

The function’s name says wrapper, its docstring is gone (None), and help() shows parameters that tell a user nothing about how to call area. Tracebacks, help(), and debugging and testing tools would all report wrapper for every function this decorator touches, which makes them much harder to tell apart.

The standard library’s functools module (tools for functions) has the fix. functools.wraps(func) is a decorator you put on the wrapper, inside your decorator. It copies the original function’s name, docstring, and parameter details onto the wrapper, so the wrapper presents itself as the function it wraps.

from functools import wraps


def log_calls(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        print("Calling", func.__name__)
        return func(*args, **kwargs)

    return wrapper


@log_calls
def area(width, height):
    """Return the area of a rectangle."""
    return width * height


print(area.__name__)
print(area.__doc__)
help(area)
print(area(4, 3))

area
Return the area of a rectangle.
Help on function area in module __main__:

area(width, height)
    Return the area of a rectangle.

Calling area
12

With wraps, here is the shape of nearly every decorator you will write. Copy it, then fill in the extra work:

from functools import wraps


def my_decorator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        # work before the call
        result = func(*args, **kwargs)
        # work after the call
        return result

    return wrapper

from functools import wraps


@wraps(func)
def log_calls(func):
    def wrapper(*args, **kwargs):
        print("Calling", func.__name__)
        return func(*args, **kwargs)

    return wrapper

Traceback (most recent call last):
  File ".../day18/wraps_outside.py", line 4, in <module>
    @wraps(func)
           ^^^^
NameError: name 'func' is not defined

from functools import wraps


def plain(func):
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)

    return wrapper


def careful(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)

    return wrapper


@plain
def shout(text):
    """Return text in capitals."""
    return text.upper()


@careful
def whisper(text):
    """Return text in small letters."""
    return text.lower()


print(shout("hi"), shout.__name__)
print(whisper("HI"), whisper.__name__, whisper.__doc__)

HI wrapper
hi whisper Return text in small letters.

A fitness tracker writes one line per day to a file, as date,steps. Lines starting with # are notes. Save this as steps.txt in day18:

# date,steps
2026-10-01,6210
2026-10-02,10432
# watch battery died
2026-10-03,3105
2026-10-04,12877
2026-10-05,9050
2026-10-06,11240

The program below reads it lazily, uses closures for the step goals, and a decorator to label each report.

from functools import wraps


def log_calls(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        print(f"[{func.__name__}]")
        return func(*args, **kwargs)

    return wrapper


def read_days(path):
    with open(path, encoding="utf-8") as file:
        for line in file:
            if line.startswith("#"):
                continue
            date, steps = line.strip().split(",")
            yield date, int(steps)


def at_least(goal):
    def reached(day):
        return day[1] >= goal

    return reached


@log_calls
def report(days, test):
    count = 0
    for day in days:
        if test(day):
            count += 1
            print(f"  {day[0]}: {day[1]}")
    return count


days = read_days("steps.txt")
first_date, first_steps = next(days)
print("First day:", first_date, first_steps)

total = report(days, at_least(10000))
print("Goal reached on", total, "of the remaining days")

busy = report(read_days("steps.txt"), at_least(12000))
print("Very busy days:", busy)

First day: 2026-10-01 6210
[report]
  2026-10-02: 10432
  2026-10-04: 12877
  2026-10-06: 11240
Goal reached on 3 of the remaining days
[report]
  2026-10-04: 12877
Very busy days: 1

Follow the data. Line 39 runs no code in read_days. Line 40’s next runs the body: it opens the file, skips the note on the first line, and pauses at yield with the first day. Line 43’s report then pulls the remaining five days through the same paused generator. Of those, 10432, 12877, and 11240 reach 10000, so the count is 3. When the loop has the last line, the generator’s body finishes, which ends its with block and closes the file. Line 46 needs every day again, so it calls read_days again for a fresh generator; reusing days would find nothing left. Only one line of the file is in memory at any moment, so the same program would work on years of data.

Several of today’s errors appear far from the line that caused them. Use this table to go from a message to its usual cause.

Older versions of Python may word some of these messages differently.

• A for loop follows the iteration protocol: iter() gets an iterator, and next() asks it for items until it raises StopIteration. A list hands out a fresh iterator each time; a generator or a file is its own iterator, so it can be used only once. A class becomes an iterator with __iter__ and __next__.
• A function containing yield is a generator function. Calling it runs nothing and returns a generator; each next() runs the body to the next yield, hands over that value, and pauses with its local variables kept. return ends a function with one value; yield hands over a value and waits to continue.
• Generators are lazy: they make each value only when asked. That allows endless generators (take what you need with islice) and pipelines that handle huge files one line at a time.
• A closure is a nested function that remembers the variables of the function that made it. It can read them freely; to assign to one, declare it nonlocal.
• A decorator takes a function and returns a wrapper that adds work around a call to the original. The wrapper takes *args, **kwargs and returns the result, @decorator above a def applies it once, and @wraps(func) keeps the original’s name and docstring.

Do these in your day18 folder. Type each program yourself, run it, and only then open the answer.

from itertools import islice


def fibonacci():
    current, following = 0, 1
    while True:
        yield current
        current, following = following, current + following


first_20 = list(islice(fibonacci(), 20))
print(first_20)
print(len(first_20), first_20[-1])

[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181]
20 4181

Buy milk


Call Ana about the project


Water the plants
  Return library books

def non_blank_lines(path):
    with open(path, encoding="utf-8") as file:
        for line in file:
            text = line.strip()
            if text:
                yield text


for number, line in enumerate(non_blank_lines("notes.txt"), 1):
    print(f"{number}. {line}")

print(sum(1 for _ in non_blank_lines("notes.txt")))

1. Buy milk
2. Call Ana about the project
3. Water the plants
4. Return library books
4

import time
from functools import wraps


def timer(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        elapsed = time.perf_counter() - start
        print(f"{func.__name__} took {elapsed:.4f} seconds")
        return result

    return wrapper


@timer
def sum_of_squares(limit):
    """Add up the squares of 1 to limit."""
    return sum(n * n for n in range(1, limit + 1))


@timer
def slow_hello(name, seconds=0.5):
    time.sleep(seconds)
    return f"Hello, {name}!"


print(sum_of_squares(1000000))
print(slow_hello("Ana"))
print(sum_of_squares.__name__, "-", sum_of_squares.__doc__)

def numbered(items, start=1):
    number = start
    for item in items:
        yield f"{number}. {item}"
        number += 1


chores = numbered(["wash", "dry", "fold"])
print(next(chores))
for line in chores:
    print(line.upper())
print(list(chores))
print(list(numbered("ab", start=5)))

1. wash
2. DRY
3. FOLD
[]
['5. a', '6. b']

def register(func):
    print("registering", func.__name__)
    return func


@register
def hello():
    print("hello")


print("program starts")
hello()
hello()

registering hello
program starts
hello
hello

def log_calls(func):
    def wrapper(value):
        print("Calling", func.__name__)
        return func(value)

    return wrapper


@log_calls
def double(number):
    return number * 2


@log_calls
def add(a, b):
    return a + b


print(double(4))
print(add(2, 3))

TypeError: log_calls.<locals>.wrapper() takes 1 positional argument but 2 were given

def log_calls(func):
    def wrapper(*args, **kwargs):
        print("Calling", func.__name__)
        return func(*args, **kwargs)

    return wrapper


@log_calls
def double(number):
    return number * 2


@log_calls
def add(a, b):
    return a + b


print(double(4))
print(add(2, 3))

Calling double
8
Calling add
5

from functools import wraps


def count_calls(func):
    calls = 0

    @wraps(func)
    def wrapper(*args, **kwargs):
        nonlocal calls
        calls += 1
        print(f"{func.__name__} call {calls}")
        return func(*args, **kwargs)

    return wrapper


@count_calls
def square(n):
    return n * n


@count_calls
def cube(n):
    return n ** 3


print(square(3))
print(square(4))
print(cube(2))
print(square(5))

square call 1
9
square call 2
16
cube call 1
8
square call 3
25

def evens(limit):
    number = 0
    while number <= limit:
        yield number
        number += 2


numbers = evens(5)
print(next(numbers))
print(list(numbers))
print(sum(evens(6)))

0
[2, 4]
12

The official Python Tutorial explains the iteration protocol and generators in Classes: Iterators and Classes: Generators. The functools module documentation describes wraps and other tools for working with functions.

Check each statement. If the answer is “not yet,” reread the linked subsection.

• I can explain what a for loop does with iter(), next(), and StopIteration. Reread
• I can tell an iterable from an iterator, and say why a generator can be used only once. Reread
• I can write a class with __iter__ and __next__ that works in a for loop. Reread
• I can write a generator function and explain what yield does differently from return. Reread
• I can use an endless generator safely with islice, and process a large file with a generator pipeline. Reread
• I can write a function that returns a closure, and explain what the closure remembers. Reread
• I can use nonlocal to change a variable a closure remembers. Reread
• I can write a decorator with a wrapper that takes *args and **kwargs, and apply it with @. Reread
• I can use functools.wraps so a decorated function keeps its name and docstring. Reread