🐍 Python · 20 вопросов · ~50 мин · ⏱ Таймер 50:00 · Средний ·

Итераторы и генераторы

Проверяет ленивые вычисления, yield, протокол итерации и однократный обход. Чтобы пройти его уверенно, мало узнать знакомую запись — нужно восстановить ход программы и обосновать выбор во всех четырёх направлениях. Все задания рассчитаны на CPython 3.12; отличия других реализаций или версий учитываются только там, где это прямо оговорено.

Отвечено: 0 из 20

⏱ --:--

💡 Инструкция: Версия: CPython 3.12. Выберите один ответ из четырёх. На 20 вопросов отведено не меньше 40 минут; код лучше читать построчно. После завершения вы увидите общий процент, четыре тематические шкалы и объяснение каждого ответа.

Вопрос 1 из 20

Сравните `iterable` и полученный из него итератор. Какие два результата проверок идентичности будут выведены?

values=[1,2]
it=iter(values)
print(iter(values) is iter(values), iter(it) is it)

False False False True True True True False

Вопрос 2 из 20

Что произойдёт после исчерпания?

it=iter([1])
print(next(it))
try:
    print(next(it))
except StopIteration:
    print("stop")

1 stop Возникнет IndexError stop 1 1

Вопрос 3 из 20

Проследите создание генератора и первый `next`. В каком порядке появятся `made`, `start` и значение?

def gen():
    print("start")
    yield 1
g=gen()
print("made")
print(next(g))

start 1 made 1 start start made 1 made start 1

Вопрос 4 из 20

Главное преимущество ленивого генератора при обработке большого файла?

Он повторяет чтение повреждённой строки до успешного результата Он распределяет обработку строк между рабочими потоками Он сохраняет возможность повторно обойти тот же объект без пересоздания Элементы выдаются лениво без хранения всего результата

Вопрос 5 из 20

Какое условие в `__next__` останавливает показанный итератор ровно после значений 1, 2 и 3?

class Count:
    def __init__(self,n): self.n=n; self.i=0
    def __iter__(self): return self
    def __next__(self):
        if self.i>=self.n: raise StopIteration
        self.i+=1; return self.i
print(list(Count(3)))

Условие должно проверяться только после возврата значения 4 Проверка `self.i >= self.n` выполняется до увеличения и возврата следующего значения Остановка происходит потому, что `__iter__` возвращает `self` `list` сам прекращает обход после трёх вызовов независимо от `StopIteration`

Вопрос 6 из 20

Какой список даст yield from?

def g():
    yield 0
    yield from [1,2]
    yield 3
print(list(g()))

[0, [1, 2], 3] [0, 1, 2, 3] [0, 3] [1, 2]

Вопрос 7 из 20

Вызов `list(generator)` для бесконечного генератора — ошибка проектирования. Что произойдёт?

Преобразование требует метода `len`, которого у генератора нет `list` остановится после заполнения внутреннего буфера Преобразование добавит генератору условие завершения Материализация не достигнет конца и будет наращивать память

Вопрос 8 из 20

Первый `next(it)` приостанавливает генератор на `yield "ready"`. Как затем значение из `send(5)` проходит через выражение `yield` и что окажется в выводе?

def g():
    x=yield "ready"
    yield x*2
it=g()
print(next(it), it.send(5))

ready 10 Возникнет TypeError ready 5 10 ready

Вопрос 9 из 20

Генератор сначала делает `yield 1`, затем `return 9`. Какие значения покажет код при двух шагах обхода?

def g():
    yield 1
    return 9
it=g(); print(next(it))
try:
    next(it)
except StopIteration as e:
    print(e.value)

1 9 9 Возникнет RuntimeError 1 None

Вопрос 10 из 20

Два обхода контейнера мешают друг другу из-за единственной общей позиции. Какое исправление сделает обходы независимыми?

Возвращать при каждом вызове ссылку на первый созданный генератор Создавать новый независимый итератор для каждого обхода Хранить одну позицию обхода прямо в контейнере Реализовать `__next__` у контейнера и возвращать `self` из `__iter__`

Вопрос 11 из 20

`zip` запрашивает элементы слева направо и останавливается на более коротком генераторе. Что произойдёт с третьим элементом первого генератора и каков полный вывод?

a=(x for x in [1,2,3])
b=(x for x in [10,20])
print(list(zip(a,b)), list(a))

[(1,10),(2,20),(3,None)] [] [(1,10),(2,20)] [1,2,3] [(1, 10), (2, 20)] [] [(1,10),(2,20)] [3]

Вопрос 12 из 20

`iter(callable, 0)` вызывает функцию до значения-сторожа. Какой список будет получен?

values=iter([3,2,0,5])
f=lambda: next(values)
print(list(iter(f,0)))

[3,2,0] [3, 2] [3,2,5] [0]

Вопрос 13 из 20

Результат потенциально велик и будет прочитан только один раз. Какое проектное решение выбрать: генераторное выражение или список?

Сразу построить список, чтобы гарантировать повторный обход и известный размер результата Выбрать генераторное выражение: данные читаются один раз, а итог может быть большим Использовать множество, потому что оно сохраняет порядок и допускает повторные значения Создать кортеж всех результатов, поскольку он не хранит элементы после начала обхода

Вопрос 14 из 20

После `list(enumerate(it, 2))` второй вызов `list(it)` пуст. Какая деталь показанного кода это объясняет?

it=iter("abc")
print(list(enumerate(it,2)), list(it))

`enumerate` создаёт копию данных, а исходный итератор очищает специально `enumerate` потребляет исходный итератор полностью; `start` меняет только номера Параметр `start=2` пропускает два первых элемента исходного итератора Строковый итератор всегда допускает только один вызов `next`, после чего закрывается

Вопрос 15 из 20

Почему побочный эффект внутри генератора может возникнуть позже ожидаемого?

Каждый `yield` передаёт работу отдельному процессу Побочный эффект будет отброшен, если рядом есть `yield` Генератор записывает побочные эффекты в буфер до завершения Код выполняется при запросе элемента, а не при создании

Вопрос 16 из 20

Что произойдёт при повторном list?

def g():
    for i in range(2): yield i
x=g()
print(list(x), list(x))

[] [0,1] [0, 1] [] [0] [1] [0,1] [0,1]

Вопрос 17 из 20

Как ограничить первые 100 элементов потенциально бесконечного iterable?

Использовать `itertools.islice(source, 100)` Использовать sorted(source) Вызвать len(source) Преобразовать source в list и взять срез

Вопрос 18 из 20

Генератор приостановлен после первого `yield`, затем вызывается `close()`. Как эта операция запускает очистку и какая последовательность получается?

def g():
    try:
        yield 1
        yield 2
    finally:
        print("closed")
it=g(); print(next(it)); it.close()

`close()` запрашивает оставшиеся значения, поэтому выводятся `1`, `2`, `closed` Печатается только `1`: `close()` пропускает блок `finally` Сначала выполняется `finally`, затем генератор возвращает первое значение Сначала печатается `1`, затем `close()` вводит `GeneratorExit` и выполняет `finally`, печатая `closed`

Вопрос 19 из 20

Чем `next(it, default)` отличается от обычного `next(it)`?

При исчерпании возвращает `default` вместо `StopIteration` Перед чтением он пропускает один элемент и возвращает следующий Он создаёт новый итератор, если исходный уже исчерпан Он возвращает `default` вместе с каждым полученным элементом

Вопрос 20 из 20

Какой результат у map?

m=map(lambda x:x*2,[1,2,3])
print(next(m), list(m))

1 [2,3] [2] [4,6] 2 [4, 6] 2 [2,4,6]

Ответьте на все 20 вопросов, чтобы получить результат

🔗 Встроить тест на свой сайт (iframe) ▼

Скопируйте код и вставьте в любое место на вашем сайте:

Также доступна прямая ссылка на embed-страницу