Как сделать из кортежа итератор?

# Как сделать из кортежа итератор?

Кортежи в Python уже итерируемы, но есть разница между итерируемым объектом (iterable) и итератором (iterator). Разберём как преобразовать кортеж в итератор и в чём различие.

Различие: Iterable vs Iterator

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

Итерируемый объект — это объект, который может быть использован в цикле for или с функцией iter():

# Кортеж — это итерируемый объект
my_tuple = (1, 2, 3, 4)

# Используем в цикле (это работает, потому что кортеж итерируемый)
for item in my_tuple:
    print(item)

# Проверка: объект итерируемый если у него есть метод __iter__
print(hasattr(my_tuple, '__iter__'))  # True
print(hasattr(my_tuple, '__getitem__'))  # True (кортежи можно индексировать)

Iterator (Итератор)

Итератор — это объект, у которого есть методы __iter__() и __next__():

# Кортеж НЕ является итератором
my_tuple = (1, 2, 3)

print(hasattr(my_tuple, '__next__'))  # False <- Нет метода __next__

# Кортеж — это итерируемый объект, но НЕ итератор
# Когда мы делаем for item in tuple, Python внутренне вызывает iter(tuple)

Преобразование кортежа в итератор

Способ 1: Функция iter()

Это самый простой способ:

my_tuple = (1, 2, 3, 4, 5)

# Преобразуем кортеж в итератор
my_iterator = iter(my_tuple)

# Теперь это настоящий итератор
print(type(my_iterator))  # <class 'tuple_iterator'>
print(hasattr(my_iterator, '__next__'))  # True

# Получаем элементы по одному
print(next(my_iterator))  # 1
print(next(my_iterator))  # 2
print(next(my_iterator))  # 3
print(next(my_iterator))  # 4
print(next(my_iterator))  # 5
# print(next(my_iterator))  # StopIteration исключение!

Способ 2: Используем в цикле with try/except

my_tuple = ('a', 'b', 'c')
my_iterator = iter(my_tuple)

while True:
    try:
        item = next(my_iterator)
        print(item)
    except StopIteration:
        break  # Итератор исчерпан

Функция iter() с двумя аргументами

За пределами кортежей, iter() может использоваться для создания итератора с sentinel значением:

# iter(callable, sentinel)
# Вызывает callable() до тех пор, пока оно не вернёт sentinel

import random

# Пример: генерируем случайные числа до тех пор, пока не выпадет 0
random_numbers = iter(lambda: random.randint(-2, 2), 0)

for num in random_numbers:
    print(f"Число: {num}")  # Печатает числа до -2 до 2, но не 0

# Практический пример: читаем файл блоками
with open('large_file.txt', 'rb') as f:
    # Читаем файл по 4096 байт до EOF
    file_reader = iter(lambda: f.read(4096), b'')
    for chunk in file_reader:
        print(f"Прочитан блок размером {len(chunk)} байт")

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

Способ 1: Класс с iter и next

class TupleIterator:
    """Пользовательский итератор для кортежа"""
    
    def __init__(self, tuple_data):
        self.tuple_data = tuple_data
        self.index = 0
    
    def __iter__(self):
        """Возвращает сам итератор"""
        return self
    
    def __next__(self):
        """Возвращает следующий элемент"""
        if self.index >= len(self.tuple_data):
            raise StopIteration  # Сигнал завершения итерации
        
        value = self.tuple_data[self.index]
        self.index += 1
        return value

# Использование
my_tuple = (10, 20, 30)
my_iterator = TupleIterator(my_tuple)

for item in my_iterator:
    print(item)  # 10, 20, 30

Способ 2: Generator функция (самый Pythonic способ)

def tuple_to_iterator(tuple_data):
    """Generator: самый простой способ создать итератор"""
    for item in tuple_data:
        yield item

# Использование
my_tuple = ('x', 'y', 'z')
my_iterator = tuple_to_iterator(my_tuple)

# Это генератор (вид итератора)
print(type(my_iterator))  # <class 'generator'>

for item in my_iterator:
    print(item)  # x, y, z

Generator Expression (самый компактный способ)

# Генераторное выражение — это кортеж -> итератор
my_tuple = (1, 2, 3, 4)

# Вариант 1: Простое генераторное выражение
my_iterator = (item for item in my_tuple)
print(type(my_iterator))  # <class 'generator'>

# Вариант 2: С преобразованием
my_iterator = (item * 2 for item in my_tuple)
for item in my_iterator:
    print(item)  # 2, 4, 6, 8

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

Пример 1: Обработка большого кортежа по частям

def chunk_iterator(data: tuple, chunk_size: int):
    """Generator: преобразует кортеж в итератор по частям"""
    iterator = iter(data)
    while True:
        chunk = tuple(itertools.islice(iterator, chunk_size))
        if not chunk:
            break
        yield chunk

import itertools

my_tuple = tuple(range(10))  # (0, 1, 2, ..., 9)

for chunk in chunk_iterator(my_tuple, chunk_size=3):
    print(chunk)  # (0, 1, 2), (3, 4, 5), (6, 7, 8), (9)

Пример 2: Фильтрированный итератор

def filtered_iterator(data: tuple, predicate):
    """Generator: возвращает итератор только тех элементов,
    которые удовлетворяют условию"""
    for item in data:
        if predicate(item):
            yield item

my_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

# Итератор только чётных чисел
evens = filtered_iterator(my_tuple, lambda x: x % 2 == 0)
for num in evens:
    print(num)  # 2, 4, 6, 8, 10

Пример 3: Двусторонний итератор

def reverse_iterator(data: tuple):
    """Generator: итератор в обратном порядке"""
    for i in range(len(data) - 1, -1, -1):
        yield data[i]

my_tuple = ('a', 'b', 'c', 'd')

for item in reverse_iterator(my_tuple):
    print(item)  # d, c, b, a

# Или просто
for item in reversed(my_tuple):  # Встроенная функция
    print(item)  # d, c, b, a

Сравнение подходов

my_tuple = (1, 2, 3)

# 1. Встроенная функция (ЛУЧШИЙ вариант)
iterator1 = iter(my_tuple)

# 2. Generator выражение
iterator2 = (x for x in my_tuple)

# 3. Generator функция
def gen():
    for x in my_tuple:
        yield x
iterator3 = gen()

# 4. Класс с __iter__ и __next__ (для сложной логики)
class CustomIterator:
    def __init__(self, data):
        self.data = data
        self.index = 0
    
    def __iter__(self):
        return self
    
    def __next__(self):
        if self.index >= len(self.data):
            raise StopIteration
        result = self.data[self.index]
        self.index += 1
        return result

iterator4 = CustomIterator(my_tuple)

# Все варианты работают одинаково
for i in [iterator1, iterator2, iterator3, iterator4]:
    print(list(i))  # [1, 2, 3] для каждого

Лучшие практики

1. Для простого преобразования — используй iter(tuple)
2. Для преобразования с логикой — используй generator выражение
3. Для сложной логики — используй generator функцию
4. Для очень сложных сценариев — создай класс с __iter__ и __next__

# ✅ ПРАВИЛЬНО
iterator = iter(my_tuple)  # Просто и ясно

# ✅ ХОРОШО
iterator = (x for x in my_tuple if x > 0)  # С логикой

# ✅ ОТЛИЧНО
def my_generator(data):
    for x in data:
        yield x * 2

iterator = my_generator(my_tuple)  # Переиспользуемая логика

Заключение

Кортежи — это итерируемые объекты, но не итераторы. Для преобразования в итератор:

• iter(tuple) — быстро и просто
• Generator выражение — с фильтрацией/трансформацией
• Generator функция — для переиспользуемой логики
• Класс — для очень сложных сценариев

Выбирай инструмент в зависимости от сложности задачи!