生成器、迭代器、闭包与装饰器
生成器
创建生成器方法一
要创建⼀个⽣成器，有很多种⽅法。第⼀种⽅法很简单，只要把⼀个列表⽣成式的 [ ] 改成 ( )
1In [1]: L = [x*2 for x in range(5)]
2
3In [2]: L
4Out[2]: [0, 2, 4, 6, 8]
5
6In [3]: G = (x*2 for x in range(5))
7
8In [4]: G
9Out[4]: <generator object <genexpr> at 0x000001B281507A98>
创建 L 和 G 的区别仅在于最外层的 [ ] 和 ( ) ， L 是列表，G 是生成器。我们可以直接打印出L的每个元素，但我们怎么打印出G的每个元素呢？使用next函数
1In [3]: G = (x*2 for x in range(5))
2
3In [4]: G
4Out[4]: <generator object <genexpr> at 0x000001B281507A98>
5
6In [5]: next(G)
7Out[5]: 0
8
9In [6]: next(G)
10Out[6]: 2
11
12In [7]: next(G)
13Out[7]: 4
14
15In [8]: next(G)
16Out[8]: 6
17
18In [9]: next(G)
19Out[9]: 8
20
21In [10]: next(G)
22---------------------------------------------------------------------------
23StopIteration Traceback (most recent call last)
24<ipython-input-10-b4d1fcb0baf1> in <module>()
25----> 1 next(G)
⽣成器保存的是算法，每次调⽤ next(G) ，就计算出 G 的下⼀个元素的值,直到计算到最后.个元素，没有更多的元素时，抛出 StopIteration 的异常。当然，这种不断调⽤ next（）实在是太变态了，正确的⽅法是使⽤ for 循环，因为⽣成器也是可迭代对象。所以，我们创建了⼀个⽣成器后，基本上永远不会调⽤ next（），而是通过for循环来迭代它，并且不需要关心StopIteration 异常！
创建生成器方法二
先看看这个斐波那契函数的例子：
1In [3]: def creatNum():
2 ...: a,b = 0,1
3 ...: for i in range(5): # 生成5个斐波那契数
4 ...: print(b)
5 ...: a,b = b,a+b
6 ...:
7
8In [4]: creatNum()
接下来我们把它改成生成器：
1#-*- coding:utf-8 -*-
2
3def creatNum():
4 print("---start---")
5 a,b = 0,1
6 for i in range(5):
7 print("---1---")
8 yield b
9 print("---2---")
10 a,b = b,a+b
11 print("---3---")
12 print("---stop---")
接下来我们将这个模块导入：
1In [1]: from test import *
2
3In [2]: a = creatNum()
4
5In [3]: next(a)
6---start---
7---1---
8Out[3]: 1
9
10In [4]: next(a)
11---2---
12---3---
13---1---
14Out[4]: 1
15
16In [5]: next(a)
17---2---
18---3---
19---1---
20Out[5]: 2
我们在循环过程中不断调⽤ yield ，就会不断中断。当然要给循环设置⼀个条件来退出循环，不然就会产⽣⼀个⽆限数列出来。同样的，把函数改成generator后，我们基本上从来不会⽤ next() 来获取下⼀个返回值，⽽是直接使⽤ for 循环来迭代!
1In [1]: from test import *
2
3In [2]: a = creatNum()
4
5In [3]: while True:
6 ...: try:
7 ...: print("value:%d" % next(a))
8 ...: except StopIteration as e:
9 ...: print("生成器返回值：%s" % e.value)
10 ...: break
11 ...:
12---start---
13---1---
14value:1
15---2---
16---3---
17---1---
18value:1
19---2---
20---3---
21---1---
22value:2
23---2---
24---3---
25---1---
26value:3
27---2---
28---3---
29---1---
30value:5
31---2---
32---3---
33---stop---
34生成器返回值：None
注意：next(a)与a.__next__（）是等价的
send
1In [1]: def test():
2 ...: i = 0
3 ...: while i<5:
4 ...: tmp = yield i
5 ...: print(tmp)
6 ...: i += 1
7 ...:
8
9In [2]: t = test()
10
11In [3]: t.__next__()
12Out[3]: 0
13
14In [4]: t.__next__()
15None
16Out[4]: 1
17
18In [5]: t.__next__()
19None
20Out[5]: 2
为什么会打印出None呢？是应为yield i执行完毕之后会把结果直接返回，但是不会赋值给tmp，所以每次打印都是None，此时使用send方法就会在yield i执行完毕之并返回结果之后给yield i赋值：
1In [1]: def test():
2 ...: i = 0
3 ...: while i<5:
4 ...: tmp = yield i
5 ...: print(tmp)
6 ...: i += 1
7 ...:
8
9In [2]: t = test()
10
11In [3]: t.__next__()
12Out[3]: 0
13
14In [4]: t.__next__()
15None
16Out[4]: 1
17
18In [5]: t.__next__()
19None
20Out[5]: 2
21
22In [6]: t.send("Hello")
23Hello
24Out[6]: 3
25
26In [7]: t.send("HelloWorld")
27HelloWorld
28Out[7]: 4
send的注意事项
1In [8]: def test():
2 ...: ...: i = 0
3 ...: ...: while i<5:
4 ...: ...: tmp = yield i
5 ...: ...: print(tmp)
6 ...: ...: i += 1
7 ...: ...:
8 ...:
9
10In [9]: a = test()
11
12In [10]: a.send("---")
13---------------------------------------------------------------------------
14TypeError Traceback (most recent call last)
15<ipython-input-10-dc33d05574fa> in <module>()
16----> 1 a.send("---")
17
18TypeError: can't send non-None value to a just-started generator
不能在第一次生成的时候就调用send方法，因为代码还未执行到yield i，所以要先使用__next()__，再使用send()
当然还有一个方法：
1In [11]: def test():
2 ...: ...: i = 0
3 ...: ...: while i<5:
4 ...: ...: tmp = yield i
5 ...: ...: print(tmp)
6 ...: ...: i += 1
7 ...: ...:
8 ...:
9
10In [12]: t = test()
11
12In [13]: t.send(None)
13Out[13]: 0
总结
生成器是这样一个函数，它记住上一次返回时在函数体中的位置。对生成器函数的第二次（或者第n次）调用跳转至该函数体中间，而上次调用的所有局部变量都保持不变！
⽣成器不仅“记住”了它数据状态；⽣成器还“记住”了它在流控制构造（在命令式编程中，这种构造不只是数据值）中的位置
生成器的特点
- 节约内存，在超大列表的情况下是非常吃内存的！
- 迭代到下⼀次的调⽤时，所使⽤的参数都是第⼀次所保留下的，即是说，在整个所有函数调⽤的参数都是第⼀次所调⽤时保留的，⽽不是新创建的，这样非常高效！ 迭代是访问集合元素的⼀种⽅式。迭代器是⼀个可以记住遍历的位置的对象。迭代器对象从集合的第⼀个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退！
可迭代对象
以直接作⽤于 for 循环的数据类型有以下⼏种： ⼀类是集合数据类型，如 list 、 tuple 、 dict 、 set 、 str 等； ⼀类是 generator ，包括⽣成器和带 yield 的generator function。 这些可以直接作⽤于 for 循环的对象统称为可迭代对象： Iterable
1In [1]: for s in "Hello":
2 ...: print(s)
3 ...:
4H
5e
6l
7l
8o
9
10In [2]: b = (x for x in range(5))
11
12In [3]: b
13Out[3]: <generator object <genexpr> at 0x0000021FEBC98A40>
14
15In [4]: for tmp in b:
16 ...: print(tmp)
17 ...:
180
191
202
213
224
判断是否可以迭代
可以使⽤isinstance()判断一个对象是否是Iterable (可迭代的)对象：
1In [1]: from collections import Iterable
2
3In [2]: isinstance([],Iterable)
4Out[2]: True
5
6In [3]: isinstance({},Iterable)
7Out[3]: True
8
9In [4]: isinstance('abc',Iterable)
10Out[4]: True
11
12In [5]: isinstance((x for x in range(5)),Iterable)
13Out[5]: True
⽽⽣成器不但可以作⽤于 for 循环，还可以被 next() 函数不断调⽤并返回下⼀个值，直到最后抛出 StopIteration 错误表示⽆法继续返回下⼀个值了!
迭代器
可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。
可以使用isinstance() 判断某个对象是否是 Iterator (迭代器)对象
1In [1]: from collections import Iterator
2
3In [2]: isinstance((x for x in range(10)),Iterator)
4Out[2]: True
5
6In [3]: isinstance([],Iterator)
7Out[3]: False
8
9In [4]: isinstance({},Iterator)
10Out[4]: False
11
12In [5]: isinstance("abc",Iterator)
13Out[5]: False
14
15In [6]: isinstance(100,Iterator)
16Out[6]: False
所以说，生成器也是迭代器的一种！
iter()函数
生成器都是Iterator对象，但是list、dict、str虽然是Iterable，去不是Iterator
1In [7]: isinstance(iter("abc"),Iterator)
2Out[7]: True
3
4In [8]: isinstance(iter([]),Iterator)
5Out[8]: True
总结
- 凡是可作⽤于 for 循环的对象都是 Iterable 类型
- 凡是可作⽤于 next() 函数的对象都是 Iterator 类型
- 集合数据类型如 list 、 dict 、 str 等是 Iterable 但不是 Iterator，不过可以通过 iter() 函数获得⼀个 Iterator 对象。
闭包
内部函数对外部函数作用域变量的引用（非全局变量），则称内部函数为闭包！
应用实例
1def linr_conf(a, b):
2 def line(x):
3 return a*x + b
4
5 return line
6
7# 相当于通过同一个方法构建了两种直线模型
8line1 = linr_conf(1,1)
9line2 = linr_conf(4,5)
10
11print(line1(5))
12print(line2(5))
这个例子中，函数line与变量a,b构成闭包。在创建闭包的时候，我们通过line_conf的参数a,b说明了这两个变量的取值，这样，我们就确定了函数的最终形式(y = x + 1和y = 4x + 5)。我们只需要变换参数a,b，就可以获得不同的直线表达函数。由此，我们可以看到，闭包也具有提高代码可复用性的作用！ 如果没有闭包，我们需要每次创建直线函数的时候同时说明a,b,x。这样，我们就需要更多的参数传递，也减少了代码的可移植性！
总结
- 闭包似优化了变量，原来需要类对象完成的工作，闭包也可以完成
- 由于闭包引用了外部函数的局部变量，则外部函数局部变量没有释放，消耗内存
装饰器
装饰器是程序开发中经常会⽤到的⼀个功能，⽤好了装饰器，开发效率如⻁添翼，所以这也是Python⾯试中必问的问题，但对于好多初次接触这个知识的⼈来讲，这个功能有点绕，⾃学时直接绕过去了，然后⾯试问到了就挂了，因为装饰器是程序开发的基础知识，这个都不会，别跟⼈家说你会Python, 看了下⾯的⽂章，保证你学会装饰器！
模拟场景
假设这些都是核心业务方法，但是现在的需求是：不能让每一个人都随意的调用这些方法，为了安全起见，在调用这些方法的时候必须进行权限验证！
为了增加权限验证的逻辑，修改后的代码如下：
1def coreCode():
2 # 验证一
3 # 验证二
4 ...
5def coreCode2():
6 # 验证一
7 # 验证二
8 ...
9def coreCode3():
10 # 验证一
11 # 验证二
12 ...
很显然这是极不合理的，代码太过于冗余，修改之后：
1def check_call():
2 # 验证-
3 # 验证二
4def coreCode():
5 check_call()
6 ...
7def coreCode2():
8 check_call()
9 ...
10def coreCode3():
11 check_call()
12 ...
这回修改之后的代码显得不是很冗余，但是违反了开放封闭原则，这样会修改核心业务代码，也是非常不推荐的做法，接着装饰器就登场了：
1def check(func):
2 def inner():
3 # 验证1
4 # 验证2
5 func()
6 return inner
7
8@check
9def coreCode():
10 ...
11
12@check
13def coreCode2():
14 ...
15
16@check
17def coreCode3():
18 ...
对于上述代码，也是仅仅对基础平台的代码进行修改，就可以实现在其他人调用coreCode1、coreCode2、coreCode3的时候都进行验证操作！
1def check(func):
2 def inner():
3 print("验证1...")
4 print("验证2...")
5 print("验证3...")
6 func()
7 return inner
8
9
10@check
11def coreCode1():
12 print("coreCode1...")
13
14def coreCode2():
15 print("coreCode2...")
16
17
18coreCode1()
19print("-"*30)
20coreCode2()
python解释器就会从上到下解释代码，步骤如下:
- def check(func): ==>将check函数加载到内存
- @check 没错， 从表⾯上看解释器仅仅会解释这两句代码，因为函数在没有被调⽤之前其内部代码不会被执行。从表面上看解释器着实会执行这两句，但是 @check 这⼀句代码里却有大文章， @函数名 是python的⼀种语法糖.
@check到底做了什么
- 执行check函数，并且会把@check下面的函数当做check函数的参数，所以内部就会执行验证的逻辑，执行完毕才去调用参数中的方法！
- check的返回值，将执行完毕的check函数返回值赋值给@check下面的函数名coreCode
- 所以想要执行coreCode 函数时，就会执行新coreCode函数，在新coreCode函数内部先执⾏验证，再执行原来的coreCode函数，然后将原来coreCode函数的返回值返回给了业务调⽤者。
再议装饰器
装饰器的装饰执行时间：并不是在调用的时候才去装饰函数，而是在解释器解释到那一句的时候就已经装饰了函数！