python

关注公众号 jb51net

关闭
首页 > 脚本专栏 > python > python迭代器,生成器

python迭代器,生成器详解

作者:网民余某人

这篇文章主要介绍了Python中的迭代器和生成器,涉及到Python中很多重要的特性,小编觉得这篇文章写的还不错,需要的朋友可以参考下

迭代器

聊迭代器前我们要先清楚迭代的概念:通常来讲从一个对象中依次取出数据,这个过程叫做遍历,这个手段称为迭代(重复执行某一段代码块,并将每一次迭代得到的结果作为下一次迭代的初始值)。

from collections.abc import Iterable
a: int = 1
print(isinstance(a, Iterable))  # False
b: str = "lalalalala" 
print(isinstance(b, Iterable))  # True
c: set = set([1, 2])
print(isinstance(c, Iterable))  # True

我们也可以自己实现__iter__来将一个类实例对象变为可迭代对象:

class MyIterable:
	def __iter__(self):
		pass

print(isinstance(MyIterable(), Iterable)) # True
from collections.abc import Iterator, Iterable
class 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):
		pass

myIterator = 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))  # 1
print(next(myIterator))  # 2
print(next(myIterator))  # 3
print(next(myIterator))  # 4
print(next(myIterator))  # raise StopIteration

迭代器优缺点:

 - 优点:迭代器对象表示的是一个数据流,可以在需要时才去调用next来获取一个值;因而本身在内存中始终只保留一个值,对于内存占用小可以存放无限数据流。优于其他容器需要一次将所有元素都存放进内存,如:列表、集合、字典...等
 - 缺点:1.无法获取存放的元素长度,除非取完计数。2.只能向后取值,next()永远返回的是下一个值。取值不灵活,无法取出指定值(无法像字典的key,或列表的下标),而且迭代器的生命周期是一次性的元素被迭代完则生命周期结束

生成器

义:在Python中,一边循环一边计算的机制,称为生成器:generator;同时生成器对象也是迭代器对象,所以他有迭代器的特性;例如支持for循环、next()方法…等

作用:对象中的元素是按照某种算法推算出来的,在循环的过程中不断推算出后续的元素,这样就不必创建完整的list,从而节省大量的空间。

# 列表生成式
_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__())  # 0
print(next(_generator)) # 1
# 注意从第三个元素开始了!
for x in _generator:
	print(x)  # 2,3,4,5,6,7,8,9

因为生成器对象也有迭代器的特性,所以元素迭代完后继续调用next()方法则会引发StopIteration。

def gen_generator():
	yield 1

def generator():
	return 1

print(gen_generator(), type(gen_generator()))  
# <generator object gen_generator at 0x7fe68b2c8b30> <class 'generator'>
print(generator(), type(generator()))  
# 1 <class 'int'>

他与普通函数返回值有所不同,普通函数运行到return语句则直接返回代码不再执行;而生成器对象会运行到yield后返回,再下次调用时从yield语句后继续执行。如:

在这里插入图片描述

注意:yield 一次只会返回一个元素,即使返回的元素是个可迭代对象,也是一次性返回

def gen_generator2():
	yield [1, 2, 3]

s = gen_generator2()
print(next(s))  # [1, 2, 3]

在这里插入图片描述

借助send我们可以实现一个简单的生产者-消费者模式如:

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()  # 关闭生成器
			break

consume = 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]
# 消费者返回服务异常,则结束生产,并关闭消费者
def my_generator(n, end_case):
	for i in range(n):
		if i == end_case:
			return f'当 i==`{i}`时,中断程序。'
		else:
			yield i

g = my_generator(5, 2)  # 调用
for _i in g:  # for循环不会显式触发异常,故而无法获取到return的值
	print(_i)
# 输出:
# 0
# 1

从上面的例子可以看出,for迭代语句不会显式触发异常,故而无法获取到return的值,迭代到2的时候遇到return语句,隐式的触发了StopIteration异常,就终止迭代了,但是在程序中不会显示出来。

可以通过next()显示的触发StopIteration异常来获取返回值:

def my_generator2(n, end_case):
	for i in range(n):
		if i == end_case:
			return f'当 i==`{i}`时,中断程序。'
		else:
			yield i

g = 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 可以简化成:

def my_generator3(n, end_case):
	for i in range(n):
		if i == end_case:
			return f'当 i==`{i}`时,中断程序。'
		else:
			yield i

def wrap_my_generator(generator):  # 将my_generator的返回值包装成一个生成器
	result = yield from generator
	yield result

g = 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

调用方是通过这个 “包装函数” 来与生成器进行交互的,即“调用方——>委托生成器——>生成器函数”
下面有个例子帮助大家理解

# 子生成器
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

在这里插入图片描述

有兴趣的同学可以结合图和下方一起理解:

总结

本篇文章就到这里了,希望能够给你带来帮助,也希望您能够多多关注脚本之家的更多内容!

您可能感兴趣的文章:
阅读全文