Понимание итераторов в Python

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


Особенности, с которыми вы часто можете столкнуться в повседневной деятельности


1. Использование генератора дважды


>>> numbers = [1,2,3,4,5]

>>> squared_numbers = (number**2 for number in numbers)

>>> list(squared_numbers)
[1, 4, 9, 16, 25]

>>> list(squared_numbers)
[]

Как мы видим в этом примере, использование переменной squared_numbers дважды, дало ожидаемый результат в первом случае, и, для людей незнакомых с Python в достаточной мере, неожиданный результат во втором.


2. Проверка вхождения элемента в генератор


Возьмём всё те же переменные:


>>> numbers = [1,2,3,4,5]
>>> squared_numbers = (number**2 for number in numbers)

А теперь, дважды проверим, входит ли элемент в последовательность:


>>> 4 in squared_numbers
True
>>> 4 in squared_numbers
False

Получившийся результат также может ввести в заблуждение некоторых программистов и привести к ошибкам в коде.


3. Распаковка словаря


Для примера используем простой словарь с двумя элементами:


>>> fruits_amount = {'apples': 2, 'bananas': 5}

Распаковываем его:


>>> x, y = fruits_amount

Результат будет также неочевиден, для людей, не понимающих устройство Python, "под капотом":


>>> x
'apples'
>>> y
'bananas'

Последовательности и итерируемые объекты


По-сути, вся разница, между последовательностями и итерируемымыи объектами, заключается в том, что в последовательностях элементы упорядочены.


Так, последовательностями являются: списки, кортежи и даже строки.


>>> numbers = [1,2,3,4,5]
>>> letters = ('a','b','c')
>>> characters = 'habristhebestsiteever'
>>> numbers[1]
2
>>> letters[2]
'c'
>>> characters[11]
's'
>>> characters[0:4]
'habr'

Итерируемые объекты же, напротив, не упорядочены, но, тем не менее, могут быть использованы там, где требуется итерация: цикл for, генераторные выражения, списковые включения — как примеры.


# Can't be indexed
>>> unordered_numbers = {1,2,3}
>>> unordered_numbers[1]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'set' object is not subscriptable

>>> users = {'males': 23, 'females': 32}
>>> users[1]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 1

# Can be used as sequence
>>> [number**2 for number in unordered_numbers]
[1, 4, 9]
>>>
>>> for user in users:
...     print(user)
... 
males
females

Отличия цикла for в Python от других языков


Стоит отдельно остановиться на том, что цикл for, в Python, устроен несколько иначе, чем в большинстве других языков. Он больше похож на for...each, или же for...of.


Если же, мы перепишем цикл for с помощью цикла while, используя индексы, то работать такой подход будет только с последовательностями:


>>> list_of_numbers = [1,2,3]
>>> index = 0
>>> while index < len(list_of_numbers):
...     print(list_of_numbers[index])
...     index += 1
... 
1
2
3

А с итерируемыми объектами, последовательностями не являющимися, не будет:


>>> set_of_numbers = {1,2,3}
>>> index = 0 
>>> while index < len(set_of_numbers):
...     print(set_of_numbers[index])
...     index += 1
... 
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
TypeError: 'set' object is not subscriptable

Если же вам нужен index, то следует использовать встроенную функцию enumerate:


>>> set_of_numbers = {1,2,3}
>>> for index, number in enumerate(set_of_numbers):
...     print(number, index)
... 
1 0
2 1
3 2

Цикл for использует итераторы


Как мы могли убедиться, цикл for не использует индексы. Вместо этого он использует так называемые итераторы.


Итераторы — это такие штуки, которые, очевидно, можно итерировать :)
Получить итератор мы можем из любого итерируемого объекта.


Для этого нужно передать итерируемый объект во встроенную функцию iter:


>>> set_of_numbers = {1,2,3}
>>> list_of_numbers = [1,2,3]
>>> string_of_numbers = '123'
>>> 
>>> iter(set_of_numbers)
<set_iterator object at 0x7fb192fa0480>
>>> iter(list_of_numbers)
<list_iterator object at 0x7fb193030780>
>>> iter(string_of_numbers)
<str_iterator object at 0x7fb19303d320>

После того, как мы получили итератор, мы можем передать его встроенной функции next.


>>> set_of_numbers = {1,2,3}
>>> 
>>> numbers_iterator = iter(set_of_numbers)
>>> next(numbers_iterator)
1
>>> next(numbers_iterator)
2

При каждом новом вызове, функция отдаёт один элемент. Если же в итераторе элементов больше не осталось, то функция next породит исключение StopIteration.


>>> next(numbers_iterator)
3
>>> next(numbers_iterator)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

По-сути, это единственное, что мы может сделать с итератором: передать его функции next.
Как только итератор становится пустым и порождается исключение StopIteration, он становится совершенно бесполезным.


Реализация цикла for с помощью функции и цикла while


Используя полученные знания, мы можем написать цикл for, не пользуясь самим циклом for. :)


Чтобы сделать это, нам нужно:


  1. Получить итератор из итерируемого объекта.
  2. Вызвать функцию next.
  3. Выполнить 'тело цикла'.
  4. Закончить цикл, когда будет получено исключение StopIteration.

def for_loop(iterable, loop_body_func):
    iterator = iter(iterable)
    next_element_exist = True
    while next_element_exist:
        try:
            element_from_iterator = next(iterator)
        except StopIteration:
            next_element_exist = False
        else:
            loop_body_func(element_from_iterator)

Стоит заметить, что здесь мы использовали конструкцию try-else. Многие о ней не знают. Она позволяет выполнять код, если исключения не возникло, и код был выполнен успешно.


Теперь мы знакомы с протоколом итератора.
А, говоря простым языком — с тем, как работает итерация в Python.
Функции iter и next этот протокол формализуют. Механизм везде один и тот же. Будь то пресловутый цикл for или генераторное выражение. Даже распаковка и "звёздочка" используют протокол итератора:


coordinates = [1,2,3]
x, y, z = coordinates

numbers = [1,2,3,4,5]
a,b, *rest = numbers

print(*numbers)

Генераторы — это тоже итераторы


Генераторы тоже реализуют протокол итератора:


>>> def custom_range(number):
...     index = 0 
...     while index < number:
...             yield index
...             index += 1
... 
>>> range_of_four = custom_range(4)
>>> next(range_of_four)
0
>>> next(range_of_four)
1
>>> next(range_of_four)
2
>>> next(range_of_four)
3
>>> next(range_of_four)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

В случае, если мы передаём в iter итератор, то получаем тот же самый итератор


>>> numbers = [1,2,3,4,5]
>>> iter1 = iter(numbers)
>>> iter2 = iter(iter1)
>>> next(iter1)
1
>>> next(iter2)
2
>>> iter1 is iter2
True

Подытожим.


Итерируемый объект — это что-то, что можно итерировать.
Итератор — это сущность порождаемая функцией iter, с помощью которой происходит итерирование итерируемого объекта.


Итератор не имеет индексов и может быть использован только один раз.


Протокол итератора


Теперь формализуем протокол итератора целиком:


  1. Чтобы получить итератор мы должны передать функции iter итерируемый объект.
  2. Далее мы передаём итератор функции next.
  3. Когда элементы в итераторе закончились, порождается исключение StopIteration.

Особенности:


  1. Любой объект, передаваемый функции iter без исключения TypeError — итерируемый объект.
  2. Любой объект, передаваемый функции next без исключения TypeError — итератор.
  3. Любой объект, передаваемый функции iter и возвращающий сам себя — итератор.

Плюсы итераторов:


  1. Итераторы работают "лениво" (en. lazy). А это значит, что они не выполняют какой-либо работы, до тех пор, пока мы их об этом не попросим.


  2. Таким образом, мы можем оптимизировать потребление ресурсов ОЗУ и CPU, а так же создавать бесконечные последовательности.



Итераторы повсюду


Мы уже видели много итераторов в Python.
Я уже упоминал о том, что генераторы — это тоже итераторы.
Многие встроенные функции является итераторами.


Так, например, enumerate:


>>> numbers = [1,2,3]
>>> enumerate_var = enumerate(numbers)
>>> enumerate_var
<enumerate object at 0x7ff975dfdd80>
>>> next(enumerate_var)
(0, 1)

А так же zip:


>>> letters = ['a','b','c']
>>> z = zip(letters, numbers)
>>> z
<zip object at 0x7ff975e00588>
>>> next(z)
('a', 1)

И даже open:


>>> f = open('foo.txt')
>>> next(f)
'bar\n'
>>> next(f)
'baz\n'
>>> 

В Python очень много итераторов, и, как уже упоминалось выше, они откладывают выполнение работы до того момента, как мы запрашиваем следующий элемент с помощью next. Так называемое, "ленивое" выполнение.


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


Так же, в некоторых случаях, может пригодится знание того, как написать свой собственный итератор и ленивый итерируемый объект.


В моей карьере этот пункт был ключевым, так как вопрос был задан на собеседовании, которое, как вы могли догадаться, я успешно прошёл и получил свою первую работу:)


class InfiniteSquaring:
"""Класс обеспечивает бесконечное последовательное возведение в квадрат заданного числа."""
    def __init__(self, initial_number):
        # Здесь хранится промежуточное значение
        self.number_to_square = initial_number

    def __next__(self):
        # Здесь мы обновляем значение и возвращаем результат
        self.number_to_square = self.number_to_square ** 2
        return self.number_to_square

    def __iter__(self):
        """Этот метод позволяет при передаче объекта функции iter возвращать самого себя, тем самым в точности реализуя протокол итератора."""
        return self

>>> squaring_of_six = InfiniteSquaring(6)
>>> next(squaring_of_six)
36
>>> next(squaring_of_six)
1296
>>> next(squaring_of_six)
1679616
>>> next(squaring_of_six)
2821109907456
>>> next(squaring_of_six)
7958661109946400884391936
>>> # И так до бесконечности...

Так же:


>>>iter(squaring_of_six) is squaring_of_six
True

Таким образом мы написали бесконечный и ленивый итератор.
А это значит, что ресурсы он будет потреблять только при вызове.
Не говоря уже о том, что без собственного итератора имлементация бесконечной последовательности была бы невозможна.


А теперь вернёмся к тем особенностям, которые были изложены в начале статьи


1. Использование генератора дважды


>>> numbers = [1,2,3,4,5]

>>> squared_numbers = (number**2 for number in numbers)

>>> list(squared_numbers)
[1, 4, 9, 16, 25]

>>> list(squared_numbers)
[]

В данном примере, список будет содержать элементы только в первом случае, потому что генераторное выражение — это итератор, а итераторы, как мы уже знаем — сущности одноразовые. И при повторном использовании не будут отдавать никаких элементов.


2. Проверка вхождения элемента в генератор


>>> numbers = [1,2,3,4,5]
>>> squared_numbers = (number**2 for number in numbers)

А теперь дважды проверим, входит ли элемент в последовательность:


>>> 4 in squared_numbers
True
>>> 4 in squared_numbers
False

В данном примере, элемент будет входить в последовательность только 1 раз, по причине того, что проверка на вхождение проверяется путем перебора всех элементов последовательности последовательно, и как только элемент обнаружен, поиск прекращается. Для наглядности приведу пример:


>>> 4 in squared_numbers
True
>>> list(squared_numbers)
[9, 16, 25]
>>> list(squared_numbers)
[]

Как мы видим, при создании списка из генераторного выражения, в нём оказываются все элементы, после искомого. При повторном же создании, вполне ожидаемо, список оказывается пуст.


3. Распаковка словаря


При использовании в цикле for, словарь будет отдавать ключи:


>>> fruits_amount = {'apples': 2, 'bananas': 5}

>>> for fruit_name in fruits_amount:
...     print(fruit_name)
... 
apples
bananas

Так как распаковка опирается на тот же протокол итератора, то и в переменных оказываются именно ключи:


>>> x, y = fruits_amount
>>> x
'apples'
>>> y
'bananas'

Выводы


Последовательности — итерируемые объекты, но не все итерируемые объекты — последовательности.


Итераторы — самая простая форма итерируемых объектов в Python.


Любой итерируемый объект реализует протокол итератора. Понимание этого протокола — ключ к пониманию любых итераций в Python.

AdBlock has stolen the banner, but banners are not teeth — they will be back

More
Ads

Comments 19

    +1
    Спасибо за статью! Очень доходчиво про собственный генератор.
      0
      Спасибо!)
      +2
      За статью +. Отличное освещение итераторов, спасибо.
        0
        Старался, спасибо:)
        0
        Про итераторы рассказал, а про модуль itertools — нет.

        Непорядок!
          0
          тема для отдельной статьи :D
          +1
          Толковая статья. Спасибо!
            0
            Спасибо. Рад, что Вам пригодилось)
            0
            Уважаемый автор, не совсем понятно перевод это статьи, или вы писали сами. Если перевод — то вы допустили ошибку при переводе, если нет — то ошибка в вашей логике.
            Далее по тексту: «По-сути, вся разница, между последовательностями и итерируемымыи объектами, заключается в том, что в последовательностях элементы упорядочены… Итерируемые объекты же, напротив, не упорядочены… Can't be indexed».
            Упорядочены так или иначе все итерируемые объекты, иначе бы итерация невозможна была.
            А вот если вы имели ввиду индексацию, как написано в комментарии к коду, то это может быть и верно (не питонист), и необходимо исправить "упорядочены" по тексту.
              0
              Спасибо за фидбек!)
              Это моя первая статья в жизни, не ругайтесь, пожалуйста.
              В данном конкретном случае, имелось ввиду то, что мы не можем надеяться на то, что элементы будут в одном и том же порядке постоянно. В основе dict() и set() в Python лежат хэш-таблицы.

              Но, Вы правы. Ясность внести нужно. Я поправлю.
                +2
                Насколько я знаю, в python 3.7 словари стали упорядоченными. Ранее пользовался OrderedDict
                  0
                  В CPython — да.
                  UPD: Теперь во всех, дейтвительно. Спасибо.
                    0
                    Могу ошибаться, но в CPython это есть с версии 3.6. А с версии 3.7 и в Python
                    Информация вот отсюда
                      0
                      В 3.6 словари фактически упорядочены, но без гарантии от разработчиков ядра. С 3.7 уже гарантировано.
                      0
                      Да, за статью +
                      Интересно получилось.
                0
                Спасибо за статью!
                  –1
                  Спасибо за отзыв)
                  0
                  Очень хорошо описано все, спасибо
                    0

                    Спасибо за статью, очень помог. Пойду экспериментировать)

                    Only users with full accounts can post comments. Log in, please.