Как работает цикл for в Python

В этой статье мы разберем, работу цикла for в Python.

Мы начнем с пары основных примеров и их синтаксиса. Далее обсудим, когда может быть полезен блок else, связанный с циклом for. Затем мы разберем итерактивные объекты (iterable), итераторы (iterator) и протокол итератора. Также узнаем, как создавать собственные итераторы и итерируемые объекты. После этого мы обсудим, как цикл for реализован с использованием итерактивных объектов и итераторов. Потом мы рассмотрим реализацию логики цикла for, используя цикл while и используя протокол итератора.
И наконец, для тех, кому интересно, мы разберем простой цикл for и пройдемся по инструкциям, которые интерпретатор Python выполняет при выполнении цикла for. Это должно помочь понять, что именно происходит внутри, во время работы цикла for.

Цикл for в Python

Оператор for является одним из двух операторов, используемых для создания циклов в Python, другим является оператор while. Если вы совсем не знакомы с итерациями в Python, то рекомендуем почитать статью Итерации в Python: операторы for, while, break и continue которая будет хорошей отправной точкой для изучения циклов и итераций.

Простой цикл for

Давайте начнем с простого цикла for, который перебирает список строк и печатает каждую строку.

>>> for word in ["You", "are", "awesome!"]:
...   print(word)
...
You
are
awesome!

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

Цикл for с условием else

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

>>> for word in ["You", "are", "awesome!"]:
...   print(word)
... else:
...   print("See you later!")
...
You
are
awesome!
See you later!

Когда полезно условие else?

Как вы могли заметить, блок else выполняется после завершения цикла for. Так какой смысл использовать блок else? Разве не будет выполнен следующий набор операторов после цикла for?

Ну, во многих случаях у нас возникают ситуации, когда нам нужно выйти из цикла for, когда выполняется определенное условие. И если это условие никогда не выполняется, но нам все равно нужно выполнить набор операторов. Для этого мы обычно используем логический флаг. Давайте посмотрим на пример.

def search(search_list, search_item):
  found_item = False

  for word in search_list:
    if word == search_item:
      found_item = True
      print("Found word '{}'".format(search_item))
      break

  if not found_item:
    print("Word '{}' was not found!".format(search_item))

Использование:

>>> search(["You", "are", "awesome!"], "are")
Found word 'are'
>>> search(["You", "are", "awesome!"], "we")
Word 'we' was not found!

С помощью блока else мы можем избежать использования логического флага found_item. Давайте посмотрим, как мы можем переписать вышеуказанный метод с помощью else. Обратите внимание, что блок else будет пропущен, если в цикле for встречается оператор break.

def search(search_list, search_item):
  for word in search_list:
    if word == search_item:
      print("Found word '{}'".format(search_item))
      break
  else:
    print("Word '{}' was not found!".format(search_item))

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

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

Синтаксис цикла for

Теперь, когда мы рассмотрели несколько основных примеров, давайте завершим этот раздел синтаксисом цикла for.

for <element> in <iterable>:
    <set_of_statements_1>
else:
    <set_of_statements_2>

По сути, для каждого итерируемого элемента выполняется set_of_statements_1. Как только все элементы исчерпаны, управление переходит к блоку else и выполняется set_of_statements_2.

Обратите внимание, что предложение else является необязательным. Если блок else отсутствует, цикл завершается после того, как все элементы будут пройдены, и управление переходит к следующему оператору программы.

Итерируемые объекты (iterables) и итераторы (iterators)

Итерируемые объекты

В предыдущем разделе мы использовали термин «iterables» для обозначения объекта, который итерировался циклом for. Теперь давайте попробуем понять, что такое итерируемый объект в Python.

В Python итерируемый объект – это любой объект, который можно использовать в итерации с использованием цикла for. Это означает, что объект должен возвращать итератор при передаче в метод iter(). Давайте посмотрим примеры некоторых часто используемых встроенных итерируемых объектов в Python.

>>> iter("You are awesome!") # String
<str_iterator object at 0x1041ad2e8>
>>> iter(["You", "are", "awesome!"]) # List
<list_iterator object at 0x1041ad358>
>>> iter(("You", "are", "awesome!")) # Tuple
<tuple_iterator object at 0x1041ad390>
>>> iter({"You", "are", "awesome!"}) # Set
<set_iterator object at 0x1041ac678>
>>> iter({1: "You", 2: "are", 3: "awesome!"}) # Dictionary
<dict_keyiterator object at 0x10400df48>
>>> iter(range(3)) # Range function
<range_iterator object at 0x1041a1450>

Как вы можете видеть, когда мы вызываем iter() для итерируемого объекта, он возвращает объект итератора.

Итераторы

А что такое итератор? В Python итератор определяется как объект, представляющий поток данных. По сути, если мы передаем итератор во встроенный метод next(), он должен вернуть следующее значение из связанного потока данных. Когда все элементы исчерпаны, должно появиться исключение StopIteration. Он должен продолжать вызывать исключение StopIteration для любых последующих вызовов метода next().

Примеры итератора со списком.

>>> my_list = ["You", "are", "awesome!"]
>>>
>>> # Get the iterator.
... list_iterator = iter(my_list)
>>>
>>> # Get next element of iterator.
... next(list_iterator)
'You'
>>> next(list_iterator)
'are'
>>> next(list_iterator)
'awesome!'
>>> next(list_iterator)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
>>> next(list_iterator)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

Итераторы тоже итеративные объекты! Но..

Следует помнить одну интересную вещь: итераторы сами по себе также поддерживают (обязаны поддерживать согласно протоколу итератора) метод iter(). Это означает, что мы можем вызвать метод iter() для итератора и получить сам объект итератора.

>>> my_list = ["You", "are", "awesome!"]
>>> list_iterator = iter(my_list)
>>> list_iterator
<list_iterator object at 0x1099a6320>
>>> iterator_of_iterator = iter(list_iterator)
>>> iterator_of_iterator
<list_iterator object at 0x1099a6320>

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

Однако обратите внимание, что вызов iter() для объекта-контейнера, такого как list, каждый раз будет возвращать новый итератор. Но вызов iter() для итератора просто возвращает тот же объект.

>>> my_list = [1, 2]
>>> iter(my_list)
<list_iterator object at 0x1099a62b0>
>>> iter(my_list) # This gives a fresh iterator object
<list_iterator object at 0x1099a62e8>

>>> my_list = [1, 2]
>>> list_iter = iter(my_list)
>>> list_iter
<list_iterator object at 0x1099a62b0>
>>> iter(list_iter) # This returns the same iterator object
<list_iterator object at 0x1099a62b0>
>>> iter(list_iter) # This returns the same iterator object
<list_iterator object at 0x1099a62b0>

Итерация по списку дважды

Обратите внимание, что это работает так, как мы ожидали.

>>> my_list = ["You are Awesome!"]
>>>
>>> for word in my_list:
...   print(word)
...
You are Awesome!
>>> for word in my_list:
...   print(word)
...
You are Awesome!

Итерация через list_iterator дважды

Обратите внимание, что итератор будет исчерпан в первом цикле, а во второй раз мы просто видим пустой контейнер.

>>> my_list = ["You are Awesome!"]
>>> list_iterator = iter(my_list)
>>>
>>> for word in list_iterator:
...   print(word)
...
You are Awesome!
>>>
>>> for word in list_iterator:
...   print(word)
...
>>>

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

В предыдущем разделе мы увидели, что:

1. Итерируемый объект при передаче в функцию iter() возвращает итератор.
2. Итератор,
   1. при передаче в функцию next() возвращает следующий элемент или вызывает StopIteration после того, как все элементы будут исчерпаны.
   2. при передаче функции iter() возвращает себя.

Протокол итератора – это не что иное, как стандартный способ определения объектов как итераторов. Мы уже видели протокол в действии в предыдущем разделе. Согласно протоколу, итераторы должны определить следующие два метода:

1. __next()__
   • Этот метод должен возвращать следующий элемент серии каждый раз, когда он вызывается. Как только все элементы исчерпаны, должно появиться исключение StopIteration.
   • Этот метод вызывается изнутри, когда мы вызываем встроенный метод next().
2. __iter()__
   • Этот метод должен возвращать сам объект итератора.
   • Это метод, который вызывается внутри, когда мы вызываем встроенный метод iter().

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

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

class Range:
  def __init__(self, start, stop, step):
    self.next = start
    self.stop = stop
    self.step = step

  def __next__(self):
    if self.next > self.stop:
      raise StopIteration
    next_item = self.next
    self.next += self.step
    return next_item

  def __iter__(self):
    return self

Теперь посмотрим, как он работает с циклом for.

>>> for num in Range(1, 10, 2):
...   print(num)
...
1
3
5
7
9

Обратите внимание, что экземпляр Range является как итерируемым объектом, так и итератором.

Создание своего собственного итерируемого объекта

Все, что для этого нужно, это возвращать новый итератор всякий раз, когда вызывается метод __iter__() , т. е. в этом случае он должен возвращать новый экземпляр Range.

class RangeIterable:
  def __init__(self, start, stop, step):
    self.start = start
    self.stop = stop
    self.step = step

  def __iter__(self):
    return Range(self.start, self.stop, self.step)

Давайте теперь используем наш RangeIterable с циклом for.

>>> for num in RangeIterable(1, 10, 2):
...   print(num)
...
1
3
5
7
9

Как работает цикл for?

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

Давайте снова посмотрим на наш предыдущий пример.

>>> for word in ["You", "are", "awesome!"]:
...   print(word)
... else:
...   print("See you later!")
...
You
are
awesome!
See you later!

Когда мы выполняем вышеуказанный блок кода, происходит следующее:

1. Оператор for внутри себя вызывает iter() для списка [«You», «are», «awesome!»]. Это приводит к получению итератора.
2. Затем вызывается next() для итератора, и возвращаемое им значение присваивается переменной цикла, в данном случае word.
3. После этого выполняется блок оператора, связанный с циклом for. В этом случае print(word).
4. Шаги 2 и 3 повторяются до тех пор, пока next() не вызовет StopIteration.
5. Как только next() вызывает StopIteration, управление переходит к предложению else, если оно присутствует, и выполняется блок операторов, связанных с else.

Примечание. Если в блоке кода, связанном с циклом for, встречается оператор break, то блок else пропускается.

Реализация логики цикла for с помощью оператора while

Мы могли бы реализовать вышеуказанную логику, используя оператор while следующим образом.

my_list = ["You", "are", "awesome!"]
list_iter = iter(my_list)
while True:
  try:
    word = next(list_iter)
    print(word)
  except StopIteration:
    print("See you later!")
    break

Цикл while ведет себя точно так же, как наш цикл for, и выдает следующий результат.

You
are
awesome!
See you later!

Разбор цикла for

В этом разделе мы разберем цикл for и пройдемся по инструкциям, которые интерпретатор исполняет при выполнении цикла for. Мы будем использовать модуль dis для разборки цикла for. Чтобы быть точным, мы будем использовать метод dis.dis, чтобы получить удобочитаемое представление дизассемблированного байт-кода.

Мы будем использовать тот же простой цикл for, который мы рассматривали до сих пор. Запишем следующий цикл for в файл for_loop.py.

for word in ["You", "are", "awesome!"]:
  print(word)
else:
  print("See you later!")

Теперь мы можем получить читаемую форму байт-кода, вызвав dis.dismethod. Запустим следующую команду в терминале.

$ python3 -m dis for_loop.py
  1           0 SETUP_LOOP              28 (to 30)
              2 LOAD_CONST               0 (('You', 'are', 'awesome!'))
              4 GET_ITER
        >>    6 FOR_ITER                12 (to 20)
              8 STORE_NAME               0 (word)

  2          10 LOAD_NAME                1 (print)
             12 LOAD_NAME                0 (word)
             14 CALL_FUNCTION            1
             16 POP_TOP
             18 JUMP_ABSOLUTE            6
        >>   20 POP_BLOCK

  4          22 LOAD_NAME                1 (print)
             24 LOAD_CONST               1 ('See you later!')
             26 CALL_FUNCTION            1
             28 POP_TOP
        >>   30 LOAD_CONST               2 (None)
             32 RETURN_VALUE

Каждый из столбцов в разобранном виде представляет следующее:

1. Колонка 1: номер строки кода.
2. Колонка 2: знак «>>», если инструкция является целью перехода.
3. Колонка 3: смещение байт кода в байтах.
4. Колонка 4: инструкция байт-кода.
5. Колонка 5: аргументы инструкции. В скобках отображается более понятный для человека имя аргументов.

Теперь давайте шаг за шагом пройдемся по нашему разобранному байт-коду и попытаемся понять, что на самом деле происходит.
В этом описание термин TOS означает вершина стека (top of the stack)

1. строка 1, “for word in [“You”, “are”, “awesome!”]:” переводится как:
   • 0 SETUP_LOOP 28 (to 30)
     • Этот оператор помещает блок для цикла for в стек. Блок занимает от этой инструкции до 28 байт, то есть до «30»
     • Это означает, что если в цикле for есть оператор break, управление переместится на «30» байт. Обратите внимание, блок else, будет пропущен если встретится оператор break.
   • 2 LOAD_CONST 0 ((‘You’, ‘are’, ‘awesome!’))
     • Затем список помещается на вершину стека (TOS).
   • 4 GET_ITER
     • Эта инструкция выполняет «TOS = iter (TOS)». Это означает, что итератор получается из списка, который на данный момент является TOS, а затем итератор переносится в TOS.
   • 6 FOR_ITER 12 (to 20)
     • Эта инструкция получает TOS, который на данный момент является нашим итератором, и вызывает для него метод next().
     • Если next() возвращает значение, оно помещается в стек, и будет выполнена следующая инструкция «8 STORE_NAME».
     • Как только функция next() указывает, что итератор исчерпан (т. к. сработал StopItered), TOS (а именно итератор) будет извлечен из стека, а счетчик байтового кода будет увеличен на 12. Это означает, что элемент управления перейдет к инструкция «20 POP_BLOCK».
   • 8 STORE_NAME 0 (word)
     • Эта инструкция преобразуется в word = TOS, то есть значение, возвращаемое функцией next(), будет присвоено переменной word.
2. строка 2, “print(word)” переводится как:
   • 10 LOAD_NAME 1 (print)
     • Эта команда помещает команду print в стек.
   • 12 LOAD_NAME 0 (word)
     • Это команда перемещает аргумент print, то есть word в стек.
   • 14 CALL_FUNCTION 1
     • Это команда вызывает функцию с позиционными аргументами.
     • Аргументы, связанные с функцией, будут присутствовать в TOS, как мы видели в предыдущей инструкции. Все аргументы выталкиваются до тех пор, пока не получит вызываемый объект, то есть print.
     • Как только он получает вызываемый объект, он вызывается путем передачи ему всех аргументов.
     • Как только вызов выполнен, его возвращаемое значение будет передано в TOS. В текущий момент это будет None.
   • 16 POP_TOP
     • TOS, то есть возвращаемое значение из функции удаляется (выталкивается) из стека.
   • 18 JUMP_ABSOLUTE 6
     • Счетчик байт-кода теперь установлен на «6». Это означает, что следующая выполняемая инструкция будет «6 FOR_ITER». Вот так цикл проходит по элементам итератора.
     • Обратите внимание, что инструкция «6 FOR_ITER» заставит программу выйти из этого цикла и перейти к «20 POP_BLOCK», как только все элементы итератора будут исчерпаны.
   • 20 POP_BLOCK
     • POP_BLOCK приведет к удалению блока, установленного в «0 SETUP_LOOP», из стека блоков.
3. Обратите внимание, что номер строки 3, т.е., else, не имеет каких-либо конкретных инструкций, связанных с этим. Управление программой естественным образом переходит к следующей инструкции, которая в основном состоит из операторов, связанных с else.
4. строка 4, “print(“See you later!”)” переводится как:
   • 22 LOAD_NAME 1 (print)
     • Вызываемый объект, связанный с print, помещается в стек.
   • 24 LOAD_CONST 1 (‘See you later!’)
     • Аргументы для вызываемого объекта помещаются в стек.
   • 26 CALL_FUNCTION 1
     • Аргументы для print и команда print извлекаются из стека. Затем выполняется вызываемая функция, и ее возвращаемое значение передается в TOS.
   • 28 POP_TOP
     • TOS, то есть возвращаемое значение функции (в данном случае None) удаляется из стека.
5. Следующие две инструкции в основном загружают возвращаемое значение нашего скрипта (None) в стек и возвращают его.
   • 30 LOAD_CONST 2 (None)
   • 32 RETURN_VALUE

Вув! Итак, мы закончили с разборкой инструкций для цикла for. Я надеюсь, что это поможет немного лучше понять работу цикла for.

Заключение

В этом посте мы рассмотрели следующее:

1. Как написать цикл for в Python?
2. Как использовать else, связанное с циклом for?
3. Что такое итераторы и итерируемые объекты?
4. Что такое протокол итератора?
5. Как создать итератор и итерируемый объект?
6. Как работает цикл for?
7. Как используя цикл while имитировать цикл for?
8. Как разобрать цикл for с помощью модуля dis и увидеть понятные человеку инструкции, выполняемые интерпретатором Python? Как читать и понимать разобранные инструкции?

Оригинальная статья Shyama Sankar Understanding for-loops in Python