python yield,yield from,深浅拷贝

(一)yield和yield from

转自:理解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的好处是其做了很多全面的异常处理,使得调用端可以直接使用而不用自己实现多种异常的处理。

 

(二)深浅拷贝

转自 Python拷贝    深浅拷贝

 

(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)

深拷贝就是数据完完全全独立拷贝出来一份,包含对象里面的自对象的拷贝,所以原始对象的改变不会造成深拷贝里任何子元素的改变

 

posted @ 2019-04-05 11:01  ccxikka  Views(630)  Comments(0Edit  收藏  举报