Где используется итератор в Python?

Итераторы в Python: использование и практика

Итератор — это объект, который позволяет последовательно обходить элементы коллекции, одно за другим. Это один из фундаментальных паттернов Python.

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

Итератор — это объект, реализующий два метода:

• __iter__() — возвращает сам итератор
• __next__() — возвращает следующий элемент и поднимает StopIteration когда элементы кончились

# Пример простого итератора
class CountUp:
    def __init__(self, max):
        self.max = max
        self.current = 0
    
    def __iter__(self):
        return self
    
    def __next__(self):
        if self.current < self.max:
            self.current += 1
            return self.current
        else:
            raise StopIteration

# Использование
for num in CountUp(3):
    print(num)  # 1, 2, 3

Встроенные итераторы

Итераторы встроенных типов:

# Список
my_list = [1, 2, 3]
iter_list = iter(my_list)  # Создание итератора
print(next(iter_list))  # 1
print(next(iter_list))  # 2

# Словарь
user = {"name": "Alice", "age": 30}
for key in user:  # Итерирует по ключам
    print(key)  # name, age

for value in user.values():  # Итерирует по значениям
    print(value)  # Alice, 30

# Строка
for char in "Hello":
    print(char)  # H, e, l, l, o

Применение итераторов в практике

1. Циклы (for loops)

# For цикл — это синтаксический сахар над итератором
fruits = ["apple", "banana", "cherry"]

# Под капотом происходит:
iter_obj = iter(fruits)  # Создание итератора
while True:
    try:
        fruit = next(iter_obj)  # Получение следующего элемента
        print(fruit)
    except StopIteration:
        break  # Выход когда элементы кончились

2. Функция range() — ленивый итератор

# range() не создаёт список в памяти, это итератор
for i in range(1000000):
    print(i)

# Это эффективнее, чем:
for i in list(range(1000000)):
    print(i)  # Весь список хранится в памяти!

# Проверка:
print(type(range(10)))  # <class range>
print(type(iter(range(10))))  # <class range_iterator>

3. Функция enumerate()

# enumerate возвращает итератор пар (индекс, значение)
students = ["Alice", "Bob", "Charlie"]

for index, student in enumerate(students):
    print(f"{index}: {student}")
# Вывод:
# 0: Alice
# 1: Bob
# 2: Charlie

# Без итератора пришлось бы писать:
for index in range(len(students)):
    print(f"{index}: {students[index]}")

4. Функция zip() — объединение итераторов

names = ["Alice", "Bob", "Charlie"]
ages = [25, 30, 28]

# zip создаёт итератор кортежей
for name, age in zip(names, ages):
    print(f"{name}: {age}")

# Результат:
# Alice: 25
# Bob: 30
# Charlie: 28

5. Функция map() и filter() — функциональное программирование

# map() применяет функцию к каждому элементу (ленивая оценка)
numbers = [1, 2, 3, 4, 5]
squared = map(lambda x: x ** 2, numbers)
print(next(squared))  # 1 (первый элемент)
print(next(squared))  # 4 (второй элемент)

# filter() выбирает элементы по условию (тоже ленивая)
even = filter(lambda x: x % 2 == 0, numbers)
print(list(even))  # [2, 4]

# Без итераторов:
evens = [x for x in numbers if x % 2 == 0]  # List comprehension (тоже ленивое)

6. Генераторы — мощные итераторы

# Генератор — это упрощённый способ создания итератора
def countdown(n):
    while n > 0:
        yield n  # yield — это return для генераторов
        n -= 1

# Использование
for num in countdown(3):
    print(num)  # 3, 2, 1

# Генератор вычисляет значения по требованию (очень эффективно)
gen = countdown(1000000)  # Не создаёт 1000000 элементов в памяти
print(next(gen))  # 1000000
print(next(gen))  # 999999

7. Generator expressions — аналог list comprehension

# List comprehension (создаёт весь список в памяти)
rectangle = [x ** 2 for x in range(1000000)]  # Весь список в RAM

# Generator expression (лениво вычисляет значения)
squares_gen = (x ** 2 for x in range(1000000))  # Эффективно по памяти!
print(next(squares_gen))  # 0
print(next(squares_gen))  # 1

Практический пример: обработка больших файлов

# БЕЗ итератора (неэффективно)
def read_file_all(filename):
    with open(filename) as f:
        lines = f.readlines()  # Весь файл в памяти!
    return lines

# С итератором (эффективно)
def read_file_lazy(filename):
    with open(filename) as f:
        for line in f:  # f — это итератор! Строки читаются по одной
            yield line.strip()

# Использование
for line in read_file_lazy("huge_file.txt"):  # Обрабатываем 1 строку за раз
    process(line)

Преимущества итераторов

# ✅ Экономия памяти
range(1000000)  # Не создаёт миллион элементов в памяти

# ✅ Ленивое вычисление (lazy evaluation)
lines_gen = (line.strip() for line in open("file.txt"))
first_line = next(lines_gen)  # Только первая строка вычисляется

# ✅ Бесконечные последовательности
def infinite_counter():
    n = 0
    while True:
        yield n
        n += 1

# ✅ Композиция
data = range(1000000)
filtered = filter(lambda x: x % 2 == 0, data)
mapped = map(lambda x: x ** 2, filtered)
final = next(mapped)

Вывод

Итераторы используются повсеместно в Python — в циклах for, встроенных функциях (map, filter, zip), генераторах и с файловыми операциями. Они обеспечивают ленивое вычисление и экономят память, особенно при работе с большими объёмами данных. Понимание итераторов критично для написания эффективного Python-кода.