Iterators/iterators.py - master - vanek0/import

Iterators/iterators.py
134 строки5 KB
vanek0
11 фев 2025, 10:18
11 фев 2025, 10:18d27b8bb

# Задание №1
class FlatIterator:
    def __init__(self, list_of_lists):
        self.list_of_lists = list_of_lists
        self.outer_index = 0
        self.inner_index = 0

    def __iter__(self):
        return self

    def __next__(self):
        while self.outer_index < len(self.list_of_lists):
            if self.inner_index < len(self.list_of_lists[self.outer_index]):
                item = self.list_of_lists[self.outer_index][self.inner_index]
                self.inner_index += 1  # Переход к следующему элементу во вложенном списке
                return item
            else:
                self.outer_index += 1  # Переход к следующему внешнему списку
                self.inner_index = 0    # Сбрасываем внутренний индекс

        # Если мы дошли до конца всех списков, вызываем StopIteration
        raise StopIteration()

# Пример использования
nested_list = [[1, 2], [3], [4, 5, 6]]
iterator = FlatIterator(nested_list)

for item in iterator:
    print(item)


# Задание №2
import types
def flat_generator(list_of_lists):
    for sublist in list_of_lists:
        for item in sublist:
            yield item  # Возвращаем каждый элемент
            print(item) # Выводим каждый элемент для проверки
def test_2():
    list_of_lists_1 = [
        ['a', 'b', 'c'],
        ['d', 'e', 'f', 'h', False],
        [1, 2, None]
    ]

    for flat_iterator_item, check_item in zip(
            flat_generator(list_of_lists_1),
            ['a', 'b', 'c', 'd', 'e', 'f', 'h', False, 1, 2, None]
    ):
        assert flat_iterator_item == check_item

    assert list(flat_generator(list_of_lists_1)) == ['a', 'b', 'c', 'd', 'e', 'f', 'h', False, 1, 2, None]
    assert isinstance(flat_generator(list_of_lists_1), types.GeneratorType)

if __name__ == '__main__':
    test_2()


# Задание №3
class FlatIterator:

    def __init__(self, list_of_list):
        self.list_of_list = list_of_list
        self.flat_list = []  # Список для хранения плоского представления элементов
        self._flatten(self.list_of_list)  # Запускаем процесс плоского представления
        self.index = 0  # Индекс для отслеживания текущего элемента

    def _flatten(self, nested_list):
        for element in nested_list:
            if isinstance(element, list):  # Если элемент - это список, продолжаем рекурсивный вызов
                self._flatten(element)
            else:
                self.flat_list.append(element)  # Добавляем элемент в плоский список

    def __iter__(self):
        return self  # Возвращаем сам объект как итератор

    def __next__(self):
        if self.index < len(self.flat_list):
            item = self.flat_list[self.index]
            self.index += 1
            print(item)
            return item
        else:
            raise StopIteration()  # Завершаем итерацию, когда все элементы перебраны


def test_3():
    list_of_lists_2 = [
        [['a'], ['b', 'c']],
        ['d', 'e', [['f'], 'h'], False],
        [1, 2, None, [[[[['!']]]]], []]
    ]

    for flat_iterator_item, check_item in zip(
            FlatIterator(list_of_lists_2),
            ['a', 'b', 'c', 'd', 'e', 'f', 'h', False, 1, 2, None, '!']
    ):
        assert flat_iterator_item == check_item

    assert list(FlatIterator(list_of_lists_2)) == ['a', 'b', 'c', 'd', 'e', 'f', 'h', False, 1, 2, None, '!']


if __name__ == '__main__':
    test_3()


# Задание #4
import types
def flat_generator(list_of_list):
    for element in list_of_list:
        if isinstance(element, list):  # Проверяем, является ли элемент списком
            yield from flat_generator(element)  # Если да, вызываем себя рекурсивно
        else:
            yield element  # Если нет, возвращаем элемент

def test_4():
    list_of_lists_2 = [
        [['a'], ['b', 'c']],
        ['d', 'e', [['f'], 'h'], False],
        [1, 2, None, [[[[['!']]]]], []]
    ]

    for flat_iterator_item, check_item in zip(
            flat_generator(list_of_lists_2),
            ['a', 'b', 'c', 'd', 'e', 'f', 'h', False, 1, 2, None, '!']
    ):
        assert flat_iterator_item == check_item

    assert list(flat_generator(list_of_lists_2)) == ['a', 'b', 'c', 'd', 'e', 'f', 'h', False, 1, 2, None, '!']
    assert isinstance(flat_generator(list_of_lists_2), types.GeneratorType)

if __name__ == '__main__':
    test_4()