How to build a basic iterator?

Как я могу создать итератор на Python?

Например, предположим, у меня есть класс, экземпляры которого логически "содержат" некоторые значения:

class Example:
    def __init__(self, values):
        self.values = values

Я хочу иметь возможность писать код, подобный:

e = Example([1, 2, 3])
# Each time through the loop, expose one of the values from e.values
for value in e:
    print("The example object contains", value)

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

Объекты итератора в python соответствуют протоколу iterator, что в основном означает, что они предоставляют два метода: __iter__() и __next__().

• __iter__ возвращает объект iterator и неявно вызывается в начале циклов.




• __next__() Метод возвращает следующее значение и неявно вызывается при каждом увеличении цикла. Этот метод вызывает исключение StopIteration, когда больше нет возвращаемого значения, которое неявно фиксируется циклическими конструкциями для остановки итерации.

Вот простой пример счетчика:

class Counter:
    def __init__(self, low, high):
        self.current = low - 1
        self.high = high

    def __iter__(self):
        return self

    def __next__(self): # Python 2: def next(self)
        self.current += 1
        if self.current < self.high:
            return self.current
        raise StopIteration


for c in Counter(3, 9):
    print(c)

Это выведет:

3
4
5
6
7
8

Это проще написать с помощью генератора, как описано в предыдущем ответе:

def counter(low, high):
    current = low
    while current < high:
        yield current
        current += 1

for c in counter(3, 9):
    print(c)

Печатный результат будет таким же. По сути, объект generator поддерживает протокол iterator и делает что-то примерно похожее на счетчик классов.

Статья Дэвида Мерца " Итераторы и простые генераторы" - довольно хорошее введение.

Существует четыре способа создания итеративной функции:

• создайте генератор (использует ключевое слово yield)


• используйте выражение генератора (genexp)


• создайте итератор (определяет __iter__ и __next__ (или next в Python 2.x))


• создайте класс, который Python может выполнять самостоятельно (определяет __getitem__)

Примеры:

# generator
def uc_gen(text):
    for char in text.upper():
        yield char

# generator expression
def uc_genexp(text):
    return (char for char in text.upper())

# iterator protocol
class uc_iter():
    def __init__(self, text):
        self.text = text.upper()
        self.index = 0
    def __iter__(self):
        return self
    def __next__(self):
        try:
            result = self.text[self.index]
        except IndexError:
            raise StopIteration
        self.index += 1
        return result

# getitem method
class uc_getitem():
    def __init__(self, text):
        self.text = text.upper()
    def __getitem__(self, index):
        return self.text[index]

Чтобы увидеть все четыре метода в действии:

for iterator in uc_gen, uc_genexp, uc_iter, uc_getitem:
    for ch in iterator('abcde'):
        print(ch, end=' ')
    print()

Что приводит к:

A B C D E
A B C D E
A B C D E
A B C D E

Примечание:

Два типа генератора (uc_gen и uc_genexp) не могут быть reversed(); простому итератору (uc_iter) потребуется __reversed__ волшебный метод (который, согласно документации, должен возвращать новый итератор, но возврат self работает (по крайней мере, в CPython)); и getitem iteratable (uc_getitem) должен иметь __len__ волшебный метод:

    # for uc_iter we add __reversed__ and update __next__
    def __reversed__(self):
        self.index = -1
        return self
    def __next__(self):
        try:
            result = self.text[self.index]
        except IndexError:
            raise StopIteration
        self.index += -1 if self.index < 0 else +1
        return result

    # for uc_getitem
    def __len__(self)
        return len(self.text)

Чтобы ответить на второстепенный вопрос полковника Паника о бесконечном лениво вычисляемом итераторе, вот эти примеры, использующие каждый из четырех вышеперечисленных методов:

# generator
def even_gen():
    result = 0
    while True:
        yield result
        result += 2


# generator expression
def even_genexp():
    return (num for num in even_gen())  # or even_iter or even_getitem
                                        # not much value under these circumstances

# iterator protocol
class even_iter():
    def __init__(self):
        self.value = 0
    def __iter__(self):
        return self
    def __next__(self):
        next_value = self.value
        self.value += 2
        return next_value

# getitem method
class even_getitem():
    def __getitem__(self, index):
        return index * 2

import random
for iterator in even_gen, even_genexp, even_iter, even_getitem:
    limit = random.randint(15, 30)
    count = 0
    for even in iterator():
        print even,
        count += 1
        if count >= limit:
            break
    print

Which results in (at least for my sample run):

0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40 42 44 46 48 50 52 54
0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38
0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30
0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32

How to choose which one to use? This is mostly a matter of taste. The two methods I see most often are generators and the iterator protocol, as well as a hybrid (__iter__ returning a generator).

Generator expressions are useful for replacing list comprehensions (they are lazy and so can save on resources).

If one needs compatibility with earlier Python 2.x versions use __getitem__.

Я вижу, что некоторые из вас делают return self в __iter__. Я просто хотел отметить, что __iter__ сам по себе может быть генератором (таким образом устраняя необходимость в __next__ и вызывая StopIteration исключения)

class range:
  def __init__(self,a,b):
    self.a = a
    self.b = b
  def __iter__(self):
    i = self.a
    while i < self.b:
      yield i
      i+=1

Конечно, здесь можно было бы создать генератор напрямую, но для более сложных классов это может быть полезно.

Прежде всего, модуль itertools невероятно полезен для всевозможных случаев, в которых итератор был бы полезен, но вот все, что вам нужно для создания итератора на python:

выход

Разве это не круто? Yield может использоваться для замены обычного return в функции. Он возвращает объект точно так же, но вместо уничтожения состояния и выхода, он сохраняет состояние на тот момент, когда вы захотите выполнить следующую итерацию. Вот пример этого в действии, извлеченный непосредственно из списка функций itertools:

def count(n=0):
    while True:
        yield n
        n += 1

Как указано в описании функций (это функция count() из модуля itertools ...) , она создает итератор, который возвращает последовательные целые числа, начинающиеся с n.

Выражения-генераторы - это совершенно другой набор червей (потрясающие черви!). Они могут использоваться вместо понимания списка для экономии памяти (понимание списка создает список в памяти, который уничтожается после использования, если не присвоен переменной, но выражения генератора могут создавать объект генератора... это необычный способ сказать "Итератор"). Вот пример определения выражения генератора:

gen = (n for n in xrange(0,11))

Это очень похоже на наше определение итератора выше, за исключением того, что полный диапазон заранее определен как от 0 до 10.

Я только что нашел xrange() (удивлен, что не видел его раньше ...) и добавил его в приведенный выше пример. xrange() - это итерируемая версия range(), преимущество которой в том, что не требуется предварительное построение списка. Было бы очень полезно, если бы у вас был огромный массив данных для итерации и было бы не так много памяти для этого.