Представьте себе, что вы загружаете файл журнала размером 10 ГБ в список только для того, чтобы найти ошибки. Вашей программе может не хватить памяти прежде, чем она ее найдет. Генератори Python решают эту проблему, генерируя значения по требованию, по одному, поэтому вы можете работать с огромными или даже бесконечными данными практически без памяти.

В этом руководстве шаг за шагом показано, что на самом деле происходит при работе генератора. Мы запускали каждый пример на Python 3.13, и в результате этого запуска были получены выходные данные. Это помогает уже освоиться с функциями и циклами, о которых рассказывается в нашем руководстве по Python для начинающих.

Что такое генератор?

Генератор — это особый вид итератора, который создается путем написания функции с использованием yield. Любая функция с yield автоматически становится функцией-генератором, и ее вызов дает вам объект-генератор, а не запускает код.

def count_up(limit):
    print("starting")
    n = 1
    while n <= limit:
        yield n
        n += 1
    print("finished")

gen = count_up(2)
print(gen)

# <generator object count_up at 0x...>

Обратите внимание, что «запуск» не напечатан. Вызов функции только создал генератор. Внутри еще ничего не запустилось.

Как работает доходность, шаг за шагом

Каждый вызов next() запускает функцию до тех пор, пока она не достигнет yield, возвращает это значение и зависает на месте. Следующий вызов возобновляется сразу после этой строки, при этом все локальные переменные остаются неизменными.

print(next(gen))
# starting
# 1

print(next(gen))
# 2

next(gen)
# finished
# StopIteration

Внимательно следите за выводом. «Запуск» появляется только на первом next(). Во втором случае выполнение продолжается с того места, где оно было остановлено, поэтому n все еще доступно и становится равным 2. В третьем цикл заканчивается, выводится сообщение «finished», функция падает с конца, и Python поднимает StopIteration, чтобы сигнализировать, что ничего не осталось.

Вы редко звоните в next() сами. Цикл for делает это за вас и спокойно обрабатывает StopIteration, а также list(), sum() и подобные функции:

print(list(count_up(3)))

# starting
# finished
# [1, 2, 3]

доходность против доходности

Эта задержка известна как ленивая оценка: значения вычисляются только при необходимости. Обычный return внутри генератора просто завершает его, что запускает StopIteration.

Разница в памяти, измеренная

Мы сравнили список из миллиона квадратов с эквивалентным генератором, используя sys.getsizeof:

import sys

squares_list = [n * n for n in range(1_000_000)]
squares_gen = (n * n for n in range(1_000_000))

print(sys.getsizeof(squares_list), sys.getsizeof(squares_gen))

# 8448728 200

Собственная структура списка занимала около 8,4 МБ, тогда как генератор в нашей системе занимал всего 200 байт. Реальный разрыв еще больше, поскольку getsizeof не учитывает целочисленные объекты внутри списка. Размер генератора также остается неизменным для миллиарда элементов, поскольку он сохраняет только текущее состояние, а не результаты.

Однако есть компромисс. Список можно повторно использовать, индексировать и измерять с помощью len(). Генератор не предлагает ничего из этого. Если вам нужен произвольный доступ или вы несколько раз выполняете цикл по небольшому объему данных, список проще. Дополнительную информацию об этих типах см. в нашем руководстве по списку Python, кортежу и набору.

Выражения-генераторы

В простых случаях вам не нужна функция. Выражение-генератор выглядит как список с круглыми скобками вместо квадратных:

squares = [n * n for n in range(5)]   # builds a list now
squares = (n * n for n in range(5))   # produces values on demand

print(sum(n * n for n in range(5)))

# 30

Если выражение-генератор является единственным аргументом функции, как в sum(), вы можете опустить лишние скобки. Это удобная привычка для итогов по большим данным, поскольку временный список не создается.

Создайте конвейер данных

Вот где генераторы действительно блестят. Небольшие генераторы можно объединить в цепочку, чтобы каждый элемент проходил каждый шаг по одному:

def read_lines(lines):
    for line in lines:
        yield line.strip()

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

def messages(lines):
    for line in lines:
        yield line.split(" ", 1)[1]

log = ["INFO started\n", "ERROR db down\n",
       "ERROR disk full\n", "INFO stopped\n"]

print(list(messages(only_errors(read_lines(log)))))

# ['db down', 'disk full']

Каждый шаг выполняет одну небольшую работу и может быть протестирован отдельно. В реальном использовании замените список образцов на открытый файл, поскольку объекты файла можно читать построчно, как показано в нашем руководстве по Обработке файлов Python. Даже журнал размером в несколько гигабайт будет проходить с очень небольшим объемом памяти.

Бесконечные последовательности

Список не может быть бесконечным, а генератор может, потому что он всегда вычисляет только следующее значение. Используйте itertools.islice, чтобы взять столько, сколько вам нужно:

import itertools

def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

print(list(itertools.islice(fibonacci(), 8)))

# [0, 1, 1, 2, 3, 5, 8, 13]

Однако будьте осторожны: вызов list(fibonacci()) без ограничений будет выполняться до тех пор, пока у вас не закончится память. Тот же шаблон подходит для генераторов идентификаторов, циклов опроса и результатов API с разбивкой на страницы, где вы получаете следующую страницу только тогда, когда текущая заканчивается.

урожайность и партии

yield from переходит к другой итерации, сохраняя вложенный цикл:

def chain_all(*groups):
    for group in groups:
        yield from group

print(list(chain_all([1, 2], (3, 4))))

# [1, 2, 3, 4]

Очень практичным шаблоном является разделение данных на пакеты фиксированного размера, например, для вставки в базу данных тысяч строк за раз:

def batches(items, size):
    batch = []
    for item in items:
        batch.append(item)
        if len(batch) == size:
            yield batch
            batch = []
    if batch:
        yield batch

print(list(batches(range(7), 3)))

# [[0, 1, 2], [3, 4, 5], [6]]

Финал if batch гарантирует, что меньшая оставшаяся группа не будет потеряна. Python 3.12 и более поздние версии также включают itertools.batched, который выполняет аналогичную работу.

отправить, закрыть и очистить

Генераторы также могут получать значения. send() возобновляет работу генератора, и значение становится результатом выражения yield. Вы должны сначала вызвать next() один раз, чтобы достичь первого yield:

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

t = running_total()
next(t)
print(t.send(10), t.send(5))

# 10 15

Большинству людей это редко нужно. Более распространенной проблемой является очистка. Если вы остановитесь раньше, блок finally все равно будет работать, когда генератор закрыт:

def tracked():
    try:
        yield 1
        yield 2
    finally:
        print("cleanup ran")

tr = tracked()
next(tr)
tr.close()

# cleanup ran

Pytest использует именно эту идею: фикстура с yield после этого запускает очистку, как показано в нашем руководстве по pytest. Аналогично, декоратор contextmanager стандартной библиотеки превращает генератор в блок with.

Генераторы в классах

Написание метода __iter__ в качестве генератора — это самый простой способ сделать ваш собственный класс итерируемым. Бонусом является то, что каждый цикл получает новый генератор, поэтому объект можно повторять снова и снова:

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

    def __iter__(self):
        n = self.start
        while n > 0:
            yield n
            n -= 1

c = Countdown(3)
print(list(c), list(c))

# [3, 2, 1] [3, 2, 1]

Когда использовать генератор

Генератор в целом не всегда быстрее. Если в конечном итоге вы будете использовать все значения, общая работа будет аналогична, а понимание списка может быть даже быстрее для небольших данных, поскольку оно требует меньше накладных расходов на каждый элемент. Основными преимуществами являются использование памяти и более быстрое получение первых результатов.

Распространенные ошибки

Повторное использование отработанного генератора

В какой-то момент это ловит почти всех. Генератор запоминает, что он завершен:

g = count_up(2)
print(list(g), list(g))

# [1, 2] []

Второй вызов получает пустой список без каких-либо ошибок. Вызовите функцию еще раз, чтобы получить новый генератор, или используйте подход класса, показанный выше.

Ожидание немедленного запуска кода

def noisy():
    print("body runs")
    yield 1

n = noisy()        # nothing is printed
print(next(n))     # body runs, then 1

Проверка аргументов в верхней части генератора не запускается до первого next(), поэтому ошибки могут появляться далеко от вызова, который их вызвал.

Другие ловушки

• Вызов len() или индексирование. Генераторы не поддерживают ни того, ни другого и вызывают TypeError.
• Слишком раннее закрытие файла. Возврат генератора из блока with может означать, что файл закроется до того, как будет прочитана какая-либо строка. Поместите yield внутрь блока with.
• Обернуть все в list(). Это сводит на нет преимущества памяти.
• Используйте один для небольших данных. Простой список часто более понятен.

Итоги

Генератор — это функция, которая может приостанавливать работу. Одна эта идея дает вам низкое использование памяти, бесконечные последовательности и чистые конвейеры. Чтобы применить это на практике, найдите место в своем коде, которое создает большой список только для одного цикла, и превратите его в генератор. Затем попробуйте объединить два небольших генератора в реальный файл журнала.

Часто задаваемые вопросы

Продолжайте учиться