Как работают генераторы в Python: yield, next() и экономия памяти

На чтение
6 мин
Дата обновления
05.11.2026

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

Разберём механику на короткой последовательности квадратов, затем построим обработку журнала JSON Lines. Примеры выполнены на Python 3.12. Здесь нет обещания фиксированного ускорения или конкретной экономии мегабайт: результат зависит от данных и потребителя.

Список хранит результат, генератор хранит ход работы

Список удобен, когда нужен доступ по индексу, известная длина и повторные проходы по сохранённым элементам. Генератор полезен, когда значения можно получать последовательно и не нужно держать их все одновременно.

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

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

Что происходит при yield

Наличие yield в теле обычной функции делает её генераторной. Вызов функции возвращает объект генератора, а выполнение тела начинается при запросе очередного значения. На yield функция выдаёт значение и приостанавливается, сохраняя локальное состояние. Следующий запрос продолжает выполнение после этой точки.

def squares(limit):
    for number in range(limit):
        yield number * number

g = squares(3)
print(next(g))  # 0
print(next(g))  # 1
print(list(g))  # [4]

После первого next переменная number не исчезла: генератор сохраняет состояние между обращениями. После второго вызова цикл уже прошёл два элемента. Поэтому list получает только оставшийся квадрат, а не заново все три.

Это принципиальное отличие yield от обычного return: выдача очередного значения не означает немедленное окончание всей генераторной функции. Когда функция действительно заканчивается или выполняет return, поток значений завершается.

next, for и завершение

Встроенная next вызывает метод __next__ итератора. Когда значения закончились, без второго аргумента возникает StopIteration. Если передан default, next возвращает его вместо этого исключения.

print(next(g, "конец"))  # конец

try:
    next(g)
except StopIteration:
    print("значений больше нет")

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

Не считайте StopIteration ошибкой данных: в этом контексте он означает окончание итератора. Но и не перехватывайте подряд все исключения ради продолжения: ошибка разбора файла или вычисления имеет другой смысл.

Генератор — один из видов итераторов

Итератор поддерживает последовательное получение значений. Генераторный объект тоже является итератором, однако не каждый итератор создан генераторной функцией. Например, можно получить итератор списка через iter или реализовать собственный класс с протоколом итератора.

Практическое следствие: потребитель обычно не обязан знать, как создан поток. Цикл for может работать с разными подходящими объектами. А yield позволяет автору функции описать последовательность обычным кодом, не записывая отдельный класс и ручное хранение его состояния.

Исчерпанный генератор не перематывается. Второй цикл по тому же объекту не повторит прежние значения. Для нового прохода создайте новый генератор и, если источник тоже исчерпан, заново откройте или восстановите сам источник.

Пример: ошибки в большом журнале

Предположим, каждая непустая строка файла содержит самостоятельный JSON-объект с полями level и message. Это выбранный формат учебного журнала, а не парсер любого произвольного JSON. Нам нужно получить сообщения ERROR или только посчитать их.

import json
from pathlib import Path

def squares(limit):
    for number in range(limit):
        yield number * number

def error_messages(lines):
    for line in lines:
        if not line.strip():
            continue
        event = json.loads(line)
        if event.get("level") == "ERROR":
            yield event.get("message", "")

def count_errors(path):
    with Path(path).open(encoding="utf-8") as source:
        return sum(1 for _ in error_messages(source))

Файл перебирается построчно. error_messages разбирает очередную запись и выдаёт сообщение только при нужном уровне. count_errors потребляет этот поток счётчиком, не собирая список всех ошибок. Файл остаётся открытым на время обработки и закрывается при выходе из with. Руководство Python по файловому вводу-выводу прямо описывает закрытие файлового объекта после завершения блока, в том числе при исключении.

Для небольшого тестового файла использованы три записи: INFO со значением started, ERROR со значением timeout и ERROR со значением bad input, а также пустая строка. Проверка получила два сообщения и count_errors = 2. Это реально выполненная проверка логики, а не измерение производительности большого журнала.

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

Где остаются ошибки и память

Код ожидает JSON-объекты. Некорректный JSON или другое содержимое строки не игнорируется: исключение появится во время потребления. В прикладном журнале можно добавить номер строки и выбранную политику обработки, но нельзя незаметно пропускать повреждения, если итоговый счёт должен быть полным.

Построчная обработка не означает нулевой расход памяти. В памяти находятся текущая строка, разобранный объект, локальное состояние и то, что сохраняет потребитель. Одна чрезвычайно большая строка сама может потребовать много памяти.

Проверьте весь путь: read или readlines без ограничения собирают исходник; list собирает результаты; сортировка потока требует хранения элементов для своей задачи. Генератор между такими этапами не превращает всю программу в потоковую автоматически.

Как выбрать подход

Если нужен один проход с фильтрацией, преобразованием или подсчётом, начинайте с последовательного потока. Если нужны индексы, повторные проходы и небольшая коллекция результатов, рассмотрите список. Если источник — файл или сетевой ресурс, заранее определите, кто и когда его закрывает.

Полезный навык работы с генераторами — видеть момент вычисления и владельца состояния. Тогда yield и next становятся понятным инструментом организации обработки, а не магическим обещанием экономии памяти.