Итераторы в Python: iter() и next()
Обновлено:
Мы уже много раз работали с итерируемыми объектами:
list
tuple
str
dict
set
frozenset
range
Все эти объекты можно обходить с помощью цикла for.
Но каким образом Python получает элементы этих объектов один за другим?
Для этого используются итераторы (iterators).
Итераторы — один из важнейших механизмов Python. Они позволяют последовательно получать элементы, запоминать место остановки и обрабатывать данные без необходимости создавать дополнительные коллекции.
Начнём знакомство с двумя встроенными функциями:
iter()
next()
1. Функция iter()
Встроенная функция:
iter()
позволяет получить итератор из итерируемого объекта.
Например, создадим список:
numbers = [10, 20, 30]
Теперь передадим его в iter():
iterator = iter(numbers)
print(type(iterator))
Результат:
<class 'list_iterator'>
Мы получили специальный объект — итератор списка.
Точно так же можно создавать итераторы других коллекций:
print(type(iter((10, 20, 30))))
# <class 'tuple_iterator'>
print(type(iter('Python')))
# <class 'str_ascii_iterator'>
print(type(iter({10, 20, 30})))
# <class 'set_iterator'>
print(type(iter({'a': 1, 'b': 2})))
# <class 'dict_keyiterator'>
Названия некоторых внутренних классов могут отличаться в зависимости от версии Python и его реализации.
Главное — функция iter() возвращает объект, предназначенный для последовательного получения элементов.
Для словаря обычный итератор обходит ключи.
2. Итератор тоже является итерируемым объектом
Мы уже знаем, что список можно обойти циклом for:
numbers = [10, 20, 30]
for number in numbers:
print(number)
Результат:
10
20
30
Но итератор тоже можно передать в for:
numbers = [10, 20, 30]
iterator = iter(numbers)
for number in iterator:
print(number)
Результат будет точно таким же:
10
20
30
Таким образом, каждый итератор является итерируемым объектом.
Но далеко не каждый итерируемый объект является итератором.
Например, обычный список — итерируемый объект, но не итератор.
3. Список можно обходить многократно
Рассмотрим:
numbers = [10, 20, 30]
for number in numbers:
print(number)
print('---')
for number in numbers:
print(number)
Результат:
10
20
30
---
10
20
30
Список можно обходить сколько угодно раз.
Каждый новый цикл for начинает обход с первого элемента.
Почему?
Потому что список хранит свои элементы и при каждом новом обходе позволяет создать новый итератор.
4. Итератор расходуется при обходе
Теперь попробуем выполнить два цикла for с одним итератором:
numbers = [10, 20, 30]
iterator = iter(numbers)
for number in iterator:
print(number)
print('---')
for number in iterator:
print(number)
Результат:
10
20
30
---
Второй цикл ничего не вывел.
Почему?
Потому что первый цикл уже получил все элементы итератора.
Такой итератор называется исчерпанным (exhausted).
В отличие от обычного списка, итератор не начинает обход заново при повторном использовании.
Важно: это не означает, что исходный список стал пустым.
print(numbers)
# [10, 20, 30]
Список по-прежнему содержит все свои элементы.
Исчерпан только итератор, который мы создали для его обхода.
5. Итератор расходуют не только циклы for
Предположим, мы создали итератор:
iterator = iter([10, 20, 30])
Теперь передадим его в класс set:
numbers = set(iterator)
print(numbers)
# {10, 20, 30}
Порядок вывода элементов множества может отличаться.
А теперь попробуем повторить операцию:
numbers = set(iterator)
print(numbers)
# set()
Мы получили пустое множество.
Причина та же: при первом преобразовании set() уже получил все элементы итератора.
Аналогично работают:
list(iterator)
tuple(iterator)
sum(iterator)
sorted(iterator)
и многие другие функции, классы и методы, которые принимают итерируемые объекты.
Они последовательно запрашивают элементы. Поэтому переданный им итератор расходуется.
Не имеет значения, кто именно получает элементы:
- написанный нами цикл
for; - встроенная функция;
- метод коллекции;
- конструктор
list,setилиtuple.
Все они используют общий механизм итерации.
6. Как работает цикл for
Рассмотрим обычный цикл:
numbers = [10, 20, 30]
for number in numbers:
print(number)
На самом деле for не обращается к элементам списка по индексам напрямую.
В общих чертах он выполняет следующие действия:
- Получает итератор из переданного объекта.
- Запрашивает у него следующий элемент.
- Выполняет тело цикла.
- Снова запрашивает следующий элемент.
- Завершает работу, когда элементов больше нет.
Упрощённо это можно представить так:
Итерируемый объект
↓
iter()
↓
Итератор
↓
next()
↓
Элемент
↓
Тело цикла
↓
Запрос следующего элемента
↓
...
Теперь познакомимся с функцией, которая позволяет получать элементы вручную.
7. Функция next()
Встроенная функция:
next()
получает следующий элемент из итератора.
Например:
numbers = [10, 20, 30]
iterator = iter(numbers)
print(next(iterator))
# 10
print(next(iterator))
# 20
print(next(iterator))
# 30
Каждый вызов next() возвращает следующий элемент.
Обратите внимание: мы нигде не указывали индексы.
Не писали:
numbers[0]
numbers[1]
numbers[2]
Итератор самостоятельно отслеживает, какой элемент нужно отдать следующим.
8. Исключение StopIteration
Что произойдёт, если после получения всех трёх элементов вызвать next() ещё раз?
iterator = iter([10, 20, 30])
print(next(iterator))
print(next(iterator))
print(next(iterator))
print(next(iterator))
Последний вызов приведёт к исключению:
StopIteration
Это специальное исключение, которое сообщает:
Итератор больше не может предоставить следующий элемент.
Именно так итератор сигнализирует о завершении обхода.
После возникновения StopIteration корректно реализованный итератор остаётся исчерпанным.
Последующие вызовы next() также будут приводить к StopIteration.
9. Почему for не падает с StopIteration
Мы уже много раз обходили коллекции циклом for и не получали подобного исключения.
Почему?
Потому что цикл for обрабатывает окончание итератора автоматически.
Когда итератор сообщает:
StopIteration
цикл понимает, что обход завершён, и прекращает работу.
Внутри реализации Python этот механизм работает без необходимости писать собственную обработку исключения.
Позже мы познакомимся с конструкцией:
try
except
и сможем самостоятельно обрабатывать подобные ситуации.
10. Функция next() принимает именно итератор
Рассмотрим:
numbers = [10, 20, 30]
print(next(numbers))
Этот код приведёт к:
TypeError: 'list' object is not an iterator
Почему?
Потому что список — итерируемый объект, но не итератор.
Правильный вариант:
numbers = [10, 20, 30]
iterator = iter(numbers)
print(next(iterator))
# 10
Или короче:
print(next(iter(numbers)))
# 10
Важно запомнить разницу:
iter()
→ получает итератор
next()
→ получает следующий элемент итератора
11. Итератор помнит место остановки
Это одна из самых полезных возможностей итераторов.
Например:
iterator = iter([10, 20, 30, 40, 50])
print(next(iterator))
# 10
print(next(iterator))
# 20
Мы получили два элемента.
Но остальные никуда не исчезли.
print(next(iterator))
# 30
Итератор продолжил работу именно с того места, где остановился.
Он не начал обход заново.
Поэтому итератор удобно использовать, когда необходимо получать данные постепенно.
Например:
- сначала обработать несколько элементов;
- затем выполнить другие действия;
- позже продолжить обработку;
- снова остановиться;
- продолжить ещё раз.
12. Два цикла for с остановкой через break
Создадим итератор:
iterator = iter([10, 20, 30, 40, 50])
Первый цикл:
for number in iterator:
print(number)
if number == 20:
break
Результат:
10
20
Цикл завершился досрочно.
Но итератор ещё не исчерпан.
Поэтому теперь запустим второй цикл:
for number in iterator:
print(number)
Результат:
30
40
50
Второй цикл продолжил обход с оставшегося элемента.
Это главное отличие от обычного списка, при повторном обходе которого создаётся новый итератор.
13. Совмещаем next() и for
Получать элементы можно разными способами, используя один и тот же итератор.
Например:
iterator = iter([10, 20, 30, 40, 50, 60])
print(next(iterator))
# 10
Теперь запустим цикл:
for number in iterator:
print(number)
if number == 30:
break
Результат:
20
30
Дальше снова используем next():
print(next(iterator))
# 40
И ещё один цикл:
for number in iterator:
print(number)
Результат:
50
60
Таким образом, мы получили элементы несколькими частями:
next() → 10
for → 20, 30
next() → 40
for → 50, 60
Все операции работали с одним итератором и одной текущей позицией обхода.
14. Повторный вызов iter() для итератора
Есть ещё одна интересная особенность.
Если передать обычный список в iter() два раза, мы получим два самостоятельных итератора:
numbers = [10, 20, 30]
first = iter(numbers)
second = iter(numbers)
print(first is second)
# False
Но если передать в iter() уже существующий итератор:
iterator = iter(numbers)
same_iterator = iter(iterator)
print(iterator is same_iterator)
# True
Будет возвращён тот же самый объект итератора.
Именно поэтому повторный цикл for не начинает обход существующего итератора заново.
15. Экономия оперативной памяти
Итераторы часто очень экономно используют оперативную память.
Посмотрим на пример.
Создадим множество из 100 000 целых чисел:
from sys import getsizeof
numbers = set(range(100_000))
Теперь создадим итератор:
iterator = iter(numbers)
Сравним размеры объектов:
print(getsizeof(numbers))
print(getsizeof(iterator))
В CPython множество такого размера может занимать несколько мегабайт, а сам объект итератора — всего несколько десятков байт.
Точные значения зависят от версии Python и платформы.
Почему разница настолько большая?
Потому что множество хранит собственную структуру данных и ссылки на содержащиеся в нём объекты.
А обычному итератору множества не требуется создавать второе такое же множество.
Ему достаточно хранить служебную информацию для обхода исходного объекта, в том числе ссылку на него и текущее состояние итерации.
Упрощённо:
Множество
├── элемент
├── элемент
├── элемент
├── ...
└── элемент
Итератор
├── ссылка на множество
└── состояние обхода
Важное уточнение
Маленький размер самого итератора не означает, что вся исходная коллекция исчезла из памяти.
В нашем примере множество по-прежнему существует.
Более того, пока итератор использует это множество, он обычно удерживает ссылку на него.
Таким образом, мы сэкономили память на создании дополнительной коллекции, а не освободили память исходной.
В дальнейшем мы познакомимся с генераторами и другими итераторами, которые позволяют обрабатывать большие потоки данных, вообще не создавая заранее коллекцию со всеми элементами.
Также помним, что getsizeof() показывает непосредственный размер объекта, а не обязательно весь объём памяти, занимаемый объектами, на которые он ссылается.
16. Итераторы работают лениво
Итератору не обязательно заранее получать все элементы.
Он предоставляет очередное значение тогда, когда его запрашивают.
Например:
iterator = iter([10, 20, 30])
print(next(iterator))
# 10
Оставшиеся элементы пока не запрашивались.
При следующем вызове:
print(next(iterator))
# 20
получаем следующий элемент.
Такой подход часто называют ленивым получением элементов.
Это немного напоминает знакомый нам range, который тоже не создаёт заранее обычный список со всеми целыми числами.
Но range сам по себе не является итератором: он поддерживает длину, индексацию и повторные обходы.
17. Оператор in тоже может расходовать итератор
Мы знаем оператор:
in
Он проверяет наличие значения.
Например:
numbers = [10, 20, 30]
print(20 in numbers)
# True
Обычный список после такой проверки не расходуется.
Но с итератором ситуация другая.
iterator = iter([10, 20, 30, 40, 50])
print(30 in iterator)
# True
Чтобы найти 30, Python последовательно получил:
10
20
30
После обнаружения нужного элемента поиск остановился.
Проверим, что осталось:
print(list(iterator))
# [40, 50]
Элементы до найденного значения, включая само найденное значение, уже были получены из итератора.
18. Если элемент не найден
iterator = iter([10, 20, 30, 40])
print(100 in iterator)
# False
Чтобы убедиться, что значения 100 нет, Python пришлось проверить все элементы.
Теперь:
print(list(iterator))
# []
Итератор полностью исчерпан.
Таким образом, проверка через in может менять состояние итератора.
Для обычных встроенных итераторов поиск принадлежности выполняется посредством последовательного получения элементов.
Это важный момент, о котором легко забыть.
19. Изменение исходной коллекции
Мы уже выяснили, что обычный итератор списка не создаёт отдельную копию списка.
Поэтому изменение исходного списка во время обхода может повлиять на работу итератора.
Посмотрим на два примера.
Добавление элемента через append()
numbers = [10, 20, 30]
iterator = iter(numbers)
print(next(iterator))
# 10
print(next(iterator))
# 20
print(next(iterator))
# 30
Мы получили три элемента.
Теперь добавим четвёртый:
numbers.append(40)
И снова вызовем:
print(next(iterator))
# 40
Итератор увидел новый элемент.
В обычном CPython итератор списка учитывает текущую длину исходного списка при продолжении обхода.
Обратите внимание: мы добавили элемент до того, как очередной вызов next() сообщил об окончании итерации.
После настоящего завершения через StopIteration итератор не должен возобновлять обход.
20. Изменение индексов через insert()
Рассмотрим ещё более интересную ситуацию.
numbers = [10, 20, 30]
iterator = iter(numbers)
Получим первый элемент:
print(next(iterator))
# 10
Теперь вставим новый элемент в начало списка:
numbers.insert(0, 5)
print(numbers)
# [5, 10, 20, 30]
Обратите внимание, что число 10 переместилось с индекса 0 на индекс 1.
Теперь снова вызовем:
print(next(iterator))
# 10
Мы получили число 10 второй раз!
Почему?
Потому что при первом запросе итератор получил элемент с индекса 0.
После этого его следующая позиция стала соответствовать индексу 1.
Но мы вставили новый элемент в начало списка.
В результате старый элемент 10 переместился на индекс 1, откуда итератор и получил его повторно.
Это показывает, что итератор списка отслеживает позицию обхода, а не обязательно запоминает каждый ранее полученный элемент.
Практическое правило: не изменяйте размер списка во время обхода его итератором, если специально не рассчитываете на подобное поведение.
У других коллекций последствия изменения во время итерации могут отличаться. Например, изменение размера словаря или множества при обходе обычно приводит к RuntimeError.
21. Как самостоятельно реализовать поведение цикла for
Мы уже знаем:
iter()
next()
Теперь можем написать функцию, которая будет работать по принципу обычного цикла for.
Используем:
from collections.abc import Iterable
from typing import Any
from collections.abc import Iterable
from typing import Any
def my_for(
iterable: Iterable[Any],
) -> None:
iterator = iter(iterable)
while True:
try:
element = next(iterator)
except StopIteration:
return
print(element)
Проверим:
my_for([10, 20, 30])
Результат:
10
20
30
Разбираем алгоритм
Сначала:
iterator = iter(iterable)
получаем итератор.
Затем запускаем бесконечный цикл:
while True:
Внутри пытаемся получить очередной элемент:
element = next(iterator)
Если элемент получен, выводим его:
print(element)
Если итератор закончился, возникает:
StopIteration
И управление переходит в блок:
except StopIteration:
return
Функция завершает работу.
Пока мы ещё подробно не изучали try и except, но здесь важно понять общий принцип.
Это не полноценная реализация синтаксической конструкции for, а учебная модель механизма её работы.
22. Второй аргумент функции next()
Мы уже знаем:
next(iterator)
Но существует и второй вариант:
next(iterator, default)
Второй аргумент является необязательным.
Он позволяет указать объект, который нужно вернуть, если итератор закончился.
Например:
iterator = iter([10, 20])
print(next(iterator, None))
# 10
print(next(iterator, None))
# 20
print(next(iterator, None))
# None
Теперь исключение StopIteration не возникает.
Вместо него возвращается:
None
И если продолжить:
print(next(iterator, None))
# None
print(next(iterator, None))
# None
результат останется таким же.
23. Значение по умолчанию может быть любым
Например:
iterator = iter([10, 20])
print(next(iterator, 'END'))
# 10
print(next(iterator, 'END'))
# 20
print(next(iterator, 'END'))
# END
Или:
iterator = iter([])
print(next(iterator, 0))
# 0
Таким образом, второй аргумент помогает обрабатывать завершение итерации без необходимости перехватывать исключение.
Нюанс с None
Если исходный итератор сам может возвращать None, такой вызов:
next(iterator, None)
не позволяет отличить настоящий элемент None от окончания итератора.
В подобных ситуациях лучше использовать try/except StopIteration либо отдельный уникальный объект-маркер.
24. Второй вариант функции iter()
Теперь рассмотрим другую, менее очевидную возможность.
Оказывается, iter() можно вызывать с двумя аргументами:
iter(callable_object, sentinel)
Здесь:
- первый аргумент — вызываемый объект, например функция;
- второй аргумент — специальное значение остановки, называемое sentinel.
В этом варианте мы не преобразуем обычную коллекцию в итератор.
Вместо этого создаём итератор, который вызывает переданную функцию при каждом запросе следующего элемента.
Если функция вернёт значение, равное sentinel, итерация завершится.
Само значение остановки в результат не включается.
25. Пример с функцией чтения команд
Предположим, у нас есть очередь команд:
commands = [
'start',
'pause',
'resume',
'stop',
'restart',
]
Создадим функцию, которая получает следующую команду:
def read_command() -> str:
if commands:
return commands.pop(0)
return 'stop'
Теперь создадим итератор:
iterator = iter(read_command, 'stop')
Обратите внимание:
read_command
передаётся без круглых скобок.
Мы передаём сам объект функции.
Второй аргумент:
'stop'
— значение, при котором итерация должна закончиться.
Обойдём итератор:
for command in iterator:
print(command)
Результат:
start
pause
resume
Почему stop не вывелся?
Потому что при получении этой строки итератор завершил работу.
Команда restart, расположенная после stop, также не была обработана.
26. Как работает iter(function, sentinel)
Упрощённый алгоритм выглядит так:
Создали итератор
↓
Запросили элемент
↓
Вызвали функцию
↓
Получили значение
↓
Сравнили с sentinel
↓
Совпадает?
├── Да → StopIteration
└── Нет → вернуть значение
После возврата значения всё повторяется при следующем запросе.
Важно: функция вызывается без аргументов, поэтому передавать в такой iter() нужно вызываемый объект, который можно вызвать без обязательных параметров.
Сравнение со значением остановки выполняется через равенство ==, а не через is.
27. Ещё один пример — получение чисел
Создадим источник значений:
source = iter([2, 4, 6, 0, 8, 10])
Теперь функцию:
def read_number() -> int:
return next(source, 0)
И создадим итератор:
iterator = iter(read_number, 0)
Получим элементы:
print(list(iterator))
# [2, 4, 6]
Что произошло?
Функция последовательно вернула:
2
4
6
0
Когда был получен 0, итератор остановился.
Числа 8 и 10 не были запрошены.
28. Третий пример — ввод пользователя
Двухаргументный iter() можно применять и со встроенной функцией:
input()
Она является вызываемым объектом.
Например:
for command in iter(input, 'exit'):
print(f'Команда: {command}')
Теперь программа будет запрашивать ввод пользователя.
Если ввести:
start
получим:
Команда: start
Если ввести:
pause
получим:
Команда: pause
А если ввести:
exit
цикл завершится.
Потому что это значение мы указали как sentinel.
Такой механизм удобен, когда мы хотим повторять вызов функции до получения определённого результата.
29. Длина и индексы итераторов
Рассмотрим обычный список:
numbers = [10, 20, 30]
Мы можем получить его длину:
print(len(numbers))
# 3
И обратиться по индексу:
print(numbers[0])
# 10
Но если создать стандартный итератор списка:
iterator = iter(numbers)
то:
len(iterator)
приведёт к TypeError.
А:
iterator[0]
тоже приведёт к TypeError.
Почему?
Потому что стандартный итератор списка не предоставляет интерфейсы длины и индексации.
Он предназначен для последовательного получения элементов.
При этом надо понимать: сам протокол итератора не запрещает пользовательскому объекту дополнительно поддерживать len() или индексацию.
Просто обычные встроенные итераторы этих возможностей, как правило, не предоставляют.
30. Логическое значение итератора
Посмотрим:
iterator = iter([10, 20, 30])
print(bool(iterator))
# True
Теперь полностью исчерпаем его:
print(list(iterator))
# [10, 20, 30]
Повторим проверку:
print(bool(iterator))
# True
Хотя элементов больше нет, результат остался True.
Почему?
Потому что стандартный итератор списка не определяет своё логическое значение через количество оставшихся элементов.
Поэтому такой код:
if iterator:
print('Итератор не пуст')
не является правильной проверкой наличия оставшихся элементов.
Большинство стандартных итераторов остаются истинными даже после исчерпания.
Однако пользовательские классы могут реализовать собственное логическое поведение, поэтому это не абсолютное требование ко всем возможным итераторам Python.
31. Хеширование итераторов
Многие встроенные итераторы являются хешируемыми объектами.
Например:
iterator = iter([10, 20, 30])
print(hash(iterator))
Мы получим целое число.
Причём не важно, что сам список хешируемым не является.
Здесь мы хешируем объект итератора, а не исходный список.
Для стандартных итераторов хеш обычно связан с идентичностью объекта.
Но не следует путать хешируемость с неизменяемостью состояния.
Итератор постоянно меняет свою позицию при обходе.
Также хешируемость не является обязательным свойством любого пользовательского итератора.
32. Распаковка итератора
Поскольку итератор является итерируемым объектом, его можно распаковывать.
Например, с помощью *:
iterator = iter([10, 20, 30])
print(*iterator)
Результат:
10 20 30
Но после этой операции итератор уже исчерпан:
print(list(iterator))
# []
Почему?
Потому что для распаковки понадобилось получить все элементы.
33. Множественное присваивание
Итераторы также поддерживают распаковку через множественное присваивание.
Например:
iterator = iter([10, 20, 30])
first, second, third = iterator
print(first)
# 10
print(second)
# 20
print(third)
# 30
Главное, чтобы количество элементов соответствовало количеству переменных.
Если элементов больше или меньше, возникнет ValueError.
Также можно использовать распаковку со звёздочкой:
iterator = iter([10, 20, 30, 40])
first, *middle, last = iterator
print(first)
# 10
print(middle)
# [20, 30]
print(last)
# 40
Такая распаковка тоже расходует итератор.
Аннотация итераторов
34. Iterator из collections.abc
Мы уже знакомы с аннотацией:
Iterable
Но для итераторов существует отдельная аннотация:
Iterator
Импортируем:
from collections.abc import Iterator
Можно написать:
iterator: Iterator = iter([10, 20, 30])
Но обычно лучше указать тип возвращаемых элементов:
iterator: Iterator[int] = iter([10, 20, 30])
Или:
iterator: Iterator[str] = iter(['Python', 'SQL'])
Отличие от Iterable
Аннотация:
Iterable[int]
говорит:
Объект можно обходить, получая целые числа.
А:
Iterator[int]
говорит:
Это именно итератор, из которого можно непосредственно получать следующие целые числа через
next().
Поэтому:
from collections.abc import Iterable, Iterator
numbers: Iterable[int] = [10, 20, 30]
iterator: Iterator[int] = iter(numbers)
Для функции, которая сама вызывает iter(), чаще достаточно принимать Iterable.
Если же функция непосредственно вызывает next() у параметра, ей обычно требуется Iterator.
35. Проверка через isinstance()
Объект Iterator можно использовать с уже знакомой функцией:
isinstance()
Например:
from collections.abc import Iterable, Iterator
numbers = [10, 20, 30]
iterator = iter(numbers)
print(isinstance(numbers, Iterable))
# True
print(isinstance(numbers, Iterator))
# False
print(isinstance(iterator, Iterable))
# True
print(isinstance(iterator, Iterator))
# True
Это ещё раз показывает главное различие:
- список является итерируемым объектом;
- итератор списка является и итерируемым объектом, и итератором.
Практические функции с итераторами
36. Функция take()
Напишем функцию, которая принимает итерируемый объект и возвращает только первые n элементов.
Например:
take([10, 20, 30, 40], 2)
должна вернуть:
[10, 20]
Чтобы функция работала с элементами произвольного типа и сохраняла этот тип, используем уже знакомый TypeVar.
from collections.abc import Iterable
from typing import TypeVar
T = TypeVar('T')
def take(
iterable: Iterable[T],
n: int,
) -> list[T]:
iterator = iter(iterable)
result: list[T] = []
for _ in range(n):
try:
item = next(iterator)
except StopIteration:
break
result.append(item)
return result
Проверим:
print(take([10, 20, 30, 40], 3))
# [10, 20, 30]
И:
print(take(range(100), 5))
# [0, 1, 2, 3, 4]
Как работает функция
Сначала получаем итератор:
iterator = iter(iterable)
Создаём список результата:
result: list[T] = []
Дальше запускаем цикл:
for _ in range(n):
На каждой итерации получаем следующий элемент:
item = next(iterator)
И добавляем его в список:
result.append(item)
Если итератор закончится раньше, чем мы получим n элементов, обработка StopIteration завершит цикл.
В итоге функция возвращает полученные значения.
Здесь мы использовали try/except, чтобы корректно работать даже с итераторами, содержащими None.
Для коллекций, про которые мы точно знаем, что None внутри не встретится, можно было бы использовать next(iterator, None).
37. Функция skip_and_take()
Теперь усложним задачу.
Предположим, нам нужно:
- Пропустить несколько первых элементов.
- Забрать определённое количество следующих.
Например:
skip_and_take(
[10, 20, 30, 40, 50],
skip=2,
take_count=2,
)
Должна вернуть:
[30, 40]
Реализация:
from collections.abc import Iterable
from typing import TypeVar
T = TypeVar('T')
def skip_and_take(
iterable: Iterable[T],
skip: int,
take_count: int,
) -> list[T]:
iterator = iter(iterable)
for _ in range(skip):
try:
next(iterator)
except StopIteration:
return []
result: list[T] = []
for _ in range(take_count):
try:
item = next(iterator)
except StopIteration:
break
result.append(item)
return result
Используем:
print(
skip_and_take(
[10, 20, 30, 40, 50],
skip=2,
take_count=2,
)
)
# [30, 40]
Разбираем
Первый цикл:
for _ in range(skip):
next(iterator)
получает и пропускает начальные элементы.
Второй цикл получает нужное количество следующих элементов и сохраняет их в список.
Такой подход позволяет обрабатывать данные по частям.
Можно ли обойтись без итератора?
Для обычного списка можно написать:
numbers[2:4]
И это будет гораздо проще.
Но наша функция принимает любой подходящий итерируемый объект.
В частности, она может работать с объектами, которые не поддерживают срезы и обычные индексы.
Именно в подобных ситуациях итераторы особенно полезны.
38. Один итератор можно продолжать использовать после функции
Рассмотрим ещё одну важную особенность.
iterator = iter([10, 20, 30, 40, 50])
Теперь передадим его в take():
print(take(iterator, 2))
# [10, 20]
А затем снова обратимся к этому же итератору:
print(list(iterator))
# [30, 40, 50]
Почему?
Потому что функция получила уже существующий итератор.
Вызов:
iter(iterator)
вернул тот же объект.
Поэтому take() израсходовала только два элемента, а остальные остались доступными.
Но если передать обычный список, сама коллекция никуда не исчезнет и при следующем обходе снова будет доступна с начала.
39. Одновременный обход двух итерируемых объектов
Раньше мы могли одновременно обращаться к элементам двух списков через индексы.
Например:
first = [10, 20, 30]
second = ['A', 'B', 'C']
for index in range(len(first)):
print(first[index], second[index])
Результат:
10 A
20 B
30 C
Но такой способ требует поддержки индексации.
А что, если перед нами два множества set, у которых индексов нет?
На помощь приходят итераторы.
first = {10, 20, 30}
second = {'A', 'B', 'C'}
first_iterator = iter(first)
second_iterator = iter(second)
for _ in range(min(len(first), len(second))):
first_value = next(first_iterator)
second_value = next(second_iterator)
print(first_value, second_value)
На каждой итерации мы получаем по одному элементу из каждого множества.
При этом порядок элементов в множествах не гарантирован, поэтому конкретные пары могут отличаться.
Почему используем min()?
Потому что множества могут иметь разное количество элементов.
Если один итератор закончится раньше другого, следующий вызов next() приведёт к StopIteration.
Поэтому здесь мы ограничиваем количество повторений длиной меньшего множества.
Вскоре мы познакомимся со встроенной функцией:
zip()
которая позволяет решать подобные задачи значительно проще.
40. Получаем сразу два элемента за одну итерацию
Предположим, у нас есть множество:
numbers = {10, 20, 30, 40, 50, 60}
Обычных индексов у него нет.
Но мы можем создать итератор:
iterator = iter(numbers)
И на каждой итерации цикла получать сразу два элемента:
for _ in range(len(numbers) // 2):
first = next(iterator)
second = next(iterator)
print(first, second)
Здесь:
len(numbers) // 2
определяет, сколько полных пар мы можем получить.
На каждой итерации выполняется два вызова:
next(iterator)
next(iterator)
Поэтому итератор продвигается сразу на два элемента.
Порядок значений множества не гарантирован.
Если количество элементов нечётное, после такого цикла останется один необработанный элемент.
41. Получаем сразу три элемента
Аналогично можно получать по три элемента:
numbers = {10, 20, 30, 40, 50, 60}
iterator = iter(numbers)
for _ in range(len(numbers) // 3):
first = next(iterator)
second = next(iterator)
third = next(iterator)
print(first, second, third)
Это ещё один пример того, что итератор позволяет управлять количеством получаемых элементов.
Для этого не требуется поддержка индексации.
Главное — не запрашивать больше элементов, чем осталось в итераторе, если мы не предусмотрели обработку StopIteration.
42. Ограничения и особенности итераторов
У итераторов есть несколько важных особенностей, которые необходимо учитывать.
| Возможность | Стандартный итератор коллекции |
|---|---|
Можно обойти через for |
Да |
Можно передать в list(), set(), tuple() |
Да |
Можно использовать next() |
Да |
| Помнит текущую позицию | Да |
| Расходуется при получении элементов | Да |
| Повторный обход начинается с начала | Нет |
iter(iterator) возвращает тот же итератор |
Да |
| Обычно требует немного собственной памяти | Да |
len(iterator) |
Обычно не поддерживается |
iterator[index] |
Обычно не поддерживается |
bool(iterator) показывает наличие элементов |
Нет |
Можно распаковать через * |
Да |
| Можно использовать множественное присваивание | Да |
Можно проверить наличие через in |
Да, но проверка расходует элементы |
Таблица описывает прежде всего обычные встроенные итераторы.
Пользовательские итераторы могут иметь дополнительные возможности, но все они должны соблюдать основной протокол итерации.
43. Главное отличие коллекции от итератора
Представим список:
numbers = [10, 20, 30]
Он хранит коллекцию значений.
Мы можем:
- обращаться к элементам по индексам;
- получать длину;
- многократно обходить список;
- изменять его содержимое.
А итератор:
iterator = iter(numbers)
предназначен в первую очередь для последовательного получения значений.
Он запоминает состояние обхода.
При этом обычный итератор списка не хранит отдельную копию всех элементов.
Можно представить это так:
СПИСОК
[10, 20, 30]
↑
Можно начать новый обход
с первого элемента
ИТЕРАТОР
10 → 20 → 30 → StopIteration
↑
Текущая позиция
Итератор не обязан предоставлять доступ к произвольным элементам по индексу.
Его задача — возвращать следующий элемент, когда он потребуется.
Главное по теме
Итератор — это объект, позволяющий последовательно получать значения из некоторого источника данных.
Для получения итератора используем:
iterator = iter(iterable)
Для получения следующего элемента:
next(iterator)
Если элементов больше нет, возникает:
StopIteration
Чтобы избежать исключения, можно указать значение по умолчанию:
next(iterator, None)
Итератор можно обходить циклом:
for item in iterator:
print(item)
Но после полного обхода обычный итератор остаётся исчерпанным.
Он также помнит место остановки, поэтому мы можем получать элементы постепенно:
iterator = iter([10, 20, 30])
print(next(iterator))
# 10
print(next(iterator))
# 20
print(next(iterator))
# 30
Двухаргументный вариант iter() позволяет создать итератор из вызываемого объекта:
iter(function, sentinel)
Функция будет вызываться при каждом запросе элемента, пока не вернёт значение, равное sentinel.
Для аннотации используем:
from collections.abc import Iterator
Например:
iterator: Iterator[int] = iter([10, 20, 30])
Важно различать:
Iterable[int]
— объект, который можно обходить;
Iterator[int]
— объект, из которого можно непосредственно получать следующие элементы.
Основные особенности итераторов:
- Они поддерживают цикл
for. - Позволяют получать значения через
next(). - Сохраняют состояние обхода.
- После полного исчерпания не начинают обход заново.
- Часто требуют совсем немного дополнительной оперативной памяти.
- Позволяют работать с объектами без обычной индексации.
- Могут расходоваться при передаче в функции и методы, которые последовательно обрабатывают элементы.
В следующих темах познакомимся с генераторами и другими инструментами Python, основанными на механизме итерации.
Официальная документация: