如何在Python中创建迭代函数(或迭代器对象)?
python中的迭代器对象符合迭代器协议,这基本上意味着它们提供了两种方法:__iter__()和next()。__iter__返回迭代器对象,并在循环开始时隐式调用。next()方法返回下一个值,并在每个循环增量中隐式调用。当没有更多的值可返回时,next()会引发stopIteration异常,该异常由循环构造隐式捕获以停止迭代。
下面是一个简单的计数器示例:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
| 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 |
这将打印:
如前一个答案所述,使用生成器更容易编写:
1 2 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 |
打印输出将相同。在引擎盖下,生成器对象支持迭代器协议,并执行与类计数器大致相似的操作。
DavidMertz的文章,迭代器和简单的生成器,是一个很好的介绍。
构建迭代函数有四种方法:
- 创建生成器(使用yield关键字)
- 使用生成器表达式(genexp)
- 创建迭代器(在python 2.x中定义__iter__和__next__(或next)
- 创建一个类,python可以自己迭代(定义__getitem__)
实例:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
| # 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 |
要查看所有四种方法的作用:
1 2 3 4
| for iterator in uc_gen, uc_genexp, uc_iter, uc_getitem:
for ch in iterator('abcde'):
print ch,
print |
结果是:
1 2 3 4
| 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__magic方法(必须返回向后的新迭代器);getitem可迭代器(uc_getitem必须有__len__magic方法:
1 2 3 4 5 6 7
| # for uc_iter
def __reversed__(self):
return reversed(self.text)
# for uc_getitem
def __len__(self)
return len(self.text) |
为了回答关于一个无限的延迟评估迭代器的第二个问题,下面是这些例子,使用上述四种方法中的每一种:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39
| # 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 |
结果是(至少对于我的示例运行):
1 2 3 4
| 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 |
首先,ITertools模块对于迭代器可能有用的各种情况都非常有用,但下面是在python中创建迭代器所需的全部内容:
yield
那不酷吗?yield可用于替换函数中的正常返回。它返回的对象是相同的,但它不会破坏状态并退出,而是在您想要执行下一个迭代时保存状态。下面是一个直接从ITertools函数列表中提取的实际IT示例:
1 2 3 4
| def count(n=0):
while True:
yield n
n += 1 |
如函数描述中所述(它是itertools模块中的count()函数…),它生成一个迭代器,返回以n开头的连续整数。
生成器表达式是一整罐其他蠕虫(可怕的蠕虫!)。它们可以用来代替列表理解来保存内存(列表理解在内存中创建一个列表,如果未分配给变量,则在使用后将其销毁,但生成器表达式可以创建生成器对象…这是一种奇特的迭代器的表达方式)。以下是生成器表达式定义的示例:
1
| gen = (n for n in xrange(0,11)) |
这与上面的迭代器定义非常相似,只是整个范围预先确定为0到10之间。
我刚找到xrange()(很惊讶我以前没见过它…)并将其添加到上面的示例中。xrange()是range()的一个可迭代版本,它具有不预先构建列表的优点。如果您有一个巨大的数据集进行迭代,并且只有那么多的内存来进行迭代,那么这将非常有用。
我看到你们中的一些人在__iter__里做return self。我只是想指出,__iter__本身可以是一个发电机(这样就不需要__next__和提高StopIteration的例外)。
1 2 3 4 5 6 7 8 9
| 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 |
当然,这里我们也可以直接生成一个生成器,但是对于更复杂的类来说,它是有用的。
这个问题是关于可Iterable对象的,而不是关于迭代器的。在python中,序列也是可重写的,因此使一个可重写类的一种方法是使它表现得像一个序列,即给它提供__getitem__和__len__方法。我在python 2和3上测试过这个。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
| 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) |
这个页面上的所有答案对于一个复杂的对象都非常有用。但是对于那些包含内置的可Itable类型作为属性的类型,如str、list、set或dict或collections.Iterable的任何实现,您可以省略类中的某些内容。
1 2 3 4 5 6 7
| 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) |
它的用途如下:
1 2 3 4 5 6 7 8 9
| for x in Test("abcde"):
print(x)
# prints
# a
# b
# c
# d
# e |
这是一个不带yield的不可迭代函数。它利用了iter函数和一个闭包,使其状态在python 2的封闭范围内保持可变(list状态。
1 2 3 4 5 6 7 8 9
| 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更新状态变量。
1 2 3 4 5 6 7 8 9 10
| 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) |
试验;
1 2 3 4 5 6 7 8 9 10 11
| for i in count(1,10):
print(i)
1
2
3
4
5
6
7
8
9 |
如果你想找一些简短的东西,也许对你来说就足够了:
1 2 3 4 5 6
| class A(object):
def __init__(self, l):
self.data = l
def __iter__(self):
return iter(self.data) |
使用示例:
1 2 3 4
| In [3]: a = A([2,3,4])
In [4]: [i for i in a]
Out[4]: [2, 3, 4] |
受Matt Gregory答案的启发,这里有一个更复杂的迭代器,它将返回a,b,…,z,a a,a b,…,z z,a a a,a a b,…,zzy,z z z
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37
| 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) |