如果你正在寻找一些简短而简单的东西，也许它对你来说已经足够了:

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]

在类代码中包含以下代码。

 def __iter__(self):
        for x in self.iterable:
            yield x

确保你替换了self。Iterablewith迭代所遍历的迭代对象。

下面是一个示例代码

class someClass:
    def __init__(self,list):
        self.list = list
    def __iter__(self):
        for x in self.list:
            yield x


var = someClass([1,2,3,4,5])
for num in var: 
    print(num) 

输出

1
2
3
4
5

注意:由于字符串也是可迭代的，它们也可以用作类的参数

foo = someClass("Python")
for x in foo:
    print(x)

输出

P
y
t
h
o
n

首先，itertools模块在迭代器有用的各种情况下都非常有用，但在python中创建迭代器所需的全部内容如下:

收益率

这不是很酷吗?Yield可以用来代替函数中的正常回报。它返回相同的对象，但不是销毁状态并退出，而是保存状态以供您想要执行下一次迭代时使用。下面是一个直接从itertools函数列表中取出的实例:

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

正如函数描述中所述(它是itertools模块中的count()函数…)，它生成一个迭代器，返回以n开头的连续整数。

生成器表达式是另一罐蠕虫(很棒的蠕虫!)。它们可以用来代替列表推导式来节省内存(列表推导式在内存中创建一个列表，如果不分配给变量，该列表在使用后将被销毁，但是生成器表达式可以创建一个生成器对象…这是Iterator的一种奇特说法)。下面是一个生成器表达式定义的例子:

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

这与上面的迭代器定义非常相似，只是整个范围预定在0到10之间。

我刚刚找到xrange()(很惊讶我以前没有见过它…)，并将其添加到上面的示例中。Xrange()是range()的可迭代版本，它的优点是不预先构建列表。如果你有一个巨大的数据语料库要迭代，但只有这么多内存，这将是非常有用的。

类uc_iter (): def __init__(自我): 自我。值= 0 def __iter__(自我): 回归自我 def __next__(自我): Next_value = self.value 自我。值+= 2 返回next_value

改进之前的回答，使用class的优点之一是你可以添加__call__来返回self。Value或next_value。

class uc_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
    def __call__(self):
        next_value = self.value
        self.value += 2
        return next_value

c = uc_iter()
print([c() for _ in range(10)])
print([next(c) for _ in range(5)])
# [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
# [20, 22, 24, 26, 28]

其他基于Python Random的类的例子可以在我的实现中看到，它既可以被调用，也可以被迭代

python中的迭代器对象遵循迭代器协议，这基本上意味着它们提供了两个方法:__iter__()和__next__()。

__iter__返回迭代器对象，并被隐式调用 在循环开始的时候。 __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)

打印输出将是相同的。在底层，生成器对象支持迭代器协议，并做一些与类Counter大致相似的事情。

David Mertz的文章《迭代器和简单生成器》是一个很好的介绍。

这个问题是关于可迭代对象的，而不是迭代器的。在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)