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

Какое самое основное определение «итерируемого», «итератора» и «итерации» в Python?

Я прочитал несколько определений, но я не могу определить точное значение, так как оно все равно не впитается.

Может кто-нибудь, пожалуйста, помогите мне с 3 определениями в терминах непрофессионала?

Ответы на вопрос(12)

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

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

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
 coelhudo28 янв. 2018 г., 08:45
Просто наблюдение: y = iter (x) не совсем y = [1,2,3,4], так как y теперь является объектом итератора. Возможно, вам следует добавить комментарий, чтобы уточнить, что это не список, а объект-итератор, или изменить представление.

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

Кроме того, люди имеют тенденцию становиться «слишком питоническими», помещая такие определения, как «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()

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

 Rich24 нояб. 2018 г., 11:15
Хотя мне нравится, что вы подчеркиваете различие между итератором и итератором, этот ответ противоречит сам себе. Сначала вы пишете: «Итераторы сами по себе также итерируемы» (что соответствует тому, что написано вдокументация Python). Но потом ты пишешь:итератор не повторяется, Итератор не может быть использован в качестве «источника» вfor цикл». Я понимаю ваш ответ, и мне нравится это в противном случае, но я думаю, что было бы полезно исправить это.
 nealmcb10 апр. 2017 г., 18:34
Почему ты ставишь простоpass в коде для техnext определения? Я предполагаю, что вы просто имеете в виду, что кто-то должен реализовать способ получить следующий, поскольку next должен что-то возвращать.
 Alois Mahdal12 апр. 2017 г., 05:18
@nealmcb Да, я думаю, что это значит для меня. (Это то чтоpass это для, после всего.)
 nealmcb21 апр. 2017 г., 14:46
@AloisMahdal Аааа, я не видел такого использования раньше. Когда я вижуpassЯ думаю, что это там по синтаксическим причинам. Я просто наткнулся на ответы вмноготочие что довольно интересно: вы можете использовать... чтобы указать блок «todo позже».NotImplemented также доступно.
 Racing Tadpole21 мар. 2017 г., 05:17
Это здорово - но я все еще немного растерялся. Я думал, что ваша желтая коробка говорит, чтоfor Для цикла требуется итератор («Посмотрите, цикл for. Похоже на работу для итератора ... Давайте его получим».). Но затем в примечаниях в конце говорится, что «Итератор не может быть использован в качестве источника вfor петля»...?

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

Предположим, мы в темной комнате и на полу у нас есть кирпичи для моего сына. Кирпичи разного размера, цвета, теперь не имеет значения. Предположим, у нас есть 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
>>>

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

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
 lmiguelvargasf06 февр. 2017 г., 16:26
что вы подразумеваете под свежим итератором?
 fountainhead19 февр. 2019 г., 06:07
Просьба перефразировать "все, что вы можете позвонить сiter()«как» все, что вы можете передатьiter()"
 fountainhead19 февр. 2019 г., 05:58
Ваши 2-я, 3-я и 4-я марки четко указывают, что вы имеете в виду, с точки зрения конкретных конструкций Python, встроенных модулей или вызовов методов. Но первая пуля («все, что может быть зациклено») не имеет такой ясности. Кроме того, первая пуля, кажется, перекрывается со второй, так как вторая пуля оfor петли, и первая пуля о "зацикливание". Не могли бы вы обратиться к этим?
 Raymond Hettinger07 февр. 2017 г., 04:15
@lmiguelvargasf "Свежий", как в "новом и неиспользованном", а не "исчерпанный или частично потребленный". Идея состоит в том, что новый итератор начинается в начале, а частично используемый итератор начинает с того места, где он остановился.

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

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

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

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

iterable = [1, 2] 

iterator = iter(iterable)

print(iterator.__next__())   

print(iterator.__next__())   

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

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

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

И ВЫШЕ ВЫШЕ КОДА БУДУТ:

1

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

Iterable: - то, что итеративно, итеративно; как последовательности, такие как списки, строки и т. д. Также он имеет__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
Решение Вопроса

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

В Pythonитерируемый а такжеитератор имеют конкретные значения.

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

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

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

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

 shadowtalker19 сент. 2018 г., 18:05
@ jlh звучит так, будто вы предлагаете очень самоуверенное поведение по умолчанию. Считают, что{'a': 'hi', 'b': 'bye'} имеет длину 2, но не может быть проиндексирован 0, 1 или 2.
 shadowtalker19 сент. 2018 г., 08:45
@ jlh почему бы__len__ быть обязательно привязанным к итерации? Как знание длины чего-либо поможет вам повторить это?
 jlh19 сент. 2018 г., 12:46
@shadowtalker это поможет узнать, какие индексы являются действительными, так что вы знаете, какие индексы можно использовать с__getitem__.
 Janus Troelsen27 июл. 2018 г., 11:33
Обратите внимание, чтоcollections.abc.AsyncIterator тесты для__aiter__ а также__anext__ методы. Это новое дополнение в 3.6.
 Rich24 нояб. 2018 г., 10:59
@shadowtalker. Но у диктанта есть__iter__ метод. Я думаю, что jlh относится к объектам, которые являются итеративными, в частности, потому что они определяют:__getitem__ метод, который может принимать последовательные индексы, начиная с нуля ".

документацияОднако попробую:

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

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

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

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

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

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

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

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

Читать далее.http://www.lepus.org.uk/ref/companion/Iterator.xml

 Mark Amery17 окт. 2014 г., 00:58
объекты, которые не являются коллекциями, не повторяемы это вообще не правда. Чтобы привести только пару примеров, генераторы итерируемы, но не являются коллекциями, а объекты итераторов создаются путем вызоваiter() Стандартные типы коллекций являются итеративными, но сами по себе не являются коллекциями.

__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
 glglgl27 мар. 2012 г., 08:18
Часто, но не всегда. Курсор генератора, файла или базы данных может быть повторен только один раз и, следовательно, является их собственным итератором.
 glglgl05 нояб. 2016 г., 10:41
@ Да, да. Как иIterator является всегдаIterable и это его собственнаяIterator, два вызоваiter() не обязательно давать два независимыхIterators.
 thechrishaddad27 мар. 2012 г., 08:17
Так на самом деле это просто объект, который проходит через контейнер? было бы это полезно?
 Bin04 нояб. 2016 г., 17:11
Я думаю, что b2 не должен быть независимым от b1? для этого особого случая он независим, уверен, я могу сделать его не независимым, а также действительнымIterable.

Ваш ответ на вопрос