Итерируемый объект python что это
Итераторы в Python
Концепция итераторов никоим образом не специфична для Python. В самом общем виде это объект, который используется для перебора в цикле последовательности элементов. Однако разные языки программирования реализуют данную концепцию по-разному или не реализуют вовсе. В Python каждый цикл for использует итератор, в отличие от многих других языков. В данной статье мы поговорим про итераторы в Python. Кроме того, мы рассмотрим итерируемые объекты (англ. iterables) и т.н. nextables.
Итерируемые объекты
Обратите внимание, что итерируемый объект не обязательно является итератором. Поскольку на самом деле сам по себе он не выполняет итерацию. У вас может быть отдельный объект-итератор, который возвращается из итерируемого класса, а не класс, обрабатывающий свою собственную итерацию. Но об этом позже.
Итераторы
Перейдем к собственно итераторам, рабочей лошадке итерации (особенно в Python). Итераторы – это уровень абстракции, который инкапсулирует знания о том, как брать элементы из некоторой последовательности. Мы намеренно объясняем это в общем виде, поскольку «последовательность» может быть чем угодно, от списков и файлов до потоков данных из базы данных или удаленного сервиса. В итераторах замечательно то, что код, использующий итератор, даже не должен знать, какой источник используется. Вместо этого он может сосредоточиться только на одном, а именно: «Что мне делать с каждым элементом?».
Марк Лутц «Изучаем Python»
Скачивайте книгу у нас в телеграм
Итерация без итератора
Чтобы лучше понять преимущества итераторов, давайте кратко рассмотрим итерацию без итераторов. Примером итерации без итератора является классический цикл for в стиле C. Этот стиль существует не только в C, но и, например, в C++, go и JavaScript.
Пример того, как это выглядит в JavaScript:
Здесь мы видим, что данный тип цикла for должен работать как с извлечением, так и с действиями для каждого элемента.
Все циклы for в Python используют итераторы
Сначала давайте посмотрим на Python-эквивалент предыдущего примера, наиболее близкий к нему синтаксически:
Если вы внимательно посмотрите на пример на JavaScript, вы увидите, что мы сообщаем циклу, когда нужно завершить ( i ), а также — как инкременировать ( i++ ). Итак, чтобы приблизить код Python к такому уровню абстракции, нам нужно написать что-то вроде этого:
Протокол итератора в Python
Отметим, nextable – это не часто используемый термин, потому что его можно запросто превратить в итератор. Как видите, метод __iter__ для итераторов легко реализовать. Фактически, в определении итератора явно указано, что должен делать метод:
Теперь давайте превратим это в итератор, сделав «некстабельным». Метод __next__ должен возвращать следующий объект в последовательности. Он также должен вызывать StopIteration при достижении конца последовательности (т.н. «исчерпание итератора»). То есть, в нашем случае — когда мы дошли до конца алфавита.
Хорошо, теперь давайте посмотрим на код нашего класса, а затем мы объясним, как он работает:
Теперь давайте попробуем сделать это через цикл for :
Мы обрезали вывод, потому что алфавит сейчас не так интересен, не правда ли? Этот итератор, как и следовало ожидать, совершенно бесполезен. Мы могли бы просто перебирать ascii_lowercase напрямую. Но, надеемся, на этом примере вы лучше разобрались в итераторах.
Nextables
Для этого удалим метод __iter__ из предыдущего примера, в результате чего получим следующее:
Python отделяет итератор от последовательности
Мы начали экспериментировать со встроенными последовательностями и сделали небольшое забавное открытие. В Python последовательности сами по себе не являются итераторами. Скорее у каждой есть соответствующий класс-итератор, отвечающий за итерацию. Давайте посмотрим на диапазон в качестве примера:
Просто для проверки используем next с range_iterator :
Создание отдельных Iterable и Nextable
Вооружившись этими новыми знаниями об отделении итерируемого объекта от итератора, мы придумали новую идею:
Итерация действительно проста:
Это просто оболочка для нашей следующей таблицы из примера nextable. Затем пишем цикл:
Однако такая установка хрупкая. Возвращаясь к нашему правильно реализованному итератору, этот код будет работать:
А код с нашей комбинацией iterable + nextable — нет:
Заключение
Давайте подведем итоги! Во-первых, теперь вы знаете, что все циклы for в Python используют итераторы! Кроме того, как мы увидели, итераторы в Python позволяют нам отделить код, выполняющий итерацию, от кода, работающего с каждым элементом. Мы также надеемся, что вы узнали немного больше о том, как работают итераторы в Python и что такое протокол итератора.
На этом пока все, и мы надеемся, вам понравился более глубокий взгляд на протокол итераторов в Python!
Итерируемый объект, итератор и генератор в Python
В некоторых источниках итератор рассматривается как частный случай итерируемого объекта, поскольку оба поддерживают операцию итерации, то есть обход циклом for. Однако for работает только с итераторами. Переданный на обработку объект должен иметь метод __iter__(), который for неявно вызывает перед обходом. Метод __iter__() должен возвращать итератор.
У итерируемого объекта, то есть объекта, который можно «превратить» в итератор, должен быть метод __iter__(), который возвращает соответствующий объект-итератор.
У итерируемого объекта нет метода __next__(), который используется при итерации:
У итератора есть метод __next__(), который извлекает из итератора очередной элемент. При этом этот элемент уже не содержится в итераторе. Таким образом, итератор в конечном итоге опустошается:
Метод __next__() исчерпанного итератора возбуждает исключение StopIteration.
У итераторов, также как у итерируемых объектов, есть метод __iter__(). Однако в данном случае он возвращает сам объект-итератор:
Здесь переменные b и c указывают на один и тот же объект.
В Python есть встроенные функции iter() и next(), которые соответственно вызывают методы __iter__() и __next__() объектов, переданных в качестве аргумента.
Внутренний механизм цикла for сначала вызывает метод __iter__() объекта. Так что, если передан итерируемый объект, создается итератор. После этого применяется метод __next__() до тех пор, пока не будет возбуждено исключение StopIteration.
Отличительной особенностью генераторов является то, что они создаются не на основе классов, а путем вызова функции, содержащей инструкцию yield, или специальным генераторным выражением по синтаксису похожим на генератор списка. Отметим, генератор списка, который является особым выражением, к генераторам, которые являются разновидностью объектов-итераторов, отношения не имеет. Подробнее можно почитать здесь.
Другими словами, если потребуется создать свой итератор, может оказаться проще определить функцию с yield или воспользоваться выражением, чем создавать класс с методами __next__() и __iter__().
Рассмотрим пример. Определим сначала собственный класс-итератор:
Пример выполнения кода:
Наш итератор выдает числа по нарастающей. При этом каждое следующее число больше предыдущего на случайную величину.
Здесь же отметим преимущество итераторов как таковых перед контейнерными типами вроде списков. В памяти компьютера не хранятся все элементы итератора, в основном лишь описание, как получить следующий элемент. Если представить, что нужны тысячи чисел или надо генерировать сложные объекты, выгода существенна.
В случае с функцией, создающей генератор, приведенный выше пример может выглядеть так:
Нам незачем самим определять методы __iter__() и __next__(), так как они неявно присутствуют у генератора.
Если логика генератора проста, вместо функции можно использовать выражение, создающее генератор:
Данный пример не идентичен приведенным выше функции и классу. Здесь целая часть каждого следующего числа больше чем у предыдущего на единицу.
Понимание итераторов в Python
Особенности, с которыми вы часто можете столкнуться в повседневной деятельности
1. Использование генератора дважды
Как мы видим в этом примере, использование переменной squared_numbers дважды, дало ожидаемый результат в первом случае, и, для людей незнакомых с Python в достаточной мере, неожиданный результат во втором.
2. Проверка вхождения элемента в генератор
Возьмём всё те же переменные:
А теперь, дважды проверим, входит ли элемент в последовательность:
Получившийся результат также может ввести в заблуждение некоторых программистов и привести к ошибкам в коде.
3. Распаковка словаря
Для примера используем простой словарь с двумя элементами:
Результат будет также неочевиден, для людей, не понимающих устройство Python, «под капотом»:
Последовательности и итерируемые объекты
По-сути, вся разница, между последовательностями и итерируемымыи объектами, заключается в том, что в последовательностях элементы упорядочены.
Так, последовательностями являются: списки, кортежи и даже строки.
Отличия цикла for в Python от других языков
А с итерируемыми объектами, последовательностями не являющимися, не будет:
Цикл for использует итераторы
Как мы могли убедиться, цикл for не использует индексы. Вместо этого он использует так называемые итераторы.
Итераторы — это такие штуки, которые, очевидно, можно итерировать 🙂
Получить итератор мы можем из любого итерируемого объекта.
Для этого нужно передать итерируемый объект во встроенную функцию iter :
Реализация цикла for с помощью функции и цикла while
Чтобы сделать это, нам нужно:
Теперь мы знакомы с протоколом итератора.
А, говоря простым языком — с тем, как работает итерация в Python.
Функции iter и next этот протокол формализуют. Механизм везде один и тот же. Будь то пресловутый цикл for или генераторное выражение. Даже распаковка и «звёздочка» используют протокол итератора:
Генераторы — это тоже итераторы
Генераторы тоже реализуют протокол итератора:
В случае, если мы передаём в iter итератор, то получаем тот же самый итератор
Итератор не имеет индексов и может быть использован только один раз.
Протокол итератора
Теперь формализуем протокол итератора целиком:
Итераторы работают «лениво» (en. lazy). А это значит, что они не выполняют какой-либо работы, до тех пор, пока мы их об этом не попросим.
Таким образом, мы можем оптимизировать потребление ресурсов ОЗУ и CPU, а так же создавать бесконечные последовательности.
Итераторы повсюду
Мы уже видели много итераторов в Python.
Я уже упоминал о том, что генераторы — это тоже итераторы.
Многие встроенные функции является итераторами.
Так, например, enumerate :
Создание собственного итератора
Так же, в некоторых случаях, может пригодится знание того, как написать свой собственный итератор и ленивый итерируемый объект.
В моей карьере этот пункт был ключевым, так как вопрос был задан на собеседовании, которое, как вы могли догадаться, я успешно прошёл и получил свою первую работу:)
Таким образом мы написали бесконечный и ленивый итератор.
А это значит, что ресурсы он будет потреблять только при вызове.
Не говоря уже о том, что без собственного итератора имлементация бесконечной последовательности была бы невозможна.
А теперь вернёмся к тем особенностям, которые были изложены в начале статьи
1. Использование генератора дважды
В данном примере, список будет содержать элементы только в первом случае, потому что генераторное выражение — это итератор, а итераторы, как мы уже знаем — сущности одноразовые. И при повторном использовании не будут отдавать никаких элементов.
2. Проверка вхождения элемента в генератор
А теперь дважды проверим, входит ли элемент в последовательность:
В данном примере, элемент будет входить в последовательность только 1 раз, по причине того, что проверка на вхождение проверяется путем перебора всех элементов последовательности последовательно, и как только элемент обнаружен, поиск прекращается. Для наглядности приведу пример:
Как мы видим, при создании списка из генераторного выражения, в нём оказываются все элементы, после искомого. При повторном же создании, вполне ожидаемо, список оказывается пуст.
3. Распаковка словаря
Так как распаковка опирается на тот же протокол итератора, то и в переменных оказываются именно ключи:
Выводы
Последовательности — итерируемые объекты, но не все итерируемые объекты — последовательности.
Итераторы — самая простая форма итерируемых объектов в Python.
Любой итерируемый объект реализует протокол итератора. Понимание этого протокола — ключ к пониманию любых итераций в Python.
Итерируемый объект, итератор и генератор
Привет, уважаемые читатели Хабрахабра. В этой статье попробуем разобраться что такое итерируемый объект, итератор и генератор. Рассмотрим как они реализованы и используются. Примеры написан на Python, но итераторы и генераторы, на мой взгляд, фундаментальные понятия, которые были актуальны 20 лет назад и еще более актуальны сейчас, при этом за это время фактически не изменились.
Итераторы
Для начала вспомним, что из себя представляет паттерн «Итератор(Iterator)».
Назначение:
Существуют два вида итераторов, внешний и внутренний.
Внешний итератор — это классический (pull-based) итератор, когда процессом обхода явно управляет клиент путем вызова метода Next.
Внутренний итератор — это push-based-итератор, которому передается callback функция, и он сам уведомляет клиента о получении следующего элемента.
Классическая диаграмма паттерна “Итератор”, как она описана в небезызвестной книги «банды четырех»:
Aggregate — составной объект, по которому может перемещаться итератор;
Iterator — определяет интерфейс итератора;
ConcreteAggregate — конкретная реализация агрегата;
ConcreteIterator — конкретная реализация итератора для определенного агрегата;
Client — использует объект Aggregate и итератор для его обхода.
Пробуем реализовать на Python классический итератор
Конкретная реализация итератора для списка:
Конкретная реализация агрегата:
Теперь мы можем создать объект коллекции и обойти все ее элементы с помощью итератора:
А так как мы реализовали метод first, который сбрасывает итератор в начальное состояние, то можно воспользоваться этим же итератором еще раз:
Реализации могут быть разные, но основная идея в том, что итератор может обходить различные структуры, вектора, деревья, хеш-таблицы и много другое, при этом имея снаружи одинаковый интерфейс.
Протокол итерирования в Python
В книге «банды четырех» о реализации итератора написано:
Минимальный интерфейс класса Iterator состоит из операций First, Next, IsDone и CurrentItem. Но если очень хочется, то этот интерфейс можно упростить, объединив операции Next, IsDone и CurrentItem в одну, которая будет переходить к следующему объекту и возвращать его. Если обход завершен, то эта операция вернет специальное значения(например, 0), обозначающее конец итерации.
Именно так и реализовано в Python, но вместо специального значения, о конце итерации говорит StopIteration. Проще просить прощения, чем разрешения.
Сначала важно определиться с терминами.
Рассмотрим итерируемый объект (Iterable). В стандартной библиотеке он объявлен как абстрактный класс collections.abc.Iterable:
У него есть абстрактный метод __iter__ который должен вернуть объект итератора. И метод __subclasshook__ который проверяет наличие у класса метод __iter__. Таким образом, получается, что итерируемый объект это любой объект который реализует метод __iter__
Но есть один момент, это функция iter(). Именно эту функцией использует например цикл for для получения итератора. Функция iter() в первую очередь для получения итератора из объекта, вызывает его метод __iter__. Если метод не реализован, то она проверяет наличие метода __getitem__ и если он реализован, то на его основе создается итератор. __getitem__ должен принимать индекс с нуля. Если не реализован ни один из этих методов, тогда будет вызвано исключение TypeError.
Итого, итерируемый объект — это любой объект, от которого встроенная функция iter() может получить итератор. Последовательности(abc.Sequence) всегда итерируемые, поскольку они реализуют метод __getitem__
Теперь посмотрим, что с итераторами в Python. Они представлены абстрактным классом collections.abc.Iterator:
__next__ Возвращает следующий доступный элемент и вызывает исключение StopIteration, когда элементов не осталось.
__iter__ Возвращает self. Это позволяет использовать итератор там, где ожидается итерируемых объект, например for.
__subclasshook__ Проверяет наличие у класса метода __iter__ и __next__
Итого, итератор в python — это любой объект, реализующий метод __next__ без аргументов, который должен вернуть следующий элемент или ошибку StopIteration. Также он реализует метод __iter__ и поэтому сам является итерируемым объектом.
Таким образом можно реализовать итерируемый объект на основе списка и его итератор:
Функция next() вызывает метод __next__. Ей можно передать второй аргумент который она будет возвращать по окончанию итерации вместо ошибки StopIteration.
Прежде чем переходить к генераторам, рассмотрим еще одну возможность встроенной функции iter(). Ее можно вызывать с двумя аргументами, что позволит создать из вызываемого объекта(функция или класс с реализованным методом __call__) итератор. Первый аргумент должен быть вызываемым объектом, а второй — неким ограничителем. Вызываемый объект вызывается на каждой итерации и итерирование завершается, когда возбуждается исключение StopIteration или возвращается значения ограничителя.
Например, из функции которая произвольно возвращает 1-6, можно сделать итератор, который будет возвращать значения пока не «выпадет» 6:
Небольшой класс ProgrammingLanguages, у которого есть кортеж c языками программирования, конструктор принимает начальное значения индекса по названию языка и функция __call__ которая перебирает кортеж.
Можем перебрать все языки начиная с C# и до последнего:
Генераторы
С точки зрения реализации, генератор в Python — это языковая конструкция, которую можно реализовать двумя способами: как функция с ключевым словом yield или как генераторное выражение. В результате вызова функции или вычисления выражения, получаем объект-генератор типа types.GeneratorType.
В объекте-генераторе определены методы __next__ и __iter__, то есть реализован протокол итератора, с этой точки зрения, в Python любой генератор является итератором.
Концептуально, итератор — это механизм поэлементного обхода данных, а генератор позволяет отложено создавать результат при итерации. Генератор может создавать результат на основе какого то алгоритма или брать элементы из источника данных(коллекция, файлы, сетевое подключения и пр) и изменять их.
Ярким пример являются функции range и enumerate:
range генерирует ограниченную арифметическую прогрессию целых чисел, не используя никакой источник данных.
enumerate генерирует двухэлементные кортежи с индексом и одним элементом из итерируемого объекта.
Yield
Для начало напишем простой генератор не используя объект-генератор. Это генератор чисел Фибоначчи:
Но используя ключевое слово yield можно сильно упростить реализацию:
Любая функция в Python, в теле которой встречается ключевое слово yield, называется генераторной функцией — при вызове она возвращает объект-генератор.
Объект-генератор реализует интерфейс итератора, соответственно с этим объектом можно работать, как с любым другим итерируемым объектом.
Рассмотрим работу yield:
Создается стейт-машина в которой при каждом вызове __next__ меняется состояния и в зависимости от него вызывается тот или иной кусок кода. Если в функции yield в цикле, то соответственно состояние стейт-машины зацикливается пока не будет выполнено условие.
Свой вариант range:
Генераторное выражение (generator expression)
Если кратко, то синтаксически более короткий способ создать генератор, не определяя и не вызывая функцию. А так как это выражение, то у него есть и ряд ограничений. В основном удобно использовать для генерации коллекций, их несложных преобразований и применений на них условий.
В языках программирования есть такие понятия, как ленивые/отложенные вычисления(lazy evaluation) и жадные вычисления(eager/greedy evaluation). Генераторы можно считать отложенным вычислением, в этом смысле списковое включение(list comprehension) очень похожи на генераторное выражение, но являются разными подходами.
Первый вариант работает схожим с нашей функцией cool_range образом и может генерировать без проблем любой диапазон. А вот второй вариант создаст сразу целый список, со всеми вытекающими от сюда проблемами.
Yield from
Для обхода ограниченно вложенных структур, традиционный подход использовать вложенные циклы. Тот же подход можно использовать когда генераторная функция должна отдавать значения, порождаемые другим генератором.
Функция похожая на itertools.chain:
Но вложенные циклы можно убрать, добавив конструкцию yield from:
Основная польза yield from в создании прямого канала между внутренним генератором и клиентом внешнего генератора. Но это уже больше тема про сопрограммы(coroutines), которые заслуживают отдельной статьи. Там же можно обсудить методы генератора: close(), throw() и send().
И в заключении еще один пример. Функция принимающая итерируемый объект, с любым уровнем вложенности другими итерируемыми объектами, и формирующая плоскую последовательность:
5 доказательств силы итерируемых объектов в Python
Что такое итерируемые объекты?
Итерируемые (перебираемые) объекты — это коллекция важных структур данных в Python. Например, к ним относятся такие встроенные типы, как строки, списки и словари. Если вам приходилось применять функции высшего порядка ( map и filter ), то, скорее всего, вам известно, что они также создают итерируемые объекты (а именно, объекты map и filter ). Кроме того, вы могли слышать и о генераторах, которые также являются высокопроизводительными объектами данного типа с эффективным использованием памяти.
Эти типы данных — общеизвестные примеры итерируемых объектов в Python. Но что именно они из себя представляют? Воспользуемся определением, предложенным Лучано Рамальо в его замечательной книге о продвинутом программирования на Python “Fluent Python: Clear, Concise, and Effective Programming”. По сути, итерируемыми являются такие объекты, которые могут быть преобразованы в итераторы, чьи элементы в дальнейшем можно перебирать (итерировать) для выполнения определенных операций.
Любой объект со встроенной функцией iter может получить итератор. Объекты, реализующие метод __iter__ , который возвращает итератор, называются итерируемыми объектами”, — Лучано Рамальо, “Fluent Python: Clear, Concise, and Effective Programming
Итерируемые объекты настолько важны, что повсеместно используются для разных целей. Здесь предпринята попытка представить систематический, но не исчерпывающий обзор самых распространенных случаев их использования в Python. Надеюсь, что знакомство с перебираемыми объектами поможет вам эффективнее применять их в своих проектах.
1. Итерация циклами for
2. Создание коллекций разных типов данных
Мы можем применять итерируемые объекты для создания коллекций разных типов данных, и к числу наиболее часто используемых из них относятся списки, множества, кортежи и словари. В самых простых случаях, включающих контролируемое число элементов, для создания этих типов данных можно использовать литералы. Как уже было продемонстрировано в самом начале фрагмента кода предыдущего раздела, мы просто конкретизировали отдельные элементы, предназначенные для хранения в указанных контейнерах. Ничего сложного, так ведь?
Однако при необходимости создания контейнера с большим числом элементов способ с литералами становится не таким удобным. Примечательно, что все эти коллекции обладают своими собственными конструкторами, использующими соответствующие имена классов, и они могут просто принять итерируемые объекты для создания новых объектов коллекции. Следующий пример кода отображает то, как это можно сделать.
Если вы занимаетесь наукой о данных или машинным обучением, то вам, вероятно, известны пакеты NumPy и Pandas, самые основные структуры данных которые создаются на основе перебираемых объектов. Следующий фрагмент кода отображает стандартные случаи использования:
3. Представления (списков, словарей, множеств) и выражения-генераторы
Одной особенно полезной возможностью Python является техника представления. Главным образом представления используются для создания списков, множеств и словарей, и соответствующие техники называются представлениями списков, представлениями множеств и словарей. Ниже представлены их основные формы.
Как мы видим, все эти формы включают однострочную итерацию. Каждое представление может иметь дополнительное заданное условие, при выполнении которогоэлемент будет отправлен в выражение. Представления списков и множеств включают только одно выражение, тогда как представление словарей — два, по одному для ключа и значения. Следует также отметить, что в синтаксисе представления списков используются квадратные скобки, а применительно к словарям и множествам — фигурные. Важно понимать отличительные нюансы этих похожих техник, поскольку в случае ошибочного использования их синтаксиса вы можете получить непредвиденные результаты или допустить баги в коде.
Следующий фрагмент демонстрирует примеры использования данных техник представления:
Выражение-генератор, применяемое для создания генераторов, похоже на техники представления. На выходе оно также производит итерируемый объект (генератор). Но в отличие от перебираемых объектов представлений генераторы могут выдавать значения по запросу, таким образом экономно расходуя ресурсы памяти. Рассмотрим синтаксис и его применение для создания генератора. Сравнение генераторов и списков:
4. Распаковка списков и кортежей
При работе со списками и кортежами обычно требуется использовать отдельные части данных. С этой целью чаще всего применяются методы индексации/среза, которые позволяют получить либо конкретные элементы, либо блоки данных. Однако эти методы могут вызывать сложности в связи с использованием так называемых магических чисел (возможно, кому-то будет непросто разобраться, почему были задействованы те или иные индексы). Вместо вышеописанного подхода мы можем применить метод распаковки, подразумевающий последовательное присваивание элементов конкретным переменным. Обратимся к простому примеру:
Здесь число использованных переменных соответствует числу элементов в итерируемом объекте. Однако Python предоставляет возможность повысить эффективность метода распаковки за счет применения принципа catch-all. Точнее говоря, если число используемых переменных меньше числа элементов в перебираемом объекте, то переменная с символом * подхватит все оставшиеся элементы. Обратите внимание, что она будет создана в виде итерируемого объекта (объекта списка). Вот конкретный пример:
Соответственно переменным first_number и last_number присваиваются первый и последний элементы списка. Примечательно, что переменная middle_numbers подхватывает все числа в середине последовательности и имеет тип списка.
5. Функции высшего порядка
Итерируемые объекты также используются в качестве входных (параметров) и выходных (возвращаемых значений) данных некоторых функций высшего порядка. К их числу относятся две хорошо известные функции map и filter . Функция filter принимает итерируемый объект и функцию фильтрации, которую применяет ко всем элементам данного объекта. Если элемент удовлетворяет условию, то он сохраняется в перебираемом объекте. Рассмотрим на примере принцип действия функции. Как мы видим, она фильтрует последовательность чисел, оставляя только те, что делятся на 3. Обратите внимание, что созданный объект filter является итератором, поддерживающим итерацию.:
Заключение
Статья была посвящена 5-ти самым распространенным случаям использования итерируемых объектов в Python. Это понятие довольно объемное и включает в себя различные встроенные типы данных (например, строки, списки и словари). Полагаю, что материал статьи расширит ваши знания по этой теме и поможет вам решать большинство задач, связанных с подобными объектами, в проектах Python. Благодарю за внимание! Счастья всем Python-программистам!