一、迭代器(itertor)
1.可迭代:
在Python中如果一个对象有__iter__()方法或__getitem__()方法,则称这个对象是可迭代的(iterable)。
其中__iter__()方法的作用是让对象可以用“for ... in...”方式来循环遍历,__getitem__()方法是让对象可以通过“实例名[index]”的方式访问实例中的元素。换句话说,两个条件只要满足一条,就可以说对象是可迭代的。
python中的可迭代对象有:
(1)序列:字符串、列表、元组
(2)非序列:字典、文件
(3)自定义类:用户自定义的类实现了__iter__()或__getitem__()方法的对象
2.迭代器:
在Python中如果一个对象有__iter__()方法和__next__()方法,则称这个对象是迭代器(Iterator);其中__iter__()方法是让对象可以用for ... in ...循环遍历,__next__()方法是让对象可以通过next(实例名)访问下一个元素。这两个方法必须同时具备,才能称之为迭代器。
列表List、元组Tuple、字典Dictionary、字符串String等数据类型虽然是可迭代的,但都不是迭代器,因为他们都没有__next__()方法。
from collections import Iterable,Iterator
# 字符串、列表、元组、集合、字典都是可迭代对象
print(isinstance('123',Iterable)) # True
print(isinstance([1,2,3],Iterable)) # True
print(isinstance((1,2,3),Iterable)) # True
print(isinstance({1,2,3},Iterable)) # True
print(isinstance({"one":1,"two":2,"three":3},Iterable)) # True
# 字符串、列表、元组、集合、字典都不是迭代器
print(isinstance('123',Iterator)) # False
print(isinstance([1,2,3],Iterator)) # False
print(isinstance((1,2,3),Iterator)) # False
print(isinstance({1,2,3},Iterator)) # False
print(isinstance({"one":1,"two":2,"three":3},Iterator)) # False
3.总结:
- 迭代器都是可迭代的,但可迭代的不一定是迭代器;可用for ... in ...循环的都是可迭代的,可用next()遍历的才是迭代器;
- next()是单向的,一次只获取一个元素,获取到最后一个元素后停止;
- 在可迭代的对象中提前存储了所有的元素,而迭代器是惰性的,只有迭代到了某个元素,该元素才会生成。
4.延迟计算或惰性求值 (Lazy evaluation)
迭代器不要求你事先准备好整个迭代过程中所有的元素。仅仅是在迭代至某个元素时才计算该元素,而在这之前或之后,元素可以不存在或者被销毁。这个特点使得它特别适合用于遍历一些巨大的或是无限的集合。
迭代之前元素可以是不存在的,迭代之后元素也可以被销毁,因此迭代器在处理大量数据甚至无限数据时具有加载数据快、占用内存小等优势。
5.创建迭代器:
(1)使用内建的工厂函数iter(iterable[, sentinel])
iter()函数只传入一个参数时,参数必须为可迭代对象;当使用第二个参数sentinel(哨兵)时,第一个参数必须是一个可调用对象。
当有第二个参数sentinel传入时,参数iterable应是一个可调用对象,这时候迭代器它会重复地调用第一个参数,当枚举到的值等于哨兵时,就会抛出异常StopIteration。
s = "abcdefgh"
iter1 = iter(s)
print(isinstance(iter1,Iterator)) # True
使用第二个参数的情况此处不描述了
(2)自己写类,其中实现__iter__()方法和__next__()方法
在__next__()方法中必须对迭代进行检查,超出范围则触发 StopIteration 异常。注意避免死循环。
class MyIterator(object):
def __init__(self, data):
self.data = data
def __iter__(self):
return self
def __next__(self):
if self.data <= 20:
self.data += 2
return self.data
else:
raise StopIteration
myIter = MyIterator(5)
print(isinstance(myIter,Iterator)) # True
print(next(myIter)) # 7
print(next(myIter)) # 9
print(next(myIter)) # 11
...
二、生成器(generator)
在Python中,不会一次性的生成所有的值,而是调用一次,生成一个值,再调用一次,生成下一个值。
即生成器不会把结果保存在一个系列中,而是保存生成器的状态,在每次进行迭代时返回一个值,直到遇到StopIteration异常时结束。
创建生成器的两种基本方法
1.生成器表达式:
通列表解析语法,在写列表生成式时,把[]换成()即可
实例:
# 列表生成式
>>> l = [i for i in range(5)]
>>> l
[0, 1, 2, 3, 4]
# 生成器表达式
>>> g = (i for i in range(5))
>>> g
<generator object <genexpr> at 0x000001A5108D5938>
>>> next(g)
0
>>> next(g)
1
>>> next(g)
2
2.生成器函数
在 Python 中,使用了(一个或多个)yield语句的函数,就叫做生成器函数。
解释器处理这种函数定义的时候将创建特殊的生成器函数对象,而不是普通的函数对象。调用生成器函数的时候,返回值就是一个生成器对象。它只能用于迭代操作,更简单点理解生成器就是一种迭代器。
在调用生成器运行的过程中,每次遇到 yield 时函数会暂停并保存当前所有的运行信息,返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。
实例:
# 实现的斐波那契数列
def fib_gen(n):
f0, f1 = 0, 1
for n in range(n):
yield f0
f0, f1 = f1, f0+f1
print(fib_gen(5)) # <generator object fib_gen at 0x0000023A5BB78830>
g = fib_gen(6) # g就是一个生成器对象(也是一种迭代器)
print(next(g)) # 0
print(next(g)) # 1
print(next(g)) # 1
print(next(g)) # 2
# 生成器是包含有__iter__()和__next__()方法的,所以可以直接使用for来迭代
for x in fib_gen(5):
print(x, end=', ')
# 0, 1, 1, 2, 3,
2.1.yield 与 return
在一个生成器中,如果没有return,则默认执行到函数完毕时返回StopIteration异常。
>>> def gen():
... for i in range(2)
... yield 1
...
>>> g=gen()
>>> next(g) #第一次调用next(g)时,会在执行完yield语句后挂起,此时程序并没有执行结束。
0
>>> next(g) #第二次调用next(g),同样会在执行完yield语句后挂起,此时程序并没有执行结束。
1
>>> next(g) #程序试图从yield语句的下一条语句开始执行,发现已经到了结尾,所以抛出StopIteration异常。
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration
>>>
生成器函数有return,如果return语句没有返回值,则直接抛出StopIteration异常。如果return语句有返回值,那么这个返回值会成为抛出StopIteration异常的一个说明。
>>> def ff():
... for i in range(2):
... yield i
... return 'i finished.'
...
>>> g = ff()
>>> next(g)
0
>>> next(g)
1
>>> next(g)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration: i finished.
2.2.yield from语法
yield from 是在Python3.3才出现的语法。所以这个特性在Python2中是没有的。
yield from 后面需要加的是可迭代对象,它可以是普通的可迭代对象,也可以是迭代器,甚至是生成器。
yield from 主要用于生成器的嵌套,重点是帮我们自动处理内外层之间的异常问题。
这种用法参考博客:深入理解yield from语法
3.生成器支持的方法
① generator.send(expr)
启动新生成器或唤醒处于挂起状态的生成器,把参数expr的值传送给它,使之成为当时挂起的那个yield表达式的值。
本操作导致generator继续执行到下一个yield表达式(或者语句),返回yield值。对新生成器调用send时参数只能是None,因为当时不存在等待值的yield表达式。
def gen():
value=0
while True:
receive=yield value
if receive=='e':
break
value = 'i got: %s' % receive
g=gen()
print(g.send(None)) # 这里用next(g)也是一样
print(g.send('aaa'))
print(g.send(3))
print(g.send('e'))
执行流程:
通过g.send(None)或者next(g)可以启动生成器函数,并执行到第一个yield语句结束的位置,yield value会输出初始值0。此时,执行完了yield语句,但是没有给receive赋值,因为执行完yield程序就处于挂起状态了,还没有来得急给receive赋值。
通过g.send('aaa'),会传入值aaa作为yield表达式的值,然后继续执行程序,此时把yield表达式的值赋值给receive,然后计算出value的值,并回到while头部,执行yield value语句又暂停。此时yield value会输出"got: aaa",然后挂起。
通过g.send(3),会重复第2步,最后输出结果为"got: 3"
当我们g.send('e')时,程序会执行break然后推出循环,最后整个函数执行完毕,所以会得到StopIteration异常。
最后的执行结果如下:
0
i got: aaa
File "生成器.py", line 104, in <module>
i got: 3
print(g.send('e'))
StopIteration
② :generator.close()
手动关闭生成器函数,如果继续调用next()获取下一个值会直接抛出StopIteration异常。
def gen():
value=0
while True:
receive=yield value
if receive=='e':
break
value = 'i got: %s' % receive
g=gen()
print(next(g))
g.close()
print(next(g)) # 继续调用抛出StopIteration异常
③ :generator.throw(type[,value[,traceback]])
启动新生成器或唤醒处于挂起状态的生成器,在当时挂起的yield表达式(语句)处抛出type类型的异常,该异常可以附带value作为参数说明,还可以有相应的traceback对象。
这个调用也返回generator生成器的下一个值,如果此时生成器退出或没有产生yield值,会抛出StopIteration异常。简单说,会抛出异常并结束程序,或者消耗掉一个yield值,或者在没有下一个yield的时候直接进行到程序的结尾。
def gen():
while True:
try:
yield 'normal value1'
yield 'normal value 2'
print('here')
except ValueError:
print('ValueError : ...... ')
except TypeError as e:
print('TypeError : ',e)
break
g=gen()
print(next(g))
print(g.throw(ValueError))
print(next(g))
print(g.throw(TypeError,'i raised a TypeError'))
执行结果:
normal value1
Traceback (most recent call last):
ValueError : ......
normal value1
File "生成器.py", line 121, in <module>
normal value 2
print(g.throw(TypeError,'i raised a TypeError'))
TypeError : i raised a TypeError
StopIteration