(一)yield和yield from
(1)yield
1、通常的for…in…循环中,in后面是一个数组,这个数组就是一个可迭代对象,类似的还有链表,字符串,文件。它可以是mylist = [1, 2, 3],也可以是mylist = [x*x for x in range(3)]。 它的缺陷是所有数据都在内存中,如果有海量数据的话将会非常耗内存。
2、对比可迭代对象,迭代器其实就只是多了一个函数:__next__(),可以不再使用for循环来间断获取元素值,而可以直接使用next()方法来实现,可通过iter(a),将可迭代对象a转换为一个迭代器。
3、生成器是可以迭代的,但只可以读取它一次。因为用的时候才生成。比如 mygenerator = (x*x for x in range(3)),注意这里用到了(),它就不是数组,而上面的例子是[]。可迭代对象和迭代器,是将所有的值都生成存放在内存中,而生成器则是需要元素才临时生成,节省时间,节省空间。
4、带有 yield 的函数不再是一个普通函数,而是一个生成器generator,可用于迭代。yield 是一个类似 return 的关键字,迭代一次遇到yield时就返回yield后面的值。并在这里阻塞,等待下一次的调用。从而实现节省内存,实现异步编程。重点是:下一次迭代时,从上一次迭代遇到的yield后面的代码开始执行。即yield就是 return 返回一个值,并且记住这个返回的位置,下次迭代就从这个位置后开始。
5、生成器并不是一次生成所有元素,而是一次一次的执行返回,激活生成器执行的方法有:使用next(),或者使用generator.send(None)。next()等同于send(None),for循环就用到了next()。
6、带有yield的函数不仅仅只用于for循环中,而且可用于某个函数的参数,只要这个函数的参数允许迭代参数。比如array.extend函数,它的原型是array.extend(iterable)。
7、send(msg)与next()的区别在于send可以传递参数给yield表达式,这时传递的参数会作为yield表达式的值,而yield的参数是返回给调用者的值。换句话说,就是send可以强行修改上一个yield表达式值。比如函数中有一个yield赋值,a = yield 5,第一次迭代到这里会返回5,a还没有赋值。第二次迭代时,使用.send(10),那么,就是强行修改yield 5表达式的值为10,本来是5的,那么a=10。
8、send(msg)与next()都有返回值,它们的返回值是当前迭代遇到yield时,yield后面表达式的值,其实就是当前迭代中yield后面的参数。
9、第一次调用时必须先next()或send(None),否则会报错,send后之所以为None是因为这时候没有上一个yield。可以认为,next()等同于send(None),for循环就用到了next()。
(2)yield from
多线程与协程:使用多线程实现并发时,多线程的运行需要频繁的加锁解锁,切换线程,这极大地降低了并发性能;协程是为非抢占式多任务产生子程序的计算机程序组件,协程允许不同入口点在不同位置暂停或开始执行程序。协程和线程,有相似点,多个协程之间和线程一样,只会交叉串行执行;也有不同点,线程之间要频繁进行切换,加锁解锁,复杂度高且效率低。协程通过使用 yield 暂停生成器,可以将程序的执行流程交给其他的子程序,从而实现不同子程序的之间的交替执行,即程序从yield处暂停,然后可以返回去做别的事。
yield from 后面需要加的是可迭代对象,它可以是普通的可迭代对象,也可以是迭代器,甚至是生成器。
yield from后面加上可迭代对象,可以把可迭代对象里的每个元素一个一个的yield出来,对比yield来说代码更加简洁,结构更加清晰(这种情况下使用yield需要两个循环,而yield from只需要一个循环)。
当 yield from 后面加上一个生成器后,就实现了生成的嵌套。实现生成器的嵌套,并不是一定必须要使用yield from,但使用yield from可以避免自己处理各种料想不到的异常。生成器嵌套的几个概念:
1、调用方:调用委托生成器的客户端(调用方)代码
2、委托生成器:包含yield from表达式的生成器函数
3、子生成器:yield from后面加的生成器函数
这几个概念的示例如下:
# 子生成器 def average_gen(): total = 0 count = 0 average = 0 while True: new_num = yield average count += 1 total += new_num average = total/count # 委托生成器 def proxy_gen(): while True: yield from average_gen() # 调用方 def main(): calc_average = proxy_gen() next(calc_average) # 预激下生成器 print(calc_average.send(10)) # 打印:10.0 print(calc_average.send(20)) # 打印:15.0 print(calc_average.send(30)) # 打印:20.0 if __name__ == ‘__main__‘: main()
委托生成器的作用是:在调用方与子生成器之间建立一个双向通道。即调用方可以通过send()直接发送消息给子生成器,而子生成器yield的值,也是直接返回给调用方。委托生成器只起一个桥梁作用,它建立的是一个双向通道,它并不会对子生成器yield回来的内容做拦截。如下:
# 子生成器 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("计算完毕!!\n总共传入 {} 个数值, 总和:{},平均数:{}".format(count, total, average)) # 调用方 def main(): calc_average = proxy_gen() next(calc_average) # 预激协程 print(calc_average.send(10)) # 打印:10.0 print(calc_average.send(20)) # 打印:15.0 print(calc_average.send(30)) # 打印:20.0 calc_average.send(None) # 结束协程 # 如果此处再调用calc_average.send(10),由于上一协程已经结束,将重开一协程 if __name__ == ‘__main__‘: main() 程序输出: 10.0 15.0 20.0 计算完毕!! 总共传入 3 个数值, 总和:60,平均数:20.0
yield from的好处是其做了很多全面的异常处理,使得调用端可以直接使用而不用自己实现多种异常的处理。
(二)深浅拷贝
(1)=赋值:数据完全共享(=赋值是在内存中指向同一个对象,如果是可变(mutable)类型,比如列表,修改其中一个,另一个必定改变
如果是不可变类型(immutable),比如字符串,修改了其中一个,另一个并不会变)
l2 = l1 ,l1 完全赋值给l2 ,l2的内存地址与l1 相同,即内存完全指向
l1 = [1, 2, 3, [‘aa‘, ‘bb‘]] l2 = l1 l2[0]=‘aaa‘ l2[3][0]=‘bbb‘ print(l1) #[‘aaa‘, 2, 3, [‘bbb‘, ‘bb‘]] print(id(l1)==id(l2)) #True
(2)浅拷贝:数据半共享(复制其数据独立内存存放,但是只拷贝成功第一层)没有拷贝子对象,所以原始数据改变,子对象会改变
l1 = [1,2,3,[11,22,33]] l2 = l1.copy() print(l2) #[1,2,3,[11,22,33]] l2[3][2]=‘aaa‘ print(l1) #[1, 2, 3, [11, 22, ‘aaa‘]] print(l2) #[1, 2, 3, [11, 22, ‘aaa‘]] l1[0]= 0 print(l1) #[0, 2, 3, [11, 22, ‘aaa‘]] print(l2) #[1, 2, 3, [11, 22, ‘aaa‘]] print(id(l1)==id(l2)) #Flase
l2浅拷贝了l1 ,之后l2把其列表中的列表的元素给修改,从结果看出,l1也被修改了。但是仅仅修改l1列表中的第一层元素,却并没有影响l2。
比较一下l2与l1的内存地址:False,说明,l2在内存中已经独立出一部分复制了l1的数据,但是只是浅拷贝,第二层的数据并没有拷贝成功,而是指向了l1中的第二层数据的内存地址,所以共享内存‘相当于‘’等号赋值’‘,所以就会有l2中第二层数据发生变化,l1中第二层数据也发生变化
l2拷贝l1的时候只拷贝了他的第一层,也就是在其他内存中重新创建了l1的第一层数据,但是l2无法拷贝l1的第二层数据,也就是列表中的列表,所以他就只能指向l1中的第二层数据
由此,当修改l1中第二层数据的时候,浅拷贝l1的l2中的第二层数据也随之发生改变
(3)深拷贝:数据完全不共享(复制其数据完完全全放独立的一个内存,完全拷贝,数据不共享)
深拷贝就是完完全全复制了一份,且数据不会互相影响,因为内存不共享。
深拷贝的方法有:导入模块
import copy l1 = [1, 2, 3, [11, 22, 33]] # l2 = copy.copy(l1) 浅拷贝 l2 = copy.deepcopy(l1) print(l1,‘>>>‘,l2) l2[3][0] = 1111 print(l1,">>>",l2)
深拷贝就是数据完完全全独立拷贝出来一份,包含对象里面的自对象的拷贝,所以原始对象的改变不会造成深拷贝里任何子元素的改变
原文地址:https://www.cnblogs.com/ccxikka/p/10658200.html