迭代器
聊迭代器前我们要先清楚迭代的概念：通常来讲从一个对象中依次取出数据，这个过程叫做遍历，这个手段称为迭代(重复执行某一段代码块，并将每一次迭代得到的结果作为下一次迭代的初始值)。
-
可迭代对象(iterable)：是指该对象可以被用于for…in…循环，例如：集合，列表，元祖，字典，字符串，迭代器等。
- 在python中如果一个对象实现了 __iter__方法，我们就称之为可迭代对象，可以查看set\list\tuple…等源码内部均实现了__iter__方法
- 如果一个对象未实现__iter__方法，但是对其使用for…in则会抛出TypeError: ‘xxx' object is not iterable
- 可以通过isinstance(obj,Iterable)来判断对象是否为可迭代对象。如：
|
1
2
3
4
5
6
7
|
from collections.abc import Iterablea: int = 1print(isinstance(a, Iterable)) # Falseb: str = "lalalalala"print(isinstance(b, Iterable)) # Truec: set = set([1, 2])print(isinstance(c, Iterable)) # True |
我们也可以自己实现__iter__来将一个类实例对象变为可迭代对象：
|
1
2
3
4
5
|
class MyIterable: def __iter__(self): passprint(isinstance(MyIterable(), Iterable)) # True |
-
迭代器：对可迭代对象进行迭代的方式或容器，并且需要记录当前迭代进行到的位置。
- 在python中如果一个对象同时实现了__iter__和__next__(获取下一个值)方法，那么它就是一个迭代器对象。
- 可以通过内置函数next(iterator)，来获取当前迭代的值
- 迭代器一定是可迭代对象，可迭代对象不一定是迭代器。
- 如果可迭代对象遍历完后继续调用next()，则会抛出：StopIteration异常。
- 自己实现一个迭代器对象：
|
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
|
from collections.abc import Iterator, Iterableclass MyIterator: def __init__(self, array_list): self.array_list = array_list self.index = 0 def __iter__(self): return self def __next__(self): if self.index < len(self.array_list): val = self.array_list[self.index] self.index += 1 return val else: raise StopIteration# 父类如果是迭代器，子类也将是迭代器class MySubIterator(MyIterator): def __init__(self): passmyIterator = MyIterator([1, 2, 3, 4])# 判断是否为可迭代对象print(isinstance(myIterator, Iterable)) # True# 判断是否为迭代器print(isinstance(myIterator, Iterator)) # True# 子类实例化mySubIterator = MySubIterator()print(isinstance(mySubIterator, Iterator)) # True# 进行迭代print(next(myIterator)) # 1print(next(myIterator)) # 2print(next(myIterator)) # 3print(next(myIterator)) # 4print(next(myIterator)) # raise StopIteration |
迭代器优缺点：
|
1
2
|
- 优点：迭代器对象表示的是一个数据流，可以在需要时才去调用next来获取一个值；因而本身在内存中始终只保留一个值，对于内存占用小可以存放无限数据流。优于其他容器需要一次将所有元素都存放进内存，如：列表、集合、字典...等- 缺点：1.无法获取存放的元素长度，除非取完计数。2.只能向后取值，next()永远返回的是下一个值。取值不灵活，无法取出指定值(无法像字典的key,或列表的下标)，而且迭代器的生命周期是一次性的元素被迭代完则生命周期结束 |
生成器
义：在Python中，一边循环一边计算的机制，称为生成器：generator；同时生成器对象也是迭代器对象，所以他有迭代器的特性；例如支持for循环、next()方法…等
作用：对象中的元素是按照某种算法推算出来的，在循环的过程中不断推算出后续的元素，这样就不必创建完整的list，从而节省大量的空间。
- 简单生成器：通过将列表生成式[]改成()即可得到一个生成器对象
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
# 列表生成式_list = [i for i in range(10)]print(type(_list)) # <class 'list'>print(_list) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]# 生成器_generator = (i for i in range(10))print(type(_generator)) # <class 'generator'>print(_generator) # <generator object <genexpr> at 0x7fbcd92c9ba0># 生成器对象取值print(_generator.__next__()) # 0print(next(_generator)) # 1# 注意从第三个元素开始了！for x in _generator: print(x) # 2，3，4，5，6，7，8，9 |
因为生成器对象也有迭代器的特性，所以元素迭代完后继续调用next()方法则会引发StopIteration。
- 函数对象生成器：带yield语句的函数对象的返回值则是个生成器对象。
|
1
2
3
4
5
6
7
8
9
10
|
def gen_generator(): yield 1def generator(): return 1print(gen_generator(), type(gen_generator())) # <generator object gen_generator at 0x7fe68b2c8b30> <class 'generator'>print(generator(), type(generator())) # 1 <class 'int'> |
他与普通函数返回值有所不同，普通函数运行到return语句则直接返回代码不再执行；而生成器对象会运行到yield后返回，再下次调用时从yield语句后继续执行。如：
注意：yield 一次只会返回一个元素，即使返回的元素是个可迭代对象，也是一次性返回
|
1
2
3
4
5
|
def gen_generator2(): yield [1, 2, 3]s = gen_generator2()print(next(s)) # [1, 2, 3] |
- yield生成器高级应用：
- send()方法，传递yield的值
借助send我们可以实现一个简单的生产者-消费者模式如：
|
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
|
def consumer(): r = '' while True: n = yield r if not n: return print(f'[CONSUMER] Consuming get params.. ({n})') if n == 3: r = '500 Error' else: r = '200 OK'def produce(c): c.send(None) # 启动生成器 n = 0 while n < 5: n = n + 1 print(f'[PRODUCER] Producing with params.. ({n})') r = c.send(n) # 一旦n有值，则切换到consumer执行 print(f'[PRODUCER] Consumer return : [{r}]') if not r.startswith('200'): print("消费者返回服务异常，则结束生产，并关闭消费者") c.close() # 关闭生成器 breakconsume = consumer()produce(consume)# [PRODUCER] Producing with params.. (1)# [CONSUMER] Consuming get params.. (1)# [PRODUCER] Consumer return : [200 OK]# [PRODUCER] Producing with params.. (2)# [CONSUMER] Consuming get params.. (2)# [PRODUCER] Consumer return : [200 OK]# [PRODUCER] Producing with params.. (3)# [CONSUMER] Consuming get params.. (3)# [PRODUCER] Consumer return : [500 Error]# 消费者返回服务异常，则结束生产，并关闭消费者 |
- yield from iterable 语法，基本作用为：返回一个生成器对象，提供一个“数据传输的管道”，yield from iterable 是 for item in iterable: yield item的缩写；并且内部帮我们实现了很多异常处理，简化了编码复杂度。
- yield 无法获取生成器return的返回值：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
def my_generator(n, end_case): for i in range(n): if i == end_case: return f'当 i==`{i}`时，中断程序。' else: yield ig = my_generator(5, 2) # 调用for _i in g: # for循环不会显式触发异常，故而无法获取到return的值 print(_i)# 输出：# 0# 1 |
从上面的例子可以看出，for迭代语句不会显式触发异常，故而无法获取到return的值，迭代到2的时候遇到return语句，隐式的触发了StopIteration异常，就终止迭代了，但是在程序中不会显示出来。
可以通过next()显示的触发StopIteration异常来获取返回值:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
def my_generator2(n, end_case): for i in range(n): if i == end_case: return f'当 i==`{i}`时，中断程序。' else: yield ig = my_generator2(5, 2) # 调用try: print(next(g)) # 0 print(next(g)) # 1 print(next(g)) # 此处要触发end_case了except StopIteration as exc: print(exc.value) # 当 i==`2`时，中断程序。 |
使用yield from 可以简化成：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
def my_generator3(n, end_case): for i in range(n): if i == end_case: return f'当 i==`{i}`时，中断程序。' else: yield idef wrap_my_generator(generator): # 将my_generator的返回值包装成一个生成器 result = yield from generator yield resultg = my_generator3(5, 2) # 调用for _ in wrap_my_generator(g): print(_)# 输出：# 0# 1# 当 i==`2`时，中断程序。 |
yield from 有以下几个概念名词：
1、调用方：调用委派生成器的客户端（调用方）代码（上文中的wrap_my_generator(g)）
2、委托生成器：包含yield from表达式的生成器函数(包装)，作用就是提供一个数据传输的管道（上文中的wrap_my_generator）
3、子生成器：yield from后面加的生成器函数（上文中的my_generator）
调用方是通过这个 “包装函数” 来与生成器进行交互的，即“调用方——>委托生成器——>生成器函数”
下面有个例子帮助大家理解
|
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
|
# 子生成器def average_gen(): total = 0 count = 0 average = 0 while True: new_num = yield average if new_num is None: break count += 1 total += new_num average = total / count # 每一次return，都意味着当前协程结束。 return total, count, average# 委托生成器def proxy_gen(): while True: # 只有子生成器要结束（return）了，yield from左边的变量才会被赋值，后面的代码才会执行。 total, count, average = yield from average_gen() print("总共传入 {} 个数值， 总和：{}，平均数：{}".format(count, total, average))# 调用方def main(): calc_average = proxy_gen() next(calc_average) # 激活协程 calc_average.send(10) # 传入：10 calc_average.send(None) # 结束协程 print("================== 重开协程 ===================") calc_average.send(20) # 传入：20 calc_average.send(30) # 传入：30 calc_average.send(None) # 结束协程if __name__ == '__main__': main()# 输出：# 总共传入 1 个数值， 总和：10，平均数：10.0# ================== 重开协程 ===================# 总共传入 2 个数值， 总和：50，平均数：25.0 |
有兴趣的同学可以结合图和下方一起理解：
- 迭代器（即可指子生成器）产生的值直接返还给调用者
- 任何使用send()方法发给委派生产器（即外部生产器）的值被直接传递给迭代器。如果send值是None，则调用迭代器next()方法；如果不为None，则调用迭代器的send()方法。如果对迭代器的调用产生StopIteration异常，委派生产器恢复继续执行yield from后面的语句；若迭代器产生其他任何异常，则都传递给委派生产器。
- 子生成器可能只是一个迭代器，并不是一个作为协程的生成器，所以它不支持.throw()和.close()方法,即可能会产生AttributeError 异常。
- 除了GeneratorExit 异常外的其他抛给委派生产器的异常，将会被传递到迭代器的throw()方法。如果迭代器throw()调用产生了StopIteration异常，委派生产器恢复并继续执行，其他异常则传递给委派生产器。
- 如果GeneratorExit异常被抛给委派生产器，或者委派生产器的close()方法被调用，如果迭代器有close()的话也将被调用。如果close()调用产生异常，异常将传递给委派生产器。否则，委派生产器将抛出GeneratorExit 异常。
- 当迭代器结束并抛出异常时，yield from表达式的值是其StopIteration 异常中的第一个参数。
- 一个生成器中的return expr语句将会从生成器退出并抛出 StopIteration(expr)异常。
总结
本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注服务器之家的更多内容！
原文链接：https://blog.csdn.net/weixin_45005677/article/details/120707139
