Что такое итерация?

# Что такое итерация в Python

Итерация — это процесс последовательного обхода элементов какого-либо набора данных (списка, строки, словаря и т.д.) по одному.

Базовое определение

# Простой пример итерации
for item in [1, 2, 3, 4, 5]:
    print(item)
# Выведет: 1, 2, 3, 4, 5 по одному

Каждый проход цикла — это одна итерация. Всего здесь 5 итераций.

Итерируемые объекты (Iterables)

Итерируемый объект — это что-то, по чему можно пройтись в цикле.

# Встроенные итерируемые типы
list_obj = [1, 2, 3]          # Список
str_obj = "hello"             # Строка
dict_obj = {"a": 1, "b": 2}  # Словарь (по ключам)
set_obj = {1, 2, 3}           # Множество
tuple_obj = (1, 2, 3)         # Кортеж
range_obj = range(5)          # Range объект

# Все они итерируемы
for item in list_obj:   pass
for char in str_obj:    pass
for key in dict_obj:    pass
for num in set_obj:     pass
for num in range_obj:   pass

Итераторы (Iterators)

Итератор — это объект, который позволяет итерировать и имеет состояние (помнит, где сейчас).

# Функция iter() создаёт итератор из итерируемого объекта
my_list = [1, 2, 3]
iterator = iter(my_list)

# Функция next() получает следующий элемент
print(next(iterator))  # 1
print(next(iterator))  # 2
print(next(iterator))  # 3
print(next(iterator))  # StopIteration — конец

Под капотом for цикл делает ровно это:

# Что происходит в цикле for
for item in my_list:
    print(item)

# Эквивалентно
iterator = iter(my_list)    # 1. Создать итератор
while True:
    try:
        item = next(iterator)  # 2. Получить следующий элемент
        print(item)
    except StopIteration:       # 3. Когда конец — выход
        break

Отличие между Iterable и Iterator

# ITERABLE — есть метод __iter__
my_list = [1, 2, 3]
print(hasattr(my_list, '__iter__'))  # True — это итерируемый

# ITERATOR — есть оба метода: __iter__ и __next__
iterator = iter(my_list)
print(hasattr(iterator, '__iter__'))   # True
print(hasattr(iterator, '__next__'))   # True — это итератор

# Важный момент: итератор можно итерировать, но список нельзя итерировать дважды
iterator = iter([1, 2, 3])
print(next(iterator))  # 1
print(next(iterator))  # 2
print(next(iterator))  # 3
print(next(iterator))  # StopIteration — конец
print(next(iterator))  # StopIteration — всё равно конец

# А список можно
my_list = [1, 2, 3]
for x in my_list: print(x)  # Работает
for x in my_list: print(x)  # Работает снова

Создание собственного итератора

# Класс итератора должен иметь __iter__ и __next__
class CountUp:
    def __init__(self, max):
        self.current = 0
        self.max = max
    
    def __iter__(self):
        return self
    
    def __next__(self):
        if self.current < self.max:
            self.current += 1
            return self.current
        else:
            raise StopIteration

counter = CountUp(3)
for num in counter:
    print(num)
# Выведет: 1, 2, 3

Создание собственного итерируемого объекта

# Итерируемый объект (но не итератор)
class CountUpIterable:
    def __init__(self, max):
        self.max = max
    
    def __iter__(self):
        # Возвращаем новый итератор каждый раз
        return CountUp(self.max)

counter = CountUpIterable(3)

# Можно итерировать несколько раз
for num in counter: print(num)  # 1, 2, 3
for num in counter: print(num)  # 1, 2, 3 (снова)

Генераторы (Generators)

Генератор — это специальный тип итератора, создаётся с помощью yield.

# Функция с yield — это генератор
def count_up(max):
    current = 0
    while current < max:
        current += 1
        yield current  # "Пауза" и вернуть значение

# Это генератор
gen = count_up(3)
print(type(gen))  # <class 'generator'>

# Итерируем его
for num in gen:
    print(num)
# Выведет: 1, 2, 3

# Генератор работает как итератор
print(next(gen))  # StopIteration — генератор уже исчерпан

Генераторы экономят память, т.к. не создают всё сразу:

# Список (всё в памяти сразу)
numbers_list = [x for x in range(1000000)]
# Использует 1 млн элементов в памяти

# Генератор (ленивое вычисление)
def number_gen():
    for x in range(1000000):
        yield x

gen = number_gen()
# Использует почти 0 памяти, значения генерируются по требованию
first = next(gen)  # Только при запросе

Функции для работы с итерацией

1. enumerate() — итерация с индексом

for index, item in enumerate(['a', 'b', 'c']):
    print(f"{index}: {item}")
# Выведет:
# 0: a
# 1: b
# 2: c

2. zip() — объединение нескольких итерируемых

names = ['Alice', 'Bob', 'Charlie']
ages = [25, 30, 35]

for name, age in zip(names, ages):
    print(f"{name}: {age}")
# Выведет:
# Alice: 25
# Bob: 30
# Charlie: 35

3. map() — применение функции к каждому элементу

numbers = [1, 2, 3, 4, 5]
squares = map(lambda x: x ** 2, numbers)
# map возвращает итератор
for square in squares:
    print(square)
# Выведет: 1, 4, 9, 16, 25

4. filter() — фильтрация элементов

numbers = [1, 2, 3, 4, 5, 6]
evens = filter(lambda x: x % 2 == 0, numbers)
for num in evens:
    print(num)
# Выведет: 2, 4, 6

Itertools — модуль для работы с итераторами

from itertools import count, cycle, repeat, chain

# count() — бесконечный счётчик
for i in count(1):
    if i > 3:
        break
    print(i)  # 1, 2, 3

# cycle() — повторение элементов циклически
for item in cycle(['A', 'B', 'C']):
    print(item)
    # Выведет: A, B, C, A, B, C, A, B, C, ... (бесконечно)

# repeat() — повторение значения N раз
for item in repeat('X', 3):
    print(item)  # X, X, X

# chain() — объединение нескольких итерируемых
for item in chain([1, 2], ['a', 'b'], range(2)):
    print(item)  # 1, 2, a, b, 0, 1

List/Dict/Set comprehensions

Это синтаксический сахар над итерацией:

# Вместо
result = []
for x in range(5):
    result.append(x ** 2)

# Пиши
result = [x ** 2 for x in range(5)]

# С фильтром
evens_squared = [x ** 2 for x in range(10) if x % 2 == 0]

# Dict comprehension
word_lengths = {word: len(word) for word in ['hello', 'world', 'python']}
# {'hello': 5, 'world': 5, 'python': 6}

Бесконечные итераторы

# Будьте осторожны с бесконечными итераторами
from itertools import count

for num in count():  # Никогда не кончится
    print(num)
    if num > 100:
        break  # Нужно явно выходить

Практические примеры

Пример 1: Потоковая обработка больших файлов

def read_file_lines(filename):
    with open(filename) as f:
        for line in f:  # f — итератор
            yield line.strip()  # Не загружает весь файл в память

for line in read_file_lines('huge_file.txt'):
    process(line)  # Обрабатываем строку за строкой

Пример 2: Ленивый парсинг JSON

import json

def parse_json_lines(filename):
    with open(filename) as f:
        for line in f:
            if line.strip():
                yield json.loads(line)

for record in parse_json_lines('data.jsonl'):
    print(record)  # Обрабатываем по одной строке

Ключевые понятия

• Итерируемый объект — есть метод __iter__(), возвращает итератор
• Итератор — есть методы __iter__() и __next__(), хранит состояние
• Итерация — процесс обхода элементов
• Генератор — функция с yield, это итератор с памятью эффективностью
• StopIteration — исключение, сигнализирующее конец итерации

Итерация — один из столпов Python, используется везде: от простых циклов до асинхронного кода.