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

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

итерацией является:

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

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

• С состоянием, которое помнит, где оно находится во время итерации,
• С __next__ метод, который:
  • возвращает следующее значение в итерации
  • обновляет состояние, чтобы указать на следующее значение
  • сигналы, когда это делается путем повышения StopIteration
• и это само-iterable (что означает, что это имеет __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

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

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

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

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

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

В Python,

• типа Iterable это объект, который, ну, iterable, что проще говоря, означает, что его можно использовать в итерации, например, с 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 преуспел в этом тесте (имея определенный метод, возвращающий действительный итератор), мы вознаграждаем его прилагательным: теперь вы можете назвать его "iterable Mr 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()

однако есть случаи, когда вы можете извлечь выгоду из того, что итератор отделен от iterable, например, когда вы хотите иметь одну строку элементов, но больше "курсоров". Например, когда вы хотите работать с "текущей" и "предстоящие" элементы, вы можете иметь отдельные итераторы для обоих. Или несколько потоков, тянущих из огромного списка: каждый может иметь свой собственный итератор для обхода всех элементов. См.@Рэймонда и @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()

Примечания:

• повторю еще раз:итератор не является iterable. Итератор нельзя использовать как "источник" в for петли. Что? for петля в первую очередь нуждается в __iter__() (это возвращает что-то с next()).

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

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

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

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

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

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

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

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

итерация-это процесс вызова this 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

объект – скажем кирпичи кит!--9-->. Мы можем сделать много вещей с этим набором кирпичей – можем принять одно и после этого принять второе и после этого третье, можем изменить места кирпичей, положили первый кирпич над вторым. С ними мы можем многое сделать. Поэтому этот набор кирпичей является iterable object или последовательность как мы можем пройти через каждый кирпич и сделать что-то с ним. Мы можем делать это только как мой маленький сын-мы можем играть с один кирпич во время. И снова я ... представьте себе, что этот набор кирпичей типа Iterable.

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

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

Это, кстати, объясняет мою раннюю ошибку, когда я пробовал следующее в режиме ожидания и получил 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
>>>

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

вот моя шпаргалка:

 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__() метод может быть реализован как генератор?
• iterable плюс __next__ метод не обязательно является итератором?

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

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

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

• шаг, вероятно, лучше всего объясняется Merriam-Webster определение слова :

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

iterable = [1, 2] 

iterator = iter(iterable)

print(iterator.__next__())   

print(iterator.__next__())   

и

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

2. С помощью

прежде чем иметь дело с iterables и iterator основным фактором, который решает iterable и iterator, является последовательность

последовательность: последовательность-это сбор данных

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

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

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

пример:

x=[1,2,3,4]

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

y=iter(x)

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

y=[1,2,3,4]

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

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

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

пример:

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

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

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

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

использование итераторов пронизывает и объединяет Python. За кулисами оператор for вызывает iter() на объект-контейнер. Функция возвращает объект итератора, определяющий метод __next__() что доступ к элементам в контейнере, по одному за раз. Когда больше нет элементов,__next__() вызывает исключение StopIteration, которое сообщает циклу for о завершении. Вы можете вызвать __next__() метод с использованием the 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

Ex класса: -

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

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

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

таким образом, итераторы также являются итераторами, но итераторы не являются итераторами.

Лучано Рамальо, Свободно Говорит На Языке Python.

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

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

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

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

подробнее. http://www.lepus.org.uk/ref/companion/Iterator.xml