К содержимому
Войти

Python Road Map

🔁 Итераторы, генераторы и yield

Цикл for в Python работает через протокол итерации: два метода и одно исключение. На нём держатся генераторы, чтение файлов построчно, zip, map, весь itertools и, исторически, корутины. На техсекции отсюда спрашивают три вещи: чем итерабельный объект отличается от итератора, что делает yield и почему второй проход по генератору ничего не возвращает

🧠 Как это устроено

Протокол итерации

Участников двое. Итерабельный объект (iterable) умеет выдать итератор: у него есть __iter__. Это список, строка, словарь, файл, range. Итератор (iterator) выдаёт элементы по одному через __next__, а когда они кончились, бросает StopIteration. У итератора тоже есть __iter__, и он возвращает сам итератор. Поэтому любой итератор заодно итерабелен и годится для for

Цикл for x in items: интерпретатор разворачивает примерно так:

it = iter(items)          # items.__iter__()
while True:
    try:
        x = next(it)      # it.__next__()
    except StopIteration:
        break
    ...                   # тело цикла

Список на каждый iter() отдаёт новый итератор, поэтому по списку можно пройти сколько угодно раз. Итератор на iter() отдаёт себя, позиция у него одна, и назад он не перематывается. Документация прямо требует: если __next__ один раз бросил StopIteration, он должен бросать его и дальше. Пройденный итератор выглядит как пустой контейнер, ошибки при этом нет

IterableIterator
Что умеетВыдать итераторВыдать следующий элемент
Методы__iter____iter__ (возвращает self) и __next__
Повторный проходДа, каждый раз новый итераторНет, после конца всегда StopIteration
Примерыlist, dict, str, rangeiter([1, 2]), генератор, файл, zip, map

Файл, кстати, сам себе итератор: второй for line in f по тому же открытому файлу ничего не прочитает

Генераторы

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

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

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

Generator expression против list comprehension

[x * x for x in data] сразу строит список целиком. (x * x for x in data) возвращает генератор, который ничего не посчитал. Синтаксис отличается скобками, поведение отличается сильно:

[... for ...](... for ...)
Когда считаетСразу всёПо запросу, по одному элементу
ПамятьВсе элементыОдин текущий плюс состояние генератора
Повторный проходДаНет, второй раз пусто
Индекс, len, срезЕстьНет

На миллионе квадратов разница видна в цифрах (Python 3.13):

import sys, tracemalloc

print(sys.getsizeof([x * x for x in range(1_000_000)]))  # 8448728
print(sys.getsizeof(x * x for x in range(1_000_000)))    # 200

tracemalloc.start()
sum([x * x for x in range(1_000_000)])
print(tracemalloc.get_traced_memory()[1])  # пик около 40 МБ
tracemalloc.reset_peak()
sum(x * x for x in range(1_000_000))
print(tracemalloc.get_traced_memory()[1])  # пик меньше 1 КБ

Два числа для списка расходятся не случайно. sys.getsizeof меряет только сам объект списка, то есть массив ссылок по 8 байт. Объекты int внутри он не считает, а tracemalloc видит все выделения, поэтому показывает 40 МБ вместо 8. Как список хранит элементы, разобрано на странице «Списки, словари и множества изнутри»

Когда генератор передают единственным аргументом, вторые скобки не нужны: sum(x * x for x in data). В Python 3.15, вышедшем 9 октября 2026, PEP 798 разрешил распаковку прямо в comprehension: [*L for L in lists] склеивает списки в один, а (*L for L in lists) делает то же лениво. Раньше для этого писали два for или itertools.chain.from_iterable

🛠️ На практике

Большой файл построчно

Типичная задача: найти в логе строки с ошибками. Вариант с readlines() читает файл в память целиком, вариант с генератором держит одну строку:

def errors(path):
    with open(path) as f:
        for line in f:                 # файл отдаёт строки по одной
            if line.rstrip().endswith(" 500"):
                yield line

count = sum(1 for _ in errors("access.log"))

На логе в 31 МБ и миллион строк пик памяти у [line for line in f.readlines() if ...] получился около 80 МБ, у генератора около 23 КБ. Генераторы удобно собирать в конвейер: lines = read(path), parsed = (parse(l) for l in lines), slow = (r for r in parsed if r.ms > 500). Ни один шаг не стартует, пока кто-то не начнёт читать последний

yield from и возврат значения

return value в генераторе не отдаёт значение в for: цикл его не увидит. Значение кладётся в атрибут value исключения StopIteration. Достаёт его yield from, который появился в Python 3.3 по PEP 380:

def read_batch():
    yield 1
    yield 2
    return "done"

def pipeline():
    result = yield from read_batch()   # пробрасывает 1 и 2 наружу
    print("подгенератор вернул", result)
    yield 3

print(list(pipeline()))
# подгенератор вернул done
# [1, 2, 3]

yield from it короче, чем for x in it: yield x, и вдобавок пробрасывает в подгенератор send, throw и close. Ради этого его и добавляли

send, throw, close

У генератора, кроме __next__, три метода. Они превращают его из источника значений в объект, с которым можно разговаривать:

  • send(value) возобновляет генератор, и выражение yield внутри возвращает value. next(g) равен g.send(None)
  • throw(exc) бросает исключение в точке, где генератор остановился. Генератор может его поймать и продолжить работу
  • close() бросает внутрь GeneratorExit, чтобы отработали finally. Если генератор поймал его и снова сделал yield, будет RuntimeError: generator ignored GeneratorExit

Python · Скользящее среднее на send

def averager():
    total = count = 0
    avg = None
    while True:
        x = yield avg      # отдаём текущее среднее, ждём новое число
        total += x
        count += 1
        avg = total / count

a = averager()
next(a)                    # дойти до первого yield
print(a.send(10), a.send(20), a.send(30))   # 10.0 15.0 20.0

Первый вызов обязан быть next(g) или send(None): генератор ещё не дошёл ни до одного yield, и принять значение ему некуда. a.send(10) на свежем генераторе падает с TypeError: can't send non-None value to a just-started generator

Две детали по версиям. Форма throw(type, value, traceback) с Python 3.12 выдаёт DeprecationWarning, пиши g.throw(ValueError("bad")). С Python 3.13 close() возвращает значение, если генератор в ответ на GeneratorExit сделал return, раньше всегда возвращался None

На yield построен contextlib.contextmanager: код до yield работает как вход в блок with, после как выход. Подробно это разобрано на странице «Исключения и контекстные менеджеры»

Связь с корутинами

send и yield from сделали из генератора функцию, которую можно приостановить и продолжить со значением снаружи. На этом в Python 3.4 появился asyncio: корутины писали как генераторы с yield from. Позже их заменили async def и await, но идея та же. Event loop и async-генераторы ждут в модуле «Конкурентность и асинхронность»

itertools

Модуль собирает ленивые строительные блоки. Три, которые встречаются чаще всего:

  • islice(it, start, stop, step) — срез для любого итератора, у которого нет индексов. islice(gen, 10) даёт первые 10 элементов. Отрицательные границы не поддерживаются: до конца ленивой последовательности не дойти, не прочитав её
  • chain(a, b, c) — склеивает итерируемые объекты в один поток без копирования. chain.from_iterable(lists) берёт их из одного итерируемого
  • groupby(it, key) — группирует соседние элементы с одинаковым ключом

У groupby подвох, который любят на собеседованиях. Это не SQL GROUP BY: новая группа начинается каждый раз, когда ключ меняется. Без сортировки одна буква превращается в несколько групп:

from itertools import groupby

words = ["apple", "avocado", "banana", "apricot", "blueberry"]
first = lambda w: w[0]

print([(k, list(g)) for k, g in groupby(words, first)])
# [('a', ['apple', 'avocado']), ('b', ['banana']), ('a', ['apricot']), ('b', ['blueberry'])]

print([(k, list(g)) for k, g in groupby(sorted(words, key=first), first)])
# [('a', ['apple', 'avocado', 'apricot']), ('b', ['banana', 'blueberry'])]

Сортировать нужно по тому же ключу, что передаёшь в groupby. Второй подвох: группа сама итератор и делит источник с groupby. Когда groupby переходит к следующему ключу, предыдущая группа становится пустой. {k: g for k, g in groupby(...)} даст словарь пустых групп, поэтому группу сразу превращают в list(g)

⚠️ Где ошибаются

Проходят по генератору дважды. Посчитали total = sum(g), потом max(g) и получили ValueError на пустой последовательности. Если данные нужны больше одного раза, сохрани их в список или создай генератор заново

Проверяют in на генераторе. 5 in (x for x in range(10)) вернёт True, но съест элементы до пятёрки включительно, и следующий list(gen) вернёт [6, 7, 8, 9]

Возвращают генератор из with. Функция открывает файл в with и делает return (l for l in f). Файл закрывается сразу при выходе из функции, и первый next() падает с ValueError: I/O operation on closed file. Пиши генераторную функцию с yield внутри with, как в примере с логом выше: тогда файл живёт, пока по генератору идут

Бросают StopIteration руками внутри генератора. Начиная с Python 3.7 (PEP 479) StopIteration, вылетевший из тела генератора, превращается в RuntimeError: generator raised StopIteration. Обычно это next(it) на пустом итераторе внутри генератора. Чтобы закончить генератор, пиши return

Ставят генератор там, где нужен список. Ленивость окупается на больших и потоковых данных. Для 20 элементов, по которым идёшь три раза и берёшь len, список проще и быстрее: генератор платит за каждое возобновление функции

🎯 Вопросы с собеседований

Чем итерабельный объект отличается от итератора?

Итерабельный объект умеет выдать итератор через __iter__: так устроены список, словарь, строка. Итератор хранит позицию и выдаёт элементы через __next__, а в конце бросает StopIteration. Его __iter__ возвращает его же, поэтому итератор можно передать в for. Цикл for вызывает iter() у объекта и дальше крутит next(), пока не поймает StopIteration. Список на каждый iter() создаёт новый итератор, поэтому его можно обходить много раз, а итератор одноразовый

Что делает yield?

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

Чем генератор отличается от списка? Чем [x for x in y] отличается от (x for x in y)?

Список строится сразу и держит все элементы в памяти, генератор считает их по запросу и держит одно текущее значение. Первое выражение возвращает список, второе генератор. У генератора нет индексов, len и повторного прохода, зато память не зависит от длины данных: на миллионе чисел список занимает десятки мегабайт, генератор около 200 байт. Генератор выбирают для больших и потоковых данных и для конвейеров, список, когда данные нужны несколько раз или нужен доступ по индексу

Что делает yield from?

Делегирует работу подгенератору: все его значения уходят прямо вызывающему коду, а send, throw и close пробрасываются внутрь. Когда подгенератор закончился, yield from возвращает его return-значение. Появился в Python 3.3 по PEP 380. Без него пришлось бы вручную писать цикл, который ловит исключения и пересылает отправленные значения, и это легко сделать с ошибкой

Какие методы есть у генератора: send, throw, close?

send(value) возобновляет генератор, и yield внутри возвращает value. Первым вызовом должен быть next() или send(None), иначе TypeError. throw(exc) бросает исключение в точке остановки: генератор может его обработать и выдать следующее значение. close() бросает внутрь GeneratorExit, чтобы выполнились finally, и генератор завершается. Если он проигнорировал GeneratorExit и снова сделал yield, close() бросит RuntimeError

Почему второй проход по генератору пустой?

Генератор — это итератор, а итератор хранит одну позицию и не перематывается. После первого прохода он бросил StopIteration и обязан бросать его дальше. for и sum воспринимают это как конец данных, поэтому второй sum(g) вернёт 0 без ошибки. Решение: сохранить результат в список или вызвать генераторную функцию ещё раз, чтобы получить новый генератор

Что будет, если в генераторе написать return value?

Генератор завершится, а value попадёт в атрибут value исключения StopIteration. Цикл for это значение проглотит. Получить его можно через result = yield from gen() в другом генераторе или поймав StopIteration вручную и прочитав e.value. С Python 3.13 close() тоже вернёт это значение, если генератор сделал return в ответ на GeneratorExit

📚 Что почитать

  • Glossary: iterator — точные определения iterator, iterable и generator, включая предупреждение про «пустой контейнер» при втором проходе
  • Yield expressions — как работают yield, yield from, send, throw и close, с примером на все методы сразу
  • itertools — все функции модуля с эквивалентом на чистом Python и разделом готовых рецептов
  • PEP 380 — зачем появился yield from и как он раскрывается в обычный код