Генераторы и generator expressions вместо ручных буферов

В C «поток данных, вычисляемых по требованию» вы бы реализовали как явную структуру состояния: указатель на позицию, буфер, функцию next_value(state*), которая помнит, где остановилась, через поля структуры, — фактически ручной конечный автомат. Генератор в Python — это функция с yield, которая получает такое поведение бесплатно: интерпретатор сам сохраняет точку выполнения и локальные переменные между обращениями.

Первая и самая важная тонкость для C-программиста: вызов функции с yield внутри не выполняет её тело. Он возвращает объект-генератор — «заготовку», которая начнёт выполняться только при первом обращении (next() или начале for). Это разительно отличается от C, где вызов функции немедленно исполняет её код до return.

def squares_up_to(n):
    print("старт")
    for i in range(n):
        yield i * i

g = squares_up_to(5)   # ничего не напечаталось — тело ещё не выполнялось
print(next(g))          # только теперь печатается "старт", и возвращается 0

Вторая тонкость: генератор — одноразовый итератор. Он не хранит все значения, как список, который можно перечитать сколько угодно раз; после исчерпания повторный обход даёт пустую последовательность, а когда значения кончаются, итератор сигнализирует об этом исключением StopIteration (цикл for перехватывает его сам).

sequenceDiagram
    participant Caller as Вызывающий код
    participant L as Жадная функция (список)
    participant G as Генератор (yield)
    Caller->>L: get_squares(1000000)
    L->>L: сразу вычисляет все элементы
    L-->>Caller: возвращает готовый список в памяти
    Caller->>G: get_squares_gen(1000000)
    G-->>Caller: возвращает объект-генератор, тело не выполнено
    Caller->>G: next()
    G-->>Caller: одно вычисленное значение
    Caller->>G: next()
    G-->>Caller: следующее значение по требованию

sequenceDiagram
    participant Client as Клиент (цикл for)
    participant GenFunc as generate_squares()
    participant GenObj as Объект-генератор

    Client->>GenFunc: generate_squares(3)
    GenFunc-->>GenObj: создать
    GenObj-->>Client: объект-генератор
    Client->>GenObj: next()
    Note over GenObj: код до yield, i=0
    GenObj-->>Client: 0
    Client->>GenObj: next()
    Note over GenObj: возобновление, i=1
    GenObj-->>Client: 1
    Client->>GenObj: next()
    Note over GenObj: возобновление, i=2
    GenObj-->>Client: 4
    Client->>GenObj: next()
    Note over GenObj: цикл завершён, выход из функции
    GenObj-->>Client: StopIteration

Практическая ценность для C-программиста — замена ручного буфера. В C, обрабатывая большой или потенциально неограниченный поток (файл, сокет, датчик), вы либо ограничиваете буфер фиксированным размером, либо пишете realloc-логику. В Python достаточно не накапливать результат в списке, а выдавать его по одному значению через yield — расход памяти остаётся почти постоянным независимо от размера источника.

Частые ошибки переноса привычек из C:

1. Функция всегда собирает полный список и возвращает его, даже когда вызывающий код проходит по нему один раз и выбрасывает — признак «не доверяю языку, соберу буфер сам».
2. Реализация генераторного поведения через класс с ручным __next__ и полями состояния, когда yield решает задачу без явного класса.
3. Забыть, что генератор — не список: передать его в функцию, которая хочет пройти по данным дважды или вызвать len() — на генераторе len() не работает, а повторный проход даёт пустоту.

Кроме функций с yield, есть генераторные выражения — то же, что comprehension, но в круглых скобках и без построения коллекции в памяти:

squares_list = [i * i for i in range(10**7)]  # жадно: список из 10 млн элементов
squares_gen  = (i * i for i in range(10**7))  # лениво: лёгкий объект-генератор
total = sum(x * x for x in range(1_000_000))  # ни один список не строится целиком

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

def parse_errors(path):
    result = []
    with open(path) as f:
        for line in f:
            if "ERROR" in line:
                result.append(line.strip())
    return result

def parse_errors(path):
    with open(path) as f:
        for line in f:
            if "ERROR" in line:
                yield line.strip()

def first_n_primes(n):
    result = []
    candidate = 2
    while len(result) < n:
        if all(candidate % p != 0 for p in result):
            result.append(candidate)
        candidate += 1
    return result