Генераторы и yield в Python: как обрабатывать большие файлы без загрузки в память

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

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

---

В чём разница: список, итератор и генератор

В повседневной разработке термины «коллекция», «итератор» и «генератор» нередко путают, хотя они играют принципиально разные роли в управлении памятью.

• Список (list) — это контейнер, который одновременно хранит все свои элементы в оперативной памяти. Доступ к элементам по индексу осуществляется мгновенно, список можно обходить циклом сколько угодно раз, однако расход памяти линейно растет (O(N)) вместе с размером данных.
• Итератор (iterator) — это объект, представляющий поток данных. Он выдает значения строго по одному с помощью вызова функции next(). Сам итератор не хранит все значения в памяти, а удерживает только текущую позицию и правила вычисления следующего элемента.
• Генератор (generator) — это специализированный итератор, создаваемый с помощью функции с ключевым словом yield или генераторного выражения в круглых скобках. Генератор сохраняет контекст выполнения функции и возобновляет его по запросу.

Сравнительная таблица характеристик

Характеристика	Список (list)	Итератор (iterator)	Генератор (generator)
Расход памяти	Растет пропорционально размеру (O(N))	Обычно константный (O(1))	Обычно константный (O(1))
Повторный обход	Возможен неограниченное число раз	Как правило, одноразовый	Одноразовый
Вычисление значений	Жадное (все сразу при создании)	Ленивое (по требованию)	Ленивое (по требованию)
Доступ по индексу ([i])	Поддерживается	Не поддерживается	Не поддерживается
Вычисление длины (len)	Поддерживается	Не поддерживается	Не поддерживается

Протокол итерации: как Python обходит данные под капотом

Цикл for item in source: в Python не работает со списками напрямую. Под капотом запускается протокол итерации:

1. Функция iter(source) запрашивает у объекта метод __iter__(), возвращающий объект-итератор.
2. В каждой итерации вызывается функция next(iterator), которая дергает метод __next__().
3. Когда элементы исчерпаны, метод __next__() возбуждает исключение StopIteration. Цикл for перехватывает его и корректно завершает работу.

data = [10, 20, 30]
iterator = iter(data)

print(next(iterator))  # 10
print(next(iterator))  # 20
print(next(iterator))  # 30
# Следующий вызов next(iterator) вызовет исключение StopIteration

Генераторы реализуют этот протокол автоматически: они содержат методы __iter__() и __next__(), избавляя разработчика от написания собственных служебных классов.

---

Механика работы yield и генераторных функций

Обычная функция выполняет инструкции сверху вниз и отдает результат через return, полностью очищая свой стек и локальные переменные.

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

Приостановка и возобновление состояния

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

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

def simple_counter():
    print("Начало работы")
    yield 1
    print("Возобновление после 1")
    yield 2
    print("Завершение")

gen = simple_counter()
print(next(gen))
# Вывод:
# Начало работы
# 1

print(next(gen))
# Вывод:
# Возобновление после 1
# 2

Делегирование подгенераторам с помощью yield from

Синтаксис yield from <iterable> позволяет прозрачно делегировать генерацию значений вложенному итерируемому объекту или другому генератору. Конструкция:

def flatten(nested):
    for sublist in nested:
        for item in sublist:
            yield item

Эквивалентна и более эффективна в следующем виде:

def flatten(nested):
    for sublist in nested:
        yield from sublist

yield from устраняет накладные расходы внутреннего цикла интерпретатора и корректно пробрасывает внутрь подгенератора вызовы методов .send(), .throw() и .close().

---

Проблема жадной загрузки и MemoryError

Главная причина нехватки ресурсов при чтении объемных файлов — жадная загрузка (Eager Loading). Типичный пример неэффективной работы с файлом:

# Попытка прочитать весь файл целиком в память
with open("huge_log.csv", "r", encoding="utf-8") as f:
    lines = f.readlines()  # Создает список со всеми строками файла

# Или чтение содержимого единой строкой
with open("huge_log.csv", "r", encoding="utf-8") as f:
    content = f.read()

Если размер файла превышает доступный объем оперативной памяти (или лимит, выделенный процессу в контейнере), операционная система принудительно завершит процесс, либо Python выбросит исключение MemoryError.

Кроме того, парсинг текстового файла в список списков или словарей порождает дополнительные накладные расходы: на каждый строковый объект выделяются служебные структуры CPython. В результате 1 ГБ исходного текстового файла может занять от 3 до 5 ГБ в оперативной памяти.

---

Построение ленивого конвейера для обработки CSV

Вместо накопления данных в памяти обработку выстраивают по принципу конвейера (data pipeline): данные передаются небольшими порциями от источника к потребителю через цепочку независимых шагов-генераторов.

Потоковое чтение строк через csv.reader

Файловый объект в Python уже является итератором, отдающим строки по одной. Модуль csv спроектирован так, чтобы принимать любой итерируемый объект.

При открытии CSV-файлов документация Python требует передачи аргумента newline="", чтобы модуль csv корректно и единообразно интерпретировал окончания строк независимо от операционной системы.

import csv

def read_csv_rows(file_path):
    with open(file_path, mode="r", newline="", encoding="utf-8") as file:
        reader = csv.reader(file)
        yield from reader

Модульная фильтрация и трансформация на лету

Каждый этап логики оформляется отдельной генераторной функцией, принимающей на вход итератор:

def filter_valid_records(rows):
    """Пропускаем пустые строки и отбираем записи со статусом COMPLETED."""
    for row in rows:
        if row and len(row) >= 3 and row[2] == "COMPLETED":
            yield row

def extract_amounts(records):
    """Преобразуем строковое поле суммы в число."""
    for record in records:
        try:
            yield float(record[1])
        except ValueError:
            continue

Безопасность контекстного менеджера with open(...)

Частый вопрос: закроется ли файл, если генератор обернут в with open(...), но цикл чтения был прерван досрочно?

Внутренний блок with open(...) закрывает файл, когда выполнение выходит из этого блока: при полном обходе генератора, исключении внутри него или явном вызове generator.close(). Сам по себе break в вызывающем цикле генератор не закрывает. Если ссылка на генератор сохраняется, он остаётся приостановленным на yield, а файл может оставаться открытым.

Для предсказуемого освобождения ресурса при досрочном выходе подходит contextlib.closing:

from contextlib import closing

with closing(read_csv_rows("data.csv")) as rows:
    for row in rows:
        print(row)
        break

При выходе из внешнего блока with будет вызван rows.close(), что завершит генератор и внутренний блок работы с файлом.

---

Практический замер памяти: список против генератора

Сравним два подхода на одном наборе данных с помощью встроенного модуля tracemalloc, отслеживающего аллокации памяти интерпретатора.

Подготовка тестового файла

Сгенерируем CSV-файл объемом в 500 000 строк:

import csv

def generate_mock_csv(filename="benchmark_data.csv", rows=500_000):
    with open(filename, "w", newline="", encoding="utf-8") as f:
        writer = csv.writer(f)
        writer.writerow(["id", "amount", "status"])
        for i in range(rows):
            status = "COMPLETED" if i % 2 == 0 else "PENDING"
            writer.writerow([i, i * 1.5, status])

generate_mock_csv()

Сценарий 1: Жадная загрузка (список)

import csv
import tracemalloc

def process_with_list(filepath):
    with open(filepath, mode="r", newline="", encoding="utf-8") as f:
        reader = csv.reader(f)
        header = next(reader, None)
        # Загружаем все отфильтрованные строки в память
        data = [row for row in reader if row and row[2] == "COMPLETED"]
        amounts = [float(row[1]) for row in data]
        return sum(amounts)

tracemalloc.start()
total_list = process_with_list("benchmark_data.csv")
current, peak_list = tracemalloc.get_traced_memory()
tracemalloc.stop()

print(f"[Список] Результат: {total_list}")
print(f"[Список] Пиковая память: {peak_list / (1024 * 1024):.2f} МБ")

Сценарий 2: Потоковая обработка (генераторный конвейер)

import csv
import tracemalloc

def stream_csv_rows(filepath):
    with open(filepath, mode="r", newline="", encoding="utf-8") as f:
        reader = csv.reader(f)
        yield from reader

def filter_completed(rows):
    header = next(rows, None)
    for row in rows:
        if row and row[2] == "COMPLETED":
            yield row

def parse_amounts(records):
    for r in records:
        yield float(r[1])

def process_with_generators(filepath):
    raw_rows = stream_csv_rows(filepath)
    filtered = filter_completed(raw_rows)
    amounts = parse_amounts(filtered)
    # Потребление потока функцией sum
    return sum(amounts)

tracemalloc.start()
total_gen = process_with_generators("benchmark_data.csv")
current, peak_gen = tracemalloc.get_traced_memory()
tracemalloc.stop()

print(f"[Генератор] Результат: {total_gen}")
print(f"[Генератор] Пиковая память: {peak_gen / 1024:.2f} КБ")

Разбор результатов

• В первом сценарии пиковая память (peak_list) исчисляется десятками мегабайт, поскольку интерпретатор единовременно удерживает структуры для сотен тысяч списков и чисел.
• Во втором сценарии пиковая память (peak_gen) составляет единицы килобайт (в пределах базового системного I/O буфера). Потребление памяти остается константным — O(1), независимо от того, сколько записей содержит файл.

---

Генераторные выражения vs List Comprehensions: быстрый рефакторинг

Преобразовать жадное списковое включение в ленивое генераторное выражение можно заменой квадратных скобок на круглые:

# List Comprehension — выделяет память под 10 000 000 элементов сразу
large_list = [x * 2 for x in range(10_000_000)]

# Generator Expression — не вычисляет элементы до фактического запроса
large_gen = (x * 2 for x in range(10_000_000))

Генераторные выражения можно передавать напрямую в функции-агрегаторы (sum, max, min, any, all) без дублирования скобок:

total_amount = sum(float(row[1]) for row in valid_rows if row[2] == "COMPLETED")

Такая запись делает код лаконичным, сохраняя минимальный след в оперативной памяти.

---

Ограничения и особенности работы с генераторами

Несмотря на эффективность генераторов, их архитектурные особенности накладывают ряд ограничений:

1. Одноразовость

Итератор нельзя прочитать повторно или «перемотать» в начало. Как только элемент отдан, он покидает поток. Повторная итерация по завершенному генератору вернет пустой результат:

gen = (x for x in range(3))
print(list(gen))  # [0, 1, 2]
print(list(gen))  # [] (генератор исчерпан)

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

2. Отсутствие произвольного доступа и функции len()

К генератору нельзя применить len(gen) или получить элемент по индексу gen[5]. Точная длина потока неизвестна до окончания итерации. Для выборки диапазона значений из генератора используют функцию itertools.islice.

3. Досрочное прерывание цикла (break)

После break генератор остаётся приостановленным на последней точке yield. Если на него сохраняется ссылка, его можно продолжить, а открытые внутри ресурсы могут оставаться занятыми. Для своевременного закрытия файла подходит явный вызов .close() в finally или внешний контекст contextlib.closing; полагаться на время сборки мусора не следует.

---

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

Можно ли обойти генератор циклом for повторно?

Нет, генераторы одноразовые. После выдачи последнего значения генератор выбрасывает исключение StopIteration. Чтобы обойти данные еще раз, генераторную функцию нужно вызвать повторно.

Закроется ли файл, если генератор с with open(...) был прерван по break?

Не обязательно. break завершает цикл, но не вызывает .close() у генератора. Пока генератор сохраняется и приостановлен внутри with open(...), файл может оставаться открытым. Для гарантированного закрытия при досрочном выходе используется contextlib.closing либо явный вызов generator.close() в finally.

Всегда ли генератор работает медленнее списка по процессорному времени?

Накладные расходы на переключение контекста генератора делают пошаговый обход чуть медленнее прямого чтения плотного C-массива. Однако генератор исключает тяжелые операции выделения гигабайтов памяти и работу Garbage Collector по их очистке, поэтому на больших файлах конвейеры работают стабильнее и быстрее.

Что выбрать для промежуточных этапов: выражение или функцию с yield?

Для базовых преобразований и простой фильтрации подходят генераторные выражения: (transform(x) for x in source if cond(x)). Если требуется сложная логика, обработка исключений или логирование, код следует выносить в полноценную генераторную функцию с yield.

Когда списки объективно лучше генераторов?

Списки необходимы, если:

• размер данных невелик и гарантированно помещается в RAM;
• требуется постоянный доступ по индексам (data[i]);
• данные нужно сортировать «на месте» (list.sort()) или повторно использовать в разных частях программы.

Как узнать количество элементов в генераторе без создания списка?

Для подсчета элементов с константной памятью используют генераторное выражение внутри sum():

total_count = sum(1 for _ in generator)

---

Вывод

Использование списков и метода file.readlines() оправдано только для небольших объемов данных. При обработке реальных производственных массивов (дампов баз данных, логов и выгрузок CSV) жадная загрузка неизбежно ведет к нехватке памяти.

Построение ленивых конвейеров на базе генераторов и ключевого слова yield позволяет обрабатывать файлы любого объема с фиксированным потреблением памяти O(1), сохраняя модульность и надежность кода.

Источники

• Glossary

• itertools — Functions creating iterators for efficient ...

• csv — CSV File Reading and Writing

• Trace or track Python statement execution

• Classes

• 3. Data model — Python 3.15.0 documentation

• contextlib.closing — явное закрытие генератора

• generator.close — документация Python