如何在python中创建迭代函数（或迭代器对象）？
答案 0 :(得分：599)
python中的迭代器对象符合迭代器协议，这基本上意味着它们提供了两种方法：__iter__()和next()。 __iter__返回迭代器对象，并在循环开始时隐式调用。 next()方法返回下一个值，并在每个循环增量处隐式调用。当没有更多值要返回时，next()会引发一个StopIteration异常，这是通过循环结构隐式捕获的，以便停止迭代。
这是一个简单的计数器示例：
class Counter:
def __init__(self, low, high):
self.current = low
self.high = high
def __iter__(self):
return self
def next(self): # Python 3: def __next__(self)
if self.current > self.high:
raise StopIteration
else:
self.current += 1
return self.current - 1
for c in Counter(3, 8):
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, 8):
print c
打印输出将是相同的。在引擎盖下，生成器对象支持迭代器协议，并且执行与类Counter类似的操作。
David Mertz的文章Iterators and Simple Generators是一个非常好的介绍。
答案 1 :(得分：379)
有四种方法可以构建迭代函数：
__iter__ and __next__（或next））__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 iteratable（uc_getitem）必须具有__len__魔术方法：
# for uc_iter
def __reversed__(self):
return reversed(self.text)
# 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
答案 2 :(得分：100)
首先，itertools module对于迭代器很有用的各种情况非常有用，但是这里只需要在python中创建一个迭代器：
产量
不是很酷吗？收益率可用于替换函数中的正常返回。它返回的对象是相同的，但它不是破坏状态和退出，而是为你想要执行下一次迭代时保存状态。以下是直接从itertools function list：
提取的实际操作示例def count(n=0):
while True:
yield n
n += 1
如函数说明中所述（它是来自itertools模块的 count（）函数...），它会生成一个迭代器，它返回以n开头的连续整数。
Generator expressions是另一种蠕虫（真棒蠕虫！）。可以使用它们代替List Comprehension来节省内存（列表推导在内存中创建一个列表，如果没有分配给变量，在使用后会被销毁，但生成器表达式可以创建一个生成器对象...这是一个说Iterator的奇特方式）。以下是生成器表达式定义的示例：
gen = (n for n in xrange(0,11))
这与上面的迭代器定义非常相似，只是整个范围预定在0到10之间。
我刚发现 xrange（）（我以前没见过它感到很惊讶......）并将其添加到上面的示例中。 xrange（）是 range（）的可迭代版本，其优点是不预先构建列表。如果你有一个巨大的数据集来迭代并且只有这么多的内存来完成它，那将非常有用。
答案 3 :(得分：98)
我看到你们中的一些人在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 :(得分：11)
这个问题是关于可迭代的对象，而不是迭代器。在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)
答案 5 :(得分：3)
这是一个没有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
答案 6 :(得分：3)
此页面上的所有答案对于复杂的对象确实非常有用。但是对于那些包含内置可迭代类型作为属性的属性，例如<p-panelMenu [model]="menuItems" [multiple]="false"></p-panelMenu>，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)
答案 7 :(得分：2)
如果你寻找简短的东西，也许对你来说就足够了：
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]
答案 8 :(得分：0)
受Matt Gregory的回答启发，这里有一个更为复杂的迭代器，它将返回a，b，...，z，aa，ab，...，zz，aaa，aab，...，zzy，zzz < / p>
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)
答案 9 :(得分：-1)
在您的班级代码中包含以下代码。
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)
输出
1
2
3
4
5
注意：由于字符串也是可迭代的，因此它们也可用作类的参数
foo = someClass("Python")
for x in foo:
print(x)
输出
P
y
t
h
o
n