🔁 Итераторы, генераторы и 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, он должен бросать его и дальше. Пройденный итератор выглядит как пустой контейнер, ошибки при этом нет
| Iterable | Iterator | |
|---|---|---|
| Что умеет | Выдать итератор | Выдать следующий элемент |
| Методы | __iter__ | __iter__ (возвращает self) и __next__ |
| Повторный проход | Да, каждый раз новый итератор | Нет, после конца всегда StopIteration |
| Примеры | list, dict, str, range | iter([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и как он раскрывается в обычный код