题
如何在 python 中创建迭代函数(或迭代器对象)?
解决方案
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 类大致相似的操作。
大卫·默茨的文章, 迭代器和简单生成器, ,是一个很好的介绍。
其他提示
构建迭代函数有四种方法:
- 创建一个生成器(使用 产量关键字)
- 使用生成器表达式 (基因实验)
- 创建一个迭代器(定义
__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)
为了回答 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
首先 迭代工具模块 对于迭代器有用的各种情况都非常有用,但这里是在 python 中创建迭代器所需的全部内容:
屈服
那不是很酷吗?Yield 可以用来代替普通的 返回 在一个函数中。它返回相同的对象,但不是销毁状态并退出,而是保存状态以供您想要执行下一次迭代时使用。这是直接从 itertools函数列表:
def count(n=0):
while True:
yield n
n += 1
如功能描述中所述(这是 数数() itertools 模块中的函数...) ,它生成一个迭代器,返回以 n 开头的连续整数。
生成器表达式 是完全不同的蠕虫罐头(很棒的蠕虫!)。它们可以用来代替 列表理解 节省内存(列表推导式在内存中创建一个列表,如果未分配给变量,则该列表在使用后会被销毁,但生成器表达式可以创建一个生成器对象...这是迭代器的一种奇特说法)。以下是生成器表达式定义的示例:
gen = (n for n in xrange(0,11))
这与上面的迭代器定义非常相似,除了完整范围预先确定为 0 到 10 之间。
我刚刚发现 xrange() (很惊讶我以前没有见过它......)并将其添加到上面的示例中。 xrange() 是一个可迭代版本 范围() 其优点是不预先构建列表。如果您有一个巨大的数据集需要迭代,并且只有这么多的内存来进行迭代,那么这将非常有用。
我看到你们中的一些人在做 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
当然,这里也可以直接创建一个生成器,但对于更复杂的类,它可能很有用。
这个问题是关于可迭代对象的,而不是关于迭代器的。在 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)
这是一个可迭代函数,无需 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
本页上的所有答案对于复杂的对象来说都非常有用。但对于那些包含内置可迭代类型作为属性的,例如 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
如果您正在寻找简短的内容,也许这对您来说就足够了:
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]
受马特格雷戈里的答案启发,这里是一个更复杂的迭代器,它将返回 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)