如何构建一个基本的迭代器?

小开

首先，在迭代器有用的各种情况下，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 ()的一个可迭代版本，它的优点是不预先构建列表。如果你有一个巨大的数据语料库要迭代，但只有这么多内存，这将是非常有用的。

小开

最佳答案

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的文章迭代器和简单生成器是一个很好的介绍。

小开

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

创建一个生成器(使用生成的关键字)
使用生成器表达式(genexp)
创建迭代器(定义#EYZ0和__next__(或Python 2.x中的next))
创建一个Python可以自行迭代的类(定义了# EYZ0)

例子:

# 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

# EYZ0:

两个生成器类型(uc_gen和uc_genexp)不能是reversed();普通迭代器(uc_iter)将需要__reversed__魔法方法(其中，根据文件必须返回一个新的迭代器，但返回self可以(至少在CPython中));和getitem迭代表(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)

为了回答Colonel 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__。

小开

我看到你们中的一些人在__iter__中做return self。我只是想指出__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函数和一个闭包，该闭包将它的状态保存在python 2的封闭范围内的一个可变(list)中。

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

小开

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

小开

本页上的所有答案对于复杂对象来说都非常棒。但是对于那些包含内置可迭代类型作为属性的类型，比如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

小开

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

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

确保将# eyz0替换为迭代遍历的可迭代对象。

下面是一个示例代码

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

小开

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的类的例子，该类既可以被调用，也可以被迭代