Как мы можем использовать пользовательские итерации с помощью string.join ()? [Дубликат]

Вдохновленный ответом Мэтта Грегори, здесь немного сложнее итератор, который вернет a, b, ..., z, aa, ab, ..., zz, aaa, aab, ..., zzy, zzz

    class AlphaCounter:
    def __init__(self, low, high):
        self.current = low
        self.high = high

    def __iter__(self):
        return self

    def __next__(self): # Python 3: def __next__(self)
        alpha = ' abcdefghijklmnopqrstuvwxyz'
        n_current = sum([(alpha.find(self.current[x])* 26**(len(self.current)-x-1)) for x in range(len(self.current))])
        n_high = sum([(alpha.find(self.high[x])* 26**(len(self.high)-x-1)) for x in range(len(self.high))])
        if n_current > n_high:
            raise StopIteration
        else:
            increment = True
            ret = ''
            for x in self.current[::-1]:
                if 'z' == x:
                    if increment:
                        ret += 'a'
                    else:
                        ret += 'z'
                else:
                    if increment:
                        ret += alpha[alpha.find(x)+1]
                        increment = False
                    else:
                        ret += x
            if increment:
                ret += 'a'
            tmp = self.current
            self.current = ret[::-1]
            return tmp

for c in AlphaCounter('a', 'zzz'):
    print(c)

Этот вопрос касается истребимых объектов, а не об итераторах. В Python последовательности также повторяются, поэтому один из способов сделать итерируемый класс - заставить его вести себя как последовательность, т. Е. Дать ему методы __getitem__ и __len__. Я тестировал это на Python 2 и 3.

class CustomRange:

    def __init__(self, low, high):
        self.low = low
        self.high = high

    def __getitem__(self, item):
        if item >= len(self):
            raise IndexError("CustomRange index out of range")
        return self.low + item

    def __len__(self):
        return self.high - self.low


cr = CustomRange(0, 10)
for i in cr:
    print(i)

Если вы ищете что-то короткое и простое, возможно, этого вам будет достаточно:

class A(object):
    def __init__(self, l):
        self.data = l

    def __iter__(self):
        return iter(self.data)

пример использования:

In [3]: a = A([2,3,4])

In [4]: [i for i in a]
Out[4]: [2, 3, 4]

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

• создать генератор (использует ключевое слово yield )
• использовать выражение генератора ( genexp )
• создает итератор (определяет __iter__ и __next__ (или next в Python 2.x))
• создает функцию, которую Python может выполнять самостоятельно самостоятельно ( определяет __getitem__ )

Примеры:

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

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

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

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

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

for iterator in uc_gen, uc_genexp, uc_iter, uc_getitem:
    for ch in iterator('abcde'):
        print ch,
    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__ (который должен возвращать новый итератор, который идет назад); и итеративный getitem (uc_getitem) должен иметь магический метод __len__:

    # for uc_iter
    def __reversed__(self):
        return reversed(self.text)

    # 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

Это приводит к (по крайней мере, для моего прогона пробела):

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

Все ответы на этой странице действительно великолепны для сложного объекта. Но для тех, которые содержат встроенные типы итераторов как атрибуты, такие как str, list, set или dict или любая реализация collections.Iterable, вы можете опустить некоторые вещи в своем классе.

class Test(object):
    def __init__(self, string):
        self.string = string

    def __iter__(self):
        # since your string is already iterable
        return (ch for ch in string)

Его можно использовать как:

for x in Test("abcde"):
    print(x)

# prints
# a
# b
# c
# d
# e

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

yield

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

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

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

. Выражения генератора - это целая другая червь червей (удивительные черви!). Они могут использоваться вместо List Consrehension для сохранения памяти (для понимания списка создается список в памяти, который уничтожается после использования, если не назначен переменной, но выражения генератора могут создавать объект Generator. который является причудливым способом сказать Итератор). Ниже приведен пример определения выражения генератора:

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

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

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

Я вижу, что некоторые из вас делают 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

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

Это итеративная функция без yield. Он использует функцию iter и замыкание, которое удерживает его состояние в изменяемом (list) в охватывающей области для python 2.

def count(low, high):
    counter = [0]
    def tmp():
        val = low + counter[0]
        if val < high:
            counter[0] += 1
            return val
        return None
    return iter(tmp, None)

Для Python 3 состояние закрытия сохраняется в неизменяемом в охватывающей области, а nonlocal используется в локальной области для обновления переменной состояния.

def count(low, high):
    counter = 0
    def tmp():
        nonlocal counter
        val = low + counter
        if val < high:
            counter += 1
            return val
        return None
    return iter(tmp, None)  

Тест;

for i in count(1,10):
    print(i)
1
2
3
4
5
6
7
8
9