如何构建一个基本的迭代器？-IT科技

摘要：问题描述：如何在 Python 中创建迭代器？例如，假设我有一个类，其实例在逻辑上“包含”一些值：class Example: def __init__(self, values): self.values = values 我希望能够编写如下代码：e = Example([1, 2,...

问题描述：

如何在 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)

更一般地说，迭代器应该能够控制值的来源，甚至可以动态计算它们（而不是考虑实例的任何特定属性）。

解决方案 1：

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)

这将打印：

使用生成器更容易编写，如前面的答案所述：

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

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

打印的输出将是相同的。在底层，生成器对象支持迭代器协议，并且执行的操作与 Counter 类大致类似。

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

解决方案 2：

构建迭代函数有四种方法：

创建一个生成器（使用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)

为了回答 Panic 上校关于无限惰性求值迭代器的第二个问题，下面是使用上述四种方法的示例：

# 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

如何选择使用哪一个？这主要是个人喜好问题。我最常看到的两种方法是生成器和迭代器协议，以及混合方法（__iter__返回生成器）。

生成器表达式对于替换列表推导很有用（它们是惰性的，因此可以节省资源）。

如果需要与早期的 Python 2.x 版本兼容，请使用__getitem__。

解决方案 3：

我看到你们中的一些人在做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

当然，这里也可以直接制作一个生成器，但对于更复杂的类来说，它会很有用。

解决方案 4：

首先，itertools 模块在所有需要使用迭代器的情况中都非常有用，但是以下是在 Python 中创建迭代器所需的全部内容：

屈服

是不是很酷？Yield 可用于替换函数中的正常返回。它同样返回对象，但不会破坏状态并退出，而是保存状态以备下次迭代时使用。以下是直接从itertools 函数列表中获取的示例：

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

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

生成器表达式是另一种麻烦（真麻烦！）。它们可以代替列表推导来节省内存（列表推导在内存中创建一个列表，如果未分配给变量，则在使用后会被销毁，但生成器表达式可以创建一个生成器对象……这是一种迭代器的说法）。以下是生成器表达式定义的示例：

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

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

我刚刚找到了xrange()（很惊讶我之前没见过它......）并将其添加到上面的示例中。xrange ()是range()的可迭代版本，其优点是无需预先构建列表。如果您有大量数据需要迭代，但只有有限的内存来执行此操作，那么它将非常有用。

解决方案 5：

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

解决方案 6：

如果你正在寻找一些简短而简单的东西，也许它就足够了：

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]

解决方案 7：

在你的课程代码中包含以下代码。

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

确保self.iterable用你迭代的可迭代对象进行替换。

以下是示例代码

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)

输出

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

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

输出

P
y
t
h
o
n

解决方案 8：

本页上的所有答案对于复杂对象来说都非常棒。但对于那些包含内置可迭代类型作为属性的对象，例如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 self.string)
        # or simply
        return self.string.__iter__()
        # also
        return iter(self.string)

它的用法如下：

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

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

解决方案 9：

这是一个不带的可迭代函数yield。它利用iter函数和闭包，将其状态保存在listPython 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

解决方案 10：

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

改进以前的答案，使用的优点之一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 的类的其他示例，它可以被调用和迭代