Какое самое основное определение "итерируемого", "итератора" и "итерации" в Python?
Я прочитал несколько определений, но я не могу определить точное значение, так как оно все равно не впитается.
Может кто-нибудь помочь мне с 3 определениями в терминах непрофессионала?
Итерация является общим термином для взятия каждого элемента чего-то одного за другим. Каждый раз, когда вы используете цикл, явный или неявный, перебирать группу элементов, то есть итерацию.
В Python итеративный и итератор имеют определенные значения.
Итерируемый - это объект, который имеет метод __iter__, который возвращает iterator или определяет метод __getitem__, который может принимать последовательные индексы, начиная с нуля (и повышает значение IndexError, когда индексы больше не действительны). Таким образом iterable - это объект, из которого вы можете получить итератор.
Итератор - это объект с методом next (Python 2) или __next__ (Python 3).
Всякий раз, когда вы используете цикл for или map, или понимание списка и т.д. в Python, метод next вызывается автоматически, чтобы получить каждый элемент из iterator таким образом пройдя процесс итерации.
Хорошим местом для начала обучения будет раздел итераторов учебника и раздел типов итераторов стандартных типов страница. После того, как вы поймете основы, попробуйте раздел итераторов функционального программирования HOWTO.
Вот объяснение, которое я использую при обучении классам Python:
ITERABLE:
for x in iterable: ... илиiter(), который вернет ITERATOR: 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
Вышеупомянутые ответы велики, но, как и большинство из того, что я видел, не подчеркивайте различия, достаточные для таких людей, как я.
Кроме того, люди склонны получать "слишком Pythonic", помещая определения типа "X - это объект, который имеет метод __foo__()" раньше. Такие определения правильны - они основаны на философии утиной печати, но основное внимание на методах имеет тенденцию обойтись, пытаясь понять концепцию в своей простоте.
Итак, я добавляю свою версию.
На естественном языке
В Python
iterable - это объект, который, ну, итерируемый, который просто ставится, означает, что
его можно использовать на итерации, например. с петлей for. Как? Используя итератор.
Я объясню ниже.
... while Итератор - это объект, который определяет, как реально выполнять
итерация - именно то, что является следующим элементом. Вот почему он должен иметь
next().
Итераторы сами по себе также являются итерабельными, с тем отличием, что их метод __iter__() возвращает тот же объект (self), независимо от того, были ли его элементы использованы предыдущими вызовами next().
Так что думает интерпретатор Python, когда он видит инструкцию for x in obj:?
Посмотрите, a
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 и @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() может вывести StopIteration, чтобы остановить итерацию. Не должны,
хотя он может итерировать навсегда или использовать другие средства.
В приведенном выше "мыслительном процессе" _i действительно не существует. Я составил это имя.
Там небольшое изменение в методе Python 3.x: next() (а не встроенное) теперь
следует называть __next__(). Да, это должно было быть так все время.
Вы также можете думать об этом так: iterable имеет данные, итератор тянет следующий элемент
Отказ от ответственности: я не разработчик любого интерпретатора Python, поэтому я не знаю, что интерпретатор "думает". Вышеупомянутые размышления - это единственная демонстрация того, как я понимаю эту тему из других объяснений, экспериментов и реального опыта новичка Python.
Итерируемый объект, имеющий метод __iter__(). Он может выполняться несколько раз, например list() и tuple() s.
Итератором является объект, который выполняет итерацию. Он возвращается методом __iter__(), возвращает себя через свой собственный метод __iter__() и имеет метод next() (__next__() в 3.x).
Итерация - это процесс вызова этого next() resp. __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
Я не знаю, помогает ли это кому-либо, но мне всегда нравится визуализировать концепции в моей голове, чтобы лучше понять их. Так как у меня есть маленький сын, я представляю концепцию итератора/итератора с кирпичами и белой бумагой.
Предположим, что мы находимся в темной комнате, а на полу у нас есть кирпичи для моего сына. Кирпичи разного размера, цвета, теперь не имеют значения. Предположим, что у нас 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
>>>
Не знаю, помогает ли это, но это помогло мне. Если бы кто-то мог подтвердить/исправить визуализацию концепции, я был бы благодарен. Это поможет мне узнать больше.
Вот мой чит-лист:
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__ не обязательно является итератором? Итерируемый: - то, что является итеративным, является итеративным; такие как последовательности, такие как списки, строки и т.д. Также он имеет метод __getitem__ или метод __iter__. Теперь, если мы используем функцию iter() для этого объекта, мы получим итератор.
Итератор: - когда мы получаем объект итератора из функции iter(); мы вызываем __next__() (в python3) или просто next() (в python2), чтобы получить элементы один за другим. Этот класс или экземпляр этого класса называется итератором.
Из документов: -
Использование итераторов пронизывает и объединяет Python. За кулисами оператор for вызывает 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
Я не думаю, что вы можете сделать это намного проще, чем документация, однако я попробую:
Вы можете думать Iterator как псевдо-метод помощника (или псевдоатрибут), который дает (или удерживает) следующий (или первый) элемент в итерабельном. (На практике это всего лишь объект, который определяет метод next())
Итерация, вероятно, лучше всего объясняется определением слова :
b: повторение последовательности компьютерных команд, указанных количество раз или до выполнения условия - сравнить рекурсию
iterable = [1, 2]
iterator = iter(iterable)
print(iterator.__next__())
print(iterator.__next__())
так,
iterable - объект, который может зацикливаться на. например список, строка, кортеж и т.д.
с помощью функции iter на нашем объекте iterable будет возвращен объект итератора.
теперь этот объект-итератор имеет метод с именем __next__ (в Python 3 или просто next в Python 2), с помощью которого вы можете получить доступ к каждому элементу итерабельного.
так, ВЫВОД ВЫШЕГО КОДА БУДЕТ:
1
2
Прежде чем обращаться к итерам и итератору, основным фактором, решающим итеративный итератор, является последовательность
Последовательность: последовательность представляет собой набор данных
Iterable: Iterable - это объект типа последовательности, поддерживающий метод Iter.
Метод Итера: метод Итера принимает последовательность как вход и создает объект, который известен как итератор
Итератор: Итератор - это объект, который вызывает следующий метод и поперек через последовательность. При вызове следующего метода он возвращает объект, который он пересекал в настоящее время.
Пример:
x=[1,2,3,4]
x - последовательность, состоящая из набора данных
y=iter(x)
При вызове iter (x) он возвращает итератор только тогда, когда объект x имеет итерационный метод, иначе он вызывает исключение. Если он возвращает итератор, тогда y присваивается следующим образом:
y=[1,2,3,4]
Так как y является итератором, то он поддерживает метод next()
При вызове следующего метода он возвращает отдельные элементы списка один за другим.
После возврата последнего элемента последовательности, если мы снова вызываем следующий метод, он вызывает ошибку StopIteration
Пример:
>>> y.next()
1
>>> y.next()
2
>>> y.next()
3
>>> y.next()
4
>>> y.next()
StopIteration
Iterables имеет метод
__iter__который каждый раз запускает новый итератор.Итераторы реализуют метод
__next__который возвращает отдельные элементы, и метод__iter__который возвращаетself.Поэтому итераторы также являются итерабельными, но итераторы не являются итераторами.
Лучиано Рамальо, Свободный Питон.
В Python все является объектом. Когда объект называется итерируемым, это означает, что вы можете выполнить (например, итерировать) объект как коллекцию.
Массивы, например, являются итерабельными. Вы можете пройти через них с циклом for и перейти от индекса 0 к индексу n, n - длина объекта массива минус 1.
Словари (пары ключей/значений, также называемые ассоциативными массивами) также являются итерабельными. Вы можете выполнить их ключи.
Очевидно, что объекты, которые не являются коллекциями, не являются итерабельными. Например, объект bool имеет только одно значение: True или False. Это не является итерируемым (было бы бессмысленно, что это итерируемый объект).
Подробнее. http://www.lepus.org.uk/ref/companion/Iterator.xml