Что такое итератор, итерация и итерация?

Question

Каковы основные определения "итерируемый", "итератор" и "итерация в Python?

Я прочитал несколько определений, но их точное значение по-прежнему не подходит.

Может ли кто-нибудь помочь мне с основной идеей?

Answer 1

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

В Python итерируемый и итератор имеют определенные значения.

Итерируемый - это объект, который имеет __iter__ метод, который возвращает итератор, или который определяет __getitem__ метод, который может принимать последовательные индексы, начиная с нуля (и поднимает IndexError когда индексы больше не действительны). Таким образом, итерируемый - это объект, от которого вы можете получить итератор.

Итератор - это объект с next (Python 2) или __next__ (Python 3) метод.

Всякий раз, когда вы используете for петля или mapили понимание списка и т. д. в Python, next Метод вызывается автоматически для получения каждого элемента от итератора, таким образом, проходя процесс итерации.

Хорошее место для начала обучения - раздел итераторов учебника и раздел типов итераторов на странице стандартных типов. После того, как вы поймете основы, попробуйте раздел итераторы HOWTO по функциональному программированию.

Answer 2

Вот объяснение, которое я использую при обучении на Python:

ITERABLE это:

• все, что может быть зациклено (т.е. вы можете зациклить строку или файл) или
• все, что может появиться в правой части цикла for: for x in iterable: ... или же
• все, что вы можете позвонить с iter() который вернет Итератор: iter(obj) или же
• объект, который определяет __iter__ который возвращает свежий ITERATOR, или он может иметь __getitem__ метод подходит для индексированного поиска.

Итератор - это объект:

• с состоянием, которое запоминает, где оно находится во время итерации,
• с __next__ метод, который:
  • возвращает следующее значение в итерации
  • обновляет состояние, чтобы указывать на следующее значение
  • сигналы, когда это сделано путем повышения StopIteration
• и это итеративно (то есть, что у него есть __iter__ метод, который возвращает self).

Заметки:

• __next__ метод в Python 3 пишется next в Python 2 и
• Встроенная функция next() вызывает этот метод для объекта, переданного ему.

Например:

>>> s = 'cat'      # s is an ITERABLE
                   # s is a str object that is immutable
                   # s has no state
                   # s has a __getitem__() method 

>>> t = iter(s)    # t is an ITERATOR
                   # t has state (it starts by pointing at the "c"
                   # t has a next() method and an __iter__() method

>>> next(t)        # the next() function returns the next value and advances the state
'c'
>>> next(t)        # the next() function returns the next value and advances
'a'
>>> next(t)        # the next() function returns the next value and advances
't'
>>> next(t)        # next() raises StopIteration to signal that iteration is complete
Traceback (most recent call last):
...
StopIteration

>>> iter(t) is t   # the iterator is self-iterable

Answer 3

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

Кроме того, люди имеют тенденцию становиться "слишком питоническими", помещая такие определения, как "X - это объект, который имеет __foo__() Метод "до". Такие определения верны - они основаны на философии типизации утки, но при попытке понять концепцию в ее простоте основное внимание уделяется методам.

Поэтому я добавляю свою версию.

---

На естественном языке,

• итерация - это процесс принятия одного элемента за раз в ряд элементов.

В Python

• "Итерируемый" - это объект, который, ну, в общем, итерируемый, что проще говоря, означает, что его можно использовать в итерации, например, с for петля. Как? С помощью итератора. Я объясню ниже.

• ... в то время как итератор - это объект, который определяет, как на самом деле выполнять итерацию, в частности, что является следующим элементом. Вот почему это должно иметьnext() метод.

Сами итераторы тоже итеративны, с той разницей, что их __iter__() метод возвращает тот же объект (self), независимо от того, были ли его предметы использованы предыдущими звонками next(),

---

Так что же думает интерпретатор Python, когда видит for x in obj: заявление?

Смотри, for петля. Похоже, работа для итератора... Давайте возьмем.... есть это obj парень, так что давайте спросим его.

"Мистер. obj, у тебя есть итератор?" (... звонки iter(obj), который вызывает obj.__iter__(), который радостно раздает новый блестящий итератор _i.)

Хорошо, это было легко... Давайте начнем итерацию тогда. (x = _i.next()... x = _i.next()...)

С мистером obj успешно в этом тесте (имея определенный метод, возвращающий действительный итератор), мы награждаем его прилагательным: теперь вы можете называть его "итеративный мистер" obj".

Тем не менее, в простых случаях вам не выгодно иметь итератор и итерацию отдельно. Таким образом, вы определяете только один объект, который также является его собственным итератором. (Python на самом деле не волнует, что _i раздал obj не все так блестяще, а просто obj сам.)

Вот почему в большинстве примеров, которые я видел (и что меня смущало снова и снова), вы можете увидеть:

class IterableExample(object):

    def __iter__(self):
        return self

    def next(self):
        pass

вместо

class Iterator(object):
    def next(self):
        pass

class Iterable(object):
    def __iter__(self):
        return Iterator()

Однако существуют случаи, когда вы можете извлечь выгоду из отделения итератора от итерируемого, например, когда вы хотите иметь одну строку элементов, но больше "курсоров". Например, если вы хотите работать с "текущими" и "предстоящими" элементами, вы можете иметь отдельные итераторы для обоих. Или несколько потоков, извлекаемых из огромного списка: каждый может иметь свой собственный итератор для обхода всех элементов. Смотрите ответы @Raymond's и @glglgl выше.

Представьте, что вы можете сделать:

class SmartIterableExample(object):

    def create_iterator(self):
        # An amazingly powerful yet simple way to create arbitrary
        # iterator, utilizing object state (or not, if you are fan
        # of functional), magic and nuclear waste--no kittens hurt.
        pass    # don't forget to add the next() method

    def __iter__(self):
        return self.create_iterator()

Заметки:

• Я повторю еще раз: итератор не повторяется. Итератор не может быть использован в качестве "источника" в for петля. Какие for цикл в первую очередь необходимо __iter__()(который возвращает что-то с next()).

• Конечно, for это не единственный итерационный цикл, поэтому вышеприведенное относится и к некоторым другим конструкциям (while...).

• итератора next() может бросить StopIration, чтобы остановить итерацию. Не нужно, однако, он может повторяться вечно или использовать другие средства.

• В вышеупомянутом "мыслительном процессе", _i на самом деле не существует. Я придумал это имя.

• В Python 3.x есть небольшое изменение: next() метод (не встроенный) теперь должен вызываться __next__(), Да, так и должно быть.

• Вы также можете думать об этом так: итерируемый имеет данные, итератор вытягивает следующий элемент

Отказ от ответственности: я не являюсь разработчиком интерпретатора Python, поэтому я не знаю, что "думает" интерпретатор. Приведенные выше размышления являются лишь демонстрацией того, как я понимаю эту тему из других объяснений, экспериментов и реального опыта новичка в Python.

Answer 4

Итерируемый - это объект, который имеет __iter__() метод. Это может возможно повторяться в течение нескольких раз, таких как list()с и tuple()s.

Итератор - это объект, который выполняет итерацию. Возвращается __iter__() метод, возвращает себя через свой собственный __iter__() метод и имеет next() метод (__next__() в 3.х).

Итерация - это процесс вызова этого next() соответственно __next__() пока не поднимется StopIteration,

Пример:

>>> a = [1, 2, 3] # iterable
>>> b1 = iter(a) # iterator 1
>>> b2 = iter(a) # iterator 2, independent of b1
>>> next(b1)
1
>>> next(b1)
2
>>> next(b2) # start over, as it is the first call to b2
1
>>> next(b1)
3
>>> next(b1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
>>> b1 = iter(a) # new one, start over
>>> next(b1)
1

Answer 5

Вот мой шпаргалка:

 sequence
  +
  |
  v
   def __getitem__(self, index: int):
  +    ...
  |    raise IndexError
  |
  |
  |              def __iter__(self):
  |             +     ...
  |             |     return <iterator>
  |             |
  |             |
  +--> or <-----+        def __next__(self):
       +        |       +    ...
       |        |       |    raise StopIteration
       v        |       |
    iterable    |       |
           +    |       |
           |    |       v
           |    +----> and +-------> iterator
           |                               ^
           v                               |
   iter(<iterable>) +----------------------+
                                           |
   def generator():                        |
  +    yield 1                             |
  |                 generator_expression +-+
  |                                        |
  +-> generator() +-> generator_iterator +-+

Тест: Вы видите, как...

• каждый итератор является итеративным?
• контейнерные объекты __iter__() метод можно реализовать как генератор?
• итеративный плюс __next__ метод не обязательно итератор?

Answer 6

Я не знаю, помогает ли это кому-либо, но мне всегда нравится визуализировать концепции в моей голове, чтобы лучше понять их. Так как у меня есть маленький сын, я визуализирую концепцию итерации / итератора с кирпичами и белой бумагой.

Предположим, мы в темной комнате и на полу у нас есть кирпичи для моего сына. Кирпичи разного размера, цвета сейчас не имеют значения. Предположим, у нас есть 5 таких кирпичей. Эти 5 кирпичей можно описать как объект - скажем, набор кирпичей. С этим набором кирпичей мы можем многое сделать - взять один, затем второй, третий, поменять местами кирпичи, поставить первый кирпич выше второго. Мы можем сделать много разных вещей с ними. Поэтому этот набор кирпичей является повторяемым объектом или последовательностью, поскольку мы можем пройти через каждый кирпичик и что-то с ним сделать. Мы можем делать это только как мой маленький сын - мы можем играть с одним кирпичиком за раз. Итак, снова я представляю себе этот набор кирпичей, чтобы быть повторяемым.

Теперь помните, что мы в темной комнате. Или почти темно. Дело в том, что мы не можем четко видеть эти кирпичи, какого они цвета, какой формы и т. Д. Поэтому, даже если мы хотим что-то с ними сделать - то есть перебрать их - мы на самом деле не знаем, что и как, потому что это слишком темный.

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

Это, кстати, объясняет мою раннюю ошибку, когда я попробовал следующее в IDLE и получил TypeError:

 >>> X = [1,2,3,4,5]
 >>> next(X)
 Traceback (most recent call last):
    File "<pyshell#19>", line 1, in <module>
      next(X)
 TypeError: 'list' object is not an iterator

Список X здесь был нашим набором кирпичей, но НЕ белым листом бумаги. Сначала мне нужно было найти итератор:

>>> X = [1,2,3,4,5]
>>> bricks_kit = [1,2,3,4,5]
>>> white_piece_of_paper = iter(bricks_kit)
>>> next(white_piece_of_paper)
1
>>> next(white_piece_of_paper)
2
>>>

Не знаю, поможет ли это, но это помогло мне. Если бы кто-то смог подтвердить / исправить визуализацию концепции, я был бы благодарен. Это помогло бы мне узнать больше.

Answer 7

Итераторы имеют __iter__ метод, который каждый раз создает новый итератор.

Итераторы реализуют __next__ метод, который возвращает отдельные элементы, и __iter__ метод, который возвращает self,

Следовательно, итераторы также являются итеративными, но итераторы не являются итераторами.

Лучано Рамальо, Свободный Питон.

Answer 8

Я не думаю, что вы можете сделать это намного проще, чем документация, однако я попробую:

• Итерируемость - это то, что можно повторять. На практике это обычно означает последовательность, например нечто, имеющее начало и конец, и какой-то способ пройти через все элементы в нем.

• Итератор можно рассматривать как вспомогательный псевдо-метод (или псевдоатрибут), который дает (или содержит) следующий (или первый) элемент в итерируемом элементе. (На практике это просто объект, который определяет метод next())

• Итерация, вероятно, лучше всего объясняется определением слова Мерриам-Вебстер:

б: повторение последовательности компьютерных инструкций указанное количество раз или до тех пор, пока условие не будет выполнено - сравните рекурсию

Answer 9

Итераторы - это объекты, реализующие методы iter и next. Если эти методы определены, мы можем использовать цикл for или выражения.

      class Squares:
    def __init__(self, length):
        self.length = length
        self.i = 0
        
    def __iter__(self):
        print('calling __iter__') # this will be called first and only once
        return self
    
    def __next__(self): 
        print('calling __next__') # this will be called for each iteration
        if self.i >= self.length:
            raise StopIteration
        else:
            result = self.i ** 2
            self.i += 1
            return result

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

      class Cities:
    def __init__(self):
        self._cities = ['Brooklyn', 'Manhattan', 'Prag', 'Madrid', 'London']
        self._index = 0
    
    def __iter__(self):
        return self
    
    def __next__(self):
        if self._index >= len(self._cities):
            raise StopIteration
        else:
            item = self._cities[self._index]
            self._index += 1
            return item

Экземпляр класса Cities - итератор. Однако, если вы хотите повторить повторение по городам, вам нужно создать новый объект, что является дорогостоящей операцией. Вы можете разделить класс на 2 класса: один возвращает города, а второй возвращает итератор, который получает города в качестве параметра инициализации.

      class Cities:
    def __init__(self):
        self._cities = ['New York', 'Newark', 'Istanbul', 'London']        
    def __len__(self):
        return len(self._cities)



class CityIterator:
    def __init__(self, city_obj):
        # cities is an instance of Cities
        self._city_obj = city_obj
        self._index = 0
        
    def __iter__(self):
        return self
    
    def __next__(self):
        if self._index >= len(self._city_obj):
            raise StopIteration
        else:
            item = self._city_obj._cities[self._index]
            self._index += 1
            return item

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

Iterable - это объект Python, который реализует итеративный протокол. Для этого требуется только то, что возвращает новый экземпляр объекта итератора.

      class Cities:
    def __init__(self):
        self._cities = ['New York', 'Newark', 'Istanbul', 'Paris']
        
    def __len__(self):
        return len(self._cities)
    
    def __iter__(self):
        return self.CityIterator(self)
    
    class CityIterator:
        def __init__(self, city_obj):
            self._city_obj = city_obj
            self._index = 0

        def __iter__(self):
            return self

        def __next__(self):
            if self._index >= len(self._city_obj):
                raise StopIteration
            else:
                item = self._city_obj._cities[self._index]
                self._index += 1
                return item

Итераторы имеют и __next__, итерации имеют __iter__, поэтому мы можем сказать, что итераторы также являются итерациями, но они исчерпываются. Итерируемые объекты, с другой стороны, никогда не исчерпываются, потому что они всегда возвращают новый итератор, который затем используется для итерации.

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

Итерация по итерации

В Python есть встроенная функция iter(), которая вызывает __iter__(). Когда мы перебираем итерацию, Python вызывает iter(), который возвращает итератор, а затем начинает использовать __next__() итератора для перебора данных.

Обратите внимание, что в приведенном выше примере Cities создает итерацию, но это не тип последовательности, это означает, что мы не можем получить город по индексу. Чтобы исправить это, мы должны просто добавить __get_item__ в класс Города.

      class Cities:
    def __init__(self):
        self._cities = ['New York', 'Newark', 'Budapest', 'Newcastle']
        
    def __len__(self):
        return len(self._cities)
    
    def __getitem__(self, s): # now a sequence type
        return self._cities[s]
    
    def __iter__(self):
        return self.CityIterator(self)
    
    class CityIterator:
        def __init__(self, city_obj):
            self._city_obj = city_obj
            self._index = 0

        def __iter__(self):
            return self

        def __next__(self):
            if self._index >= len(self._city_obj):
                raise StopIteration
            else:
                item = self._city_obj._cities[self._index]
                self._index += 1
                return item

Answer 10

Итерируемый:- то, что является итерируемым, итеративно; как последовательности, такие как списки, строки и т. д. Также он имеет __getItem__() метод или iter() функция, которая возвращает итератор.

Итератор:- Когда мы получаем объект итератора из iter() метод повторяемости; мы называем __next__() метод (в python3) или просто next() (в python2), чтобы получить элементы один за другим. Этот класс или экземпляр этого класса называется итератором.

Из документов:-

Использование итераторов пронизывает и объединяет Python. За кулисами, для заявления звонков iter() на объекте контейнера. Функция возвращает объект итератора, который определяет метод __next__() который обращается к элементам в контейнере по одному. Когда больше нет элементов, __next__() вызывает исключение StopIteration, которое сообщает циклу for завершиться. Вы можете позвонить __next__() метод с использованием next() встроенная функция; этот пример показывает, как все это работает:

>>> s = 'abc'
>>> it = iter(s)
>>> it
<iterator object at 0x00A1DB50>
>>> next(it)
'a'
>>> next(it)
'b'
>>> next(it)
'c'
>>> next(it)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
    next(it)
StopIteration

Бывший класс:-

class Reverse:
    """Iterator for looping over a sequence backwards."""
    def __init__(self, data):
        self.data = data
        self.index = len(data)
    def __iter__(self):
        return self
    def __next__(self):
        if self.index == 0:
            raise StopIteration
        self.index = self.index - 1
        return self.data[self.index]


>>> rev = Reverse('spam')
>>> iter(rev)
<__main__.Reverse object at 0x00A1DB50>
>>> for char in rev:
...     print(char)
...
m
a
p
s

Answer 11

• Итерацию является объектом , который имеет ITER () метод , который возвращает итератор. Это то, что можно зациклить. Пример: список является итеративным, потому что мы можем перебирать список, НО не является итератором
• Итератор это объект , который вы можете получить итератор с. Это объект с таким состоянием, что он запоминает, где он находится во время итерации.

Чтобы узнать, есть ли у объекта этот метод iter (), мы можем использовать приведенную ниже функцию.

      ls = ['hello','bye']
print(dir(ls))

Выход

      ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

Как вы можете видеть, есть iter (), что означает, что это итеративный объект, но не содержит метода next (), который является функцией объекта итератора.

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

Answer 12

iterable = [1, 2] 

iterator = iter(iterable)

print(iterator.__next__())   

print(iterator.__next__())   

так,

1. iterable это объект, который может быть зациклен на. например, список, строка, кортеж и т. д.

2. с использованием iter функционировать на нашем iterable объект вернет объект итератор.

3. теперь этот объект итератора имеет метод с именем __next__ (в Python 3 или просто next в Python 2), с помощью которого вы можете получить доступ к каждому элементу итерации.

Итак, ВЫШЕ ВЫШЕ КОДА БУДУТ:

1

2

Answer 13

Вот еще один вид с использованием. Это представление может быть полезно во второй раз или позже.

Из collections.abc мы можем увидеть следующую иерархию:

      builtins.object
    Iterable
        Iterator
            Generator

т.е. генератор является производным от Iterator, производным от Iterable и производным от базового объекта.

Следовательно,

• Каждый итератор является итератором, но не каждый итератор. Например, [1, 2, 3] и range(10) являются итераторами, но не итераторами. x = iter([1, 2, 3])является итератором и итератором .
• Аналогичные отношения существуют между Iterator и Generator.
• Вызов итератора или генератора возвращает сам себя. Таким образом, если it является итератором, то iter(it) is it правда.
• Под капотом понимание списка вроде [2 * x for x in nums] или цикл for, как если бы iter() вызывается в iterable (), а затем перебирает numsиспользуя этот итератор. Следовательно, все следующие функционально эквивалентны (например, nums=[1, 2, 3]):
  • for x in nums:
  • for x in iter(nums):
  • for x in iter(iter(nums)):
  • for x in iter(iter(iter(iter(iter(nums))))):

Answer 14

Прежде чем иметь дело с итераторами и итераторами, основным фактором, определяющим итерируемость и итератор, является последовательность

Последовательность: последовательность представляет собой сбор данных

Iterable:Iterable - это объект типа последовательности, который поддерживает метод Iter.

Метод Iter: метод Iter принимает последовательность в качестве входных данных и создает объект, известный как итератор

Iterator: Iterator - это объект, который вызывает следующий метод и проходит через последовательность. При вызове следующего метода он возвращает объект, который он прошел в данный момент.

пример:

x=[1,2,3,4]

х последовательность, которая состоит из сбора данных

y=iter(x)

При вызове iter(x) он возвращает итератор, только если у объекта x есть метод iter, в противном случае он вызывает исключение. Если он возвращает итератор, то y присваивается следующим образом:

y=[1,2,3,4]

Поскольку у является итератором, следовательно, он поддерживает метод next()

При вызове метода next он возвращает отдельные элементы списка по одному.

После возврата последнего элемента последовательности, если мы снова вызываем следующий метод, возникает ошибка StopIteration.

пример:

>>> y.next()
1
>>> y.next()
2
>>> y.next()
3
>>> y.next()
4
>>> y.next()
StopIteration

Answer 15

Для меня глоссарий Python был наиболее полезен для этих вопросов, например, для итерации он говорит:

Объект, способный возвращать свои члены по одному. Примеры итераций включают все типы последовательностей (такие как list, str и tuple) и некоторые непоследовательные типы, такие как dict, файловые объекты и объекты любых классов, которые вы определяете с помощью метода iter() или метода getitem(), который реализует семантику последовательности.

Итерируемые объекты могут использоваться в цикле for и во многих других местах, где требуется последовательность (zip(), map(),…). Когда итерируемый объект передается в качестве аргумента встроенной функции iter(), она возвращает итератор для объекта. Этот итератор подходит для одного прохода по набору значений. При использовании итераторов обычно нет необходимости вызывать iter () или самостоятельно работать с объектами итератора. Оператор for делает это автоматически, создавая временную безымянную переменную для хранения итератора в течение всего цикла. См. Также итератор, последовательность и генератор.

Answer 16

Другие люди уже пояснялось всесторонне, что Iterable и итератор, поэтому я буду стараться делать то же самое с генераторами.

ИМХО, основная проблема для понимания генераторов - это запутанное использование слова "генератор", потому что это слово используется в двух разных значениях:

1. как инструмент для создания (генерации) итераторов,
   • в виде функции, возвращающей итератор (т.е. с yield заявление (я) в его теле),
   • в виде генератора выражения
2. в результате использования этого инструмента, то есть итогового итератора.
   (В этом смысле генератор - это особая форма итератора - слово "генератор" указывает на то, как этот итератор был создан.)

---

Генератор как инструмент 1- ^го типа:

       In[2]: def my_generator():
  ...:     yield 100
  ...:     yield 200

In[3]: my_generator

        Out[3]: <function __main__.my_generator()>

       In[4]: type(my_generator)

        Out[4]: function

Генератор в результате (т.е. итератор) использования этого инструмента:

       In[5]: my_iterator = my_generator()
In[6]: my_iterator

        Out[6]: <generator object my_generator at 0x00000000053EAE48>

       In[7]: type(my_iterator)

        Out[7]: generator

---

Генератор как инструмент 2- ^го типа - неотличим от итогового итератора этого инструмента:

       In[8]: my_gen_expression = (2 * i for i in (10, 20))
In[9]: my_gen_expression

        Out[9]: <generator object <genexpr> at 0x000000000542C048>

       In[10]: type(my_gen_expression)

        Out[10]: generator

Answer 17

Вот пример: class Square (): def init (self, max):self.max =max self.power = 0 def iter (self): return self def next (self):

          if(self.power<=self.max):
        result = 2**self.power
        self.power +=1
        return result

    else:
        raise StopIteration

square = Квадрат (5) для i в квадрате: print (i)

Answer 18

В Python все является объектом. Когда говорят, что объект является итеративным, это означает, что вы можете пройти (т.е. итерировать) объект как коллекцию.

Например, массивы являются повторяемыми. Вы можете пройти по ним с помощью цикла for и перейти от индекса 0 к индексу n, где n - длина объекта массива минус 1.

Словари (пары ключ / значение, также называемые ассоциативными массивами) также являются итеративными. Вы можете пройти через их ключи.

Очевидно, что объекты, которые не являются коллекциями, не являются итеративными. Например, объект bool имеет только одно значение: True или False. Он не повторяется (не имеет смысла, что это повторяемый объект).

Прочитайте больше. http://www.lepus.org.uk/ref/companion/Iterator.xml