2- 高级语法
迭代器
迭代是访问集合元素的一种方式。迭代器是一个可以记住遍历的位置的对象。迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。
1. 可迭代对象
我们已经知道可以对list、tuple、str等类型的数据使用for...in...的循环语法从其中依次拿到数据进行使用，我们把这样的过程称为遍历，也叫迭代。
但是，是否所有的数据类型都可以放到for...in...的语句中，然后让for...in...每次从中取出一条数据供我们使用，即供我们迭代吗？
>>> for i in 100: ... print(i) ... Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: 'int' object is not iterable >>>
int整型不是iterable，即int整型不是可以迭代的
我们自定义一个容器MyList用来存放数据，可以通过add方法向其中添加数据
>>> class MyList(object): ... def __init__(self): ... self.container = [] ... def add(self, item): ... self.container.append(item) ... >>> mylist = MyList() >>> mylist.add(1) >>> mylist.add(2) >>> mylist.add(3) >>> for num in mylist: ... print(num) ... Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: 'MyList' object is not iterable >>>
MyList容器的对象也是不能迭代的我们自定义了一个容器类型MyList，在将一个存放了多个数据的MyList对象放到for...in...的语句中，发现for...in...并不能从中依次取出一条数据返回给我们，也就说我们随便封装了一个可以存放多条数据的类型却并不能被迭代使用。
我们把可以通过for...in...这类语句迭代读取一条数据供我们使用的对象称之为可迭代对象（Iterable）。
2. 如何判断一个对象是否可以迭代
可以使用 isinstance() 判断一个对象是否是 Iterable 对象：
In [50]: from collections import Iterable In [51]: isinstance([], Iterable) Out[51]: True In [52]: isinstance({}, Iterable) Out[52]: True In [53]: isinstance('abc', Iterable) Out[53]: True In [54]: isinstance(mylist, Iterable) Out[54]: False In [55]: isinstance(100, Iterable) Out[55]: False
3. 可迭代对象的本质
我们分析对可迭代对象进行迭代使用的过程，发现每迭代一次（即在for...in...中每循环一次）都会返回对象中的下一条数据，一直向后读取数据直到迭代了所有数据后结束。那么，在这个过程中就应该有一个“人”去记录每次访问到了第几条数据，以便每次迭代都可以返回下一条数据。我们把这个能帮助我们进行数据迭代的“人”称为迭代器(Iterator)。
可迭代对象的本质就是可以向我们提供一个这样的中间“人”即迭代器帮助我们对其进行迭代遍历使用。
可迭代对象通过__iter__方法向我们提供一个迭代器，我们在迭代一个可迭代对象的时候，实际上就是先获取该对象提供的一个迭代器，然后通过这个迭代器来依次获取对象中的每一个数据。
那么也就是说，一个具备了__iter__方法的对象，就是一个可迭代对象。
>>> class MyList(object): ... def __init__(self): ... self.container = [] ... def add(self, item): ... self.container.append(item) ... def __iter__(self): ... """返回一个迭代器""" ... # 我们暂时忽略如何构造一个迭代器对象 ... pass ... >>> mylist = MyList() >>> from collections import Iterable >>> isinstance(mylist, Iterable) True >>>
这回测试发现添加了__iter__方法的mylist对象已经是一个可迭代对象了
4. iter()函数与next()函数
list、tuple等都是可迭代对象，我们可以通过iter()函数获取这些可迭代对象的迭代器。然后我们可以对获取到的迭代器不断使用next()函数来获取下一条数据。iter()函数实际上就是调用了可迭代对象的__iter__方法。
>>> li = [11, 22, 33, 44, 55] >>> li_iter = iter(li) >>> next(li_iter) 11 >>> next(li_iter) 22 >>> next(li_iter) 33 >>> next(li_iter) 44 >>> next(li_iter) 55 >>> next(li_iter) Traceback (most recent call last): File "<stdin>", line 1, in <module> StopIteration >>>
注意，当我们已经迭代完最后一个数据之后，再次调用next()函数会抛出StopIteration的异常，来告诉我们所有数据都已迭代完成，不用再执行next()函数了。
5. 如何判断一个对象是否是迭代器
可以使用 isinstance() 判断一个对象是否是 Iterator 对象：
In [56]: from collections import Iterator In [57]: isinstance([], Iterator) Out[57]: False In [58]: isinstance(iter([]), Iterator) Out[58]: True In [59]: isinstance(iter("abc"), Iterator) Out[59]: True
6. 迭代器Iterator
通过上面的分析，我们已经知道，迭代器是用来帮助我们记录每次迭代访问到的位置，当我们对迭代器使用next()函数的时候，迭代器会向我们返回它所记录位置的下一个位置的数据。实际上，在使用next()函数的时候，调用的就是迭代器对象的__next__方法（Python3中是对象的__next__方法，Python2中是对象的next()方法）。所以，我们要想构造一个迭代器，就要实现它的__next__方法。但这还不够，python要求迭代器本身也是可迭代的，所以我们还要为迭代器实现__iter__方法，而__iter__方法要返回一个迭代器，迭代器自身正是一个迭代器，所以迭代器的__iter__方法返回自身即可。
一个实现了__iter__方法和__next__方法的对象，就是迭代器。
class MyList(object): """自定义的一个可迭代对象""" def __init__(self): self.items = [] def add(self, val): self.items.append(val) def __iter__(self): myiterator = MyIterator(self) return myiterator class MyIterator(object): """自定义的供上面可迭代对象使用的一个迭代器""" def __init__(self, mylist): self.mylist = mylist # current用来记录当前访问到的位置 self.current = 0 def __next__(self): if self.current < len(self.mylist.items): item = self.mylist.items[self.current] self.current += 1 return item else: raise StopIteration def __iter__(self): return self if __name__ == '__main__': mylist = MyList() mylist.add(1) mylist.add(2) mylist.add(3) mylist.add(4) mylist.add(5) for num in mylist: print(num)
7. for...in...循环的本质
for item in Iterable 循环的本质就是先通过iter()函数获取可迭代对象Iterable的迭代器，然后对获取到的迭代器不断调用next()方法来获取下一个值并将其赋值给item，当遇到StopIteration的异常后循环结束。
8. 迭代器的应用场景
我们发现迭代器最核心的功能就是可以通过next()函数的调用来返回下一个数据值。如果每次返回的数据值不是在一个已有的数据集合中读取的，而是通过程序按照一定的规律计算生成的，那么也就意味着可以不用再依赖一个已有的数据集合，也就是说不用再将所有要迭代的数据都一次性缓存下来供后续依次读取，这样可以节省大量的存储（内存）空间。
举个例子，比如，数学中有个著名的斐波拉契数列（Fibonacci），数列中第一个数为0，第二个数为1，其后的每一个数都可由前两个数相加得到：
0, 1, 1, 2, 3, 5, 8, 13, 21, 34, ...
现在我们想要通过for...in...循环来遍历迭代斐波那契数列中的前n个数。那么这个斐波那契数列我们就可以用迭代器来实现，每次迭代都通过数学计算来生成下一个数。
class FibIterator(object): """斐波那契数列迭代器""" def __init__(self, n): """ :param n: int, 指明生成数列的前n个数 """ self.n = n # current用来保存当前生成到数列中的第几个数了 self.current = 0 # num1用来保存前前一个数，初始值为数列中的第一个数0 self.num1 = 0 # num2用来保存前一个数，初始值为数列中的第二个数1 self.num2 = 1 def __next__(self): """被next()函数调用来获取下一个数""" if self.current < self.n: num = self.num1 self.num1, self.num2 = self.num2, self.num1+self.num2 self.current += 1 return num else: raise StopIteration def __iter__(self): """迭代器的__iter__返回自身即可""" return self if __name__ == '__main__': fib = FibIterator(10) for num in fib: print(num, end=" ")
9. 并不是只有for循环能接收可迭代对象
除了for循环能接收可迭代对象，list、tuple等也能接收。
li = list(FibIterator(15)) print(li) tp = tuple(FibIterator(6)) print(tp)
生成器
1. 生成器
利用迭代器，我们可以在每次迭代获取数据（通过next()方法）时按照特定的规律进行生成。但是我们在实现一个迭代器时，关于当前迭代到的状态需要我们自己记录，进而才能根据当前状态生成下一个数据。为了达到记录当前状态，并配合next()函数进行迭代使用，我们可以采用更简便的语法，即生成器(generator)。生成器是一类特殊的迭代器。
2. 创建生成器方法1
要创建一个生成器，有很多种方法。第一种方法很简单，只要把一个列表生成式的 [ ] 改成 ( )
In [15]: L = [ x*2 for x in range(5)] In [16]: L Out[16]: [0, 2, 4, 6, 8] In [17]: G = ( x*2 for x in range(5)) In [18]: G Out[18]: <generator object <genexpr> at 0x7f626c132db0>
创建 L 和 G 的区别仅在于最外层的 [ ] 和 ( ) ， L 是一个列表，而 G 是一个生成器。我们可以直接打印出列表L的每一个元素，而对于生成器G，我们可以按照迭代器的使用方法来使用，即可以通过next()函数、for循环、list()等方法使用。
In [19]: next(G) Out[19]: 0 In [20]: next(G) Out[20]: 2 In [21]: next(G) Out[21]: 4 In [22]: next(G) Out[22]: 6 In [23]: next(G) Out[23]: 8 In [24]: next(G) --------------------------------------------------------------------------- StopIteration Traceback (most recent call last) <ipython-input-24-380e167d6934> in <module>() ----> 1 next(G) StopIteration: In [25]: In [26]: G = ( x*2 for x in range(5)) In [27]: for x in G: ....: print(x) ....: 0 2 4 6 8 In [28]:
3. 创建生成器方法2
generator非常强大。如果推算的算法比较复杂，用类似列表生成式的 for 循环无法实现的时候，还可以用函数来实现。
我们仍然用上一节提到的斐波那契数列来举例，回想我们在上一节用迭代器的实现方式：
现在我们用生成器来实现一下。
In [30]: def fib(n): ....: current = 0 ....: num1, num2 = 0, 1 ....: while current < n: ....: num = num1 ....: num1, num2 = num2, num1+num2 ....: current += 1 ....: yield num ....: return 'done' ....: In [31]: F = fib(5) In [32]: next(F) Out[32]: 1 In [33]: next(F) Out[33]: 1 In [34]: next(F) Out[34]: 2 In [35]: next(F) Out[35]: 3 In [36]: next(F) Out[36]: 5 In [37]: next(F) --------------------------------------------------------------------------- StopIteration Traceback (most recent call last) <ipython-input-37-8c2b02b4361a> in <module>() ----> 1 next(F) StopIteration: done
在使用生成器实现的方式中，我们将原本在迭代器__next__方法中实现的基本逻辑放到一个函数中来实现，但是将每次迭代返回数值的return换成了yield，此时新定义的函数便不再是函数，而是一个生成器了。
此时按照调用函数的方式( 案例中为F = fib(5) )使用生成器就不再是执行函数体了，而是会返回一个生成器对象（ 案例中为F ），然后就可以按照使用迭代器的方式来使用生成器了。
总结
- 使用了yield关键字的函数不再是函数，而是生成器。（使用了yield的函数就是生成器）
- yield关键字有两点作用：
- 保存当前运行状态（断点），然后暂停执行，即将生成器（函数）挂起
- 将yield关键字后面表达式的值作为返回值返回，此时可以理解为起到了return的作用
- 可以使用next()函数让生成器从断点处继续执行，即唤醒生成器（函数）
- Python3中的生成器可以使用return返回最终运行的返回值，而Python2中的生成器不允许使用return返回一个返回值（即可以使用return从生成器中退出，但return后不能有任何表达式）。
4. 使用send唤醒
我们除了可以使用next()函数来唤醒生成器继续执行外，还可以使用send()函数来唤醒执行。使用send()函数的一个好处是可以在唤醒的同时向断点处传入一个附加数据。
例子：执行到yield时，gen函数作用暂时保存，返回i的值; temp接收下次c.send("python")，send发送过来的值，c.next()等价c.send(None)
In [10]: def gen(): ....: i = 0 ....: while i<5: ....: temp = yield i ....: print(temp) ....: i+=1 ....:
使用send
In [43]: f = gen() In [44]: next(f) Out[44]: 0 In [45]: f.send('haha') haha Out[45]: 1 In [46]: next(f) None Out[46]: 2 In [47]: f.send('haha') haha Out[47]: 3 In [48]:
使用next函数
In [11]: f = gen() In [12]: next(f) Out[12]: 0 In [13]: next(f) None Out[13]: 1 In [14]: next(f) None Out[14]: 2 In [15]: next(f) None Out[15]: 3 In [16]: next(f) None Out[16]: 4 In [17]: next(f) None --------------------------------------------------------------------------- StopIteration Traceback (most recent call last) <ipython-input-17-468f0afdf1b9> in <module>() ----> 1 next(f) StopIteration:
使用__next__()方法（不常使用）
In [18]: f = gen() In [19]: f.__next__() Out[19]: 0 In [20]: f.__next__() None Out[20]: 1 In [21]: f.__next__() None Out[21]: 2 In [22]: f.__next__() None Out[22]: 3 In [23]: f.__next__() None Out[23]: 4 In [24]: f.__next__() None --------------------------------------------------------------------------- StopIteration Traceback (most recent call last) <ipython-input-24-39ec527346a9> in <module>() ----> 1 f.__next__() StopIteration:
闭包
1. 函数引用
def test1(): print("--- in test1 func----") #调用函数 test1() #引用函数 ret = test1 print(id(ret)) print(id(test1)) #通过引用调用函数 ret()
运行结果:
--- in test1 func---- 140212571149040 140212571149040 --- in test1 func----
2. 什么是闭包
#定义一个函数 def test(number): #在函数内部再定义一个函数，并且这个函数用到了外边函数的变量，那么将这个函数以及用到的一些变量称之为闭包 def test_in(number_in): print("in test_in 函数, number_in is %d"%number_in) return number+number_in #其实这里返回的就是闭包的结果 return test_in #给test函数赋值，这个20就是给参数number ret = test(20) #注意这里的100其实给参数number_in print(ret(100)) #注意这里的200其实给参数number_in print(ret(200))
运行结果：
in test_in 函数, number_in is 100 120 in test_in 函数, number_in is 200 220
3. 看一个闭包的实际例子：
def line_conf(a, b): def line(x): return a*x + b return line line1 = line_conf(1, 1) line2 = line_conf(4, 5) print(line1(5)) print(line2(5))
这个例子中，函数line与变量a,b构成闭包。在创建闭包的时候，我们通过line_conf的参数a,b说明了这两个变量的取值，这样，我们就确定了函数的最终形式(y = x + 1和y = 4x + 5)。我们只需要变换参数a,b，就可以获得不同的直线表达函数。由此，我们可以看到，闭包也具有提高代码可复用性的作用。
如果没有闭包，我们需要每次创建直线函数的时候同时说明a,b,x。这样，我们就需要更多的参数传递，也减少了代码的可移植性。
闭包思考：
1.闭包似优化了变量，原来需要类对象完成的工作，闭包也可以完成 2.由于闭包引用了外部函数的局部变量，则外部函数的局部变量没有及时释放，消耗内存
4. 修改外部函数中的变量
python3的方法
def counter(start=0): def incr(): nonlocal start start += 1 return start return incr c1 = counter(5) print(c1()) print(c1()) c2 = counter(50) print(c2()) print(c2()) print(c1()) print(c1()) print(c2()) print(c2())
python2的方法
def counter(start=0): count=[start] def incr(): count[0] += 1 return count[0] return incr c1 = counter(5) print(c1())#6 print(c1())#7 c2 = counter(100) print(c2())#101 print(c2())#102
LEGB 规则
Python 使用 LEGB 的顺序来查找一个符号对应的对象
locals -> enclosing function -> globals -> builtins
a = 1 # 全局变量 globals def fun(): a = 2 # 闭包变量 enclosing def inner_fun(): a = 3 # 局部变量 locals print("a=%d" % a) return inner_fun f = fun() f()
-
locals，当前所在命名空间（如函数、模块），函数的参数也属于命名空间内的变量
-
enclosing，外部嵌套函数的命名空间（闭包中常见）
def fun1(): a = 10 def fun2(): # a 位于外部嵌套函数的命名空间 print(a)
globals，全局变量，函数定义所在模块的命名空间
a = 1 def fun(): # 需要通过 global 指令来声明全局变量 global a # 修改全局变量，而不是创建一个新的 local 变量 a = 2
builtins，内建模块的命名空间。
Python 在启动的时候会自动为我们载入很多内建的函数、类， 比如 dict，list，type，print，这些都位于 __builtin__ 模块中， 可以使用 dir(__builtin__) 来查看。 这也是为什么我们在没有 import任何模块的情况下， 就能使用这么多丰富的函数和功能了。 在Python中，有一个内建模块，该模块中有一些常用函数;在Python启动后， 且没有执行程序员所写的任何代码前，Python会首先加载该内建模块到内存。 另外，该内建模块中的功能可以直接使用，不用在其前添加内建模块前缀， 其原因是对函数、变量、类等标识符的查找是按LEGB法则，其中B即代表内建模块 比如：内建模块中有一个abs()函数，其功能求绝对值，如abs(-20)将返回20。
装饰器
装饰器是程序开发中经常会用到的一个功能，用好了装饰器，开发效率如虎添翼，所以这也是Python面试中必问的问题，但对于好多初次接触这个知识的人来讲，这个功能有点绕，自学时直接绕过去了，然后面试问到了就挂了，因为装饰器是程序开发的基础知识，这个都不会，别跟人家说你会Python, 看了下面的文章，保证你学会装饰器。
单独以f1为例：
def w1(func): def inner(): # 验证1 # 验证2 # 验证3 func() return inner @w1 def f1(): print('f1')
python解释器就会从上到下解释代码，步骤如下：
-
def w1(func): ==>将w1函数加载到内存
-
@w1
没错， 从表面上看解释器仅仅会解释这两句代码，因为函数在 没有被调用之前其内部代码不会被执行。
从表面上看解释器着实会执行这两句，但是 @w1 这一句代码里却有大文章， @函数名 是python的一种语法糖。
上例@w1内部会执行一下操作：
执行w1函数
执行w1函数 ，并将 @w1 下面的函数作为w1函数的参数，即：@w1 等价于 w1(f1) 所以，内部就会去执行：
def inner(): #验证 1 #验证 2 #验证 3 f1() # func是参数，此时 func 等于 f1 return inner# 返回的 inner，inner代表的是函数，非执行函数 ,其实就是将原来的 f1 函数塞进另外一个函数中
w1的返回值
将执行完的w1函数返回值 赋值 给@w1下面的函数的函数名f1 即将w1的返回值再重新赋值给 f1，即：
新f1 = def inner(): #验证 1 #验证 2 #验证 3 原来f1() return inner
所以，以后业务部门想要执行 f1 函数时，就会执行 新f1 函数，在新f1 函数内部先执行验证，再执行原来的f1函数，然后将原来f1 函数的返回值返回给了业务调用者。
如此一来， 即执行了验证的功能，又执行了原来f1函数的内容，并将原f1函数返回值 返回给业务调用着
3. 再议装饰器
#定义函数：完成包裹数据 def makeBold(fn): def wrapped(): return "<b>" + fn() + "</b>" return wrapped #定义函数：完成包裹数据 def makeItalic(fn): def wrapped(): return "<i>" + fn() + "</i>" return wrapped @makeBold def test1(): return "hello world-1" @makeItalic def test2(): return "hello world-2" @makeBold @makeItalic def test3(): return "hello world-3" print(test1())) print(test2())) print(test3()))
运行结果:
<b>hello world-1</b> <i>hello world-2</i> <b><i>hello world-3</i></b>
4. 装饰器(decorator)功能
- 引入日志
- 函数执行时间统计
- 执行函数前预备处理
- 执行函数后清理功能
- 权限校验等场景
- 缓存
5. 装饰器示例
例1:无参数的函数
from time import ctime, sleep def timefun(func): def wrappedfunc(): print("%s called at %s"%(func.__name__, ctime())) func() return wrappedfunc @timefun def foo(): print("I am foo") foo() sleep(2) foo()
上面代码理解装饰器执行行为可理解成
foo = timefun(foo) #foo先作为参数赋值给func后,foo接收指向timefun返回的wrappedfunc foo() #调用foo(),即等价调用wrappedfunc() #内部函数wrappedfunc被引用，所以外部函数的func变量(自由变量)并没有释放 #func里保存的是原foo函数对象
例2:被装饰的函数有参数
from time import ctime, sleep def timefun(func): def wrappedfunc(a, b): print("%s called at %s"%(func.__name__, ctime())) print(a, b) func(a, b) return wrappedfunc @timefun def foo(a, b): print(a+b) foo(3,5) sleep(2) foo(2,4)
例3:被装饰的函数有不定长参数
from time import ctime, sleep def timefun(func): def wrappedfunc(*args, **kwargs): print("%s called at %s"%(func.__name__, ctime())) func(*args, **kwargs) return wrappedfunc @timefun def foo(a, b, c): print(a+b+c) foo(3,5,7) sleep(2) foo(2,4,9)
例4:装饰器中的return
from time import ctime, sleep def timefun(func): def wrappedfunc(): print("%s called at %s"%(func.__name__, ctime())) func() return wrappedfunc @timefun def foo(): print("I am foo") @timefun def getInfo(): return '----hahah---' foo() sleep(2) foo() print(getInfo())
执行结果:
foo called at Fri Nov 4 21:55:35 2016 I am foo foo called at Fri Nov 4 21:55:37 2016 I am foo getInfo called at Fri Nov 4 21:55:37 2016 None
如果修改装饰器为return func()，则运行结果：
foo called at Fri Nov 4 21:55:57 2016 I am foo foo called at Fri Nov 4 21:55:59 2016 I am foo getInfo called at Fri Nov 4 21:55:59 2016 ----hahah---
总结：
- 一般情况下为了让装饰器更通用，可以有return
例5:装饰器带参数,在原有装饰器的基础上，设置外部变量
#decorator2.py from time import ctime, sleep def timefun_arg(pre="hello"): def timefun(func): def wrappedfunc(): print("%s called at %s %s"%(func.__name__, ctime(), pre)) return func() return wrappedfunc return timefun @timefun_arg("itcast") def foo(): print("I am foo") @timefun_arg("python") def too(): print("I am too") foo() sleep(2) foo() too() sleep(2) too()
可以理解为
foo()==timefun_arg("itcast")(foo)()
例6：类装饰器（扩展，非重点）
装饰器函数其实是这样一个接口约束，它必须接受一个callable对象作为参数，然后返回一个callable对象。在Python中一般callable对象都是函数，但也有例外。只要某个对象重写了 __call__() 方法，那么这个对象就是callable的。
class Test(): def __call__(self): print('call me!') t = Test() t() # call me
类装饰器demo
class Test(object): def __init__(self, func): print("---初始化---") print("func name is %s"%func.__name__) self.__func = func def __call__(self): print("---装饰器中的功能---") self.__func() #说明： #1. 当用Test来装作装饰器对test函数进行装饰的时候，首先会创建Test的实例对象 # 并且会把test这个函数名当做参数传递到__init__方法中 # 即在__init__方法中的func变量指向了test函数体 # #2. test函数相当于指向了用Test创建出来的实例对象 # #3. 当在使用test()进行调用时，就相当于让这个对象()，因此会调用这个对象的__call__方法 # #4. 为了能够在__call__方法中调用原来test指向的函数体，所以在__init__方法中就需要一个实例属性来保存这个函数体的引用 # 所以才有了self.__func = func这句代码，从而在调用__call__方法中能够调用到test之前的函数体 @Test def test(): print("----test---") test() showpy()#如果把这句话注释，重新运行程序，依然会看到"--初始化--"
运行结果如下：
---初始化--- func name is test ---装饰器中的功能--- ----test---
functools
functools 是python2.5被引人的,一些工具函数放在此包里。
python2.7中
python3.5中
import functools dir(functools)
运行结果：
['MappingProxyType', 'RLock', 'WRAPPER_ASSIGNMENTS', 'WRAPPER_UPDATES', 'WeakKeyDictionary', '_CacheInfo', '_HashedSeq', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_c3_merge', '_c3_mro', '_compose_mro', '_convert', '_find_impl', '_ge_from_gt', '_ge_from_le', '_ge_from_lt', '_gt_from_ge', '_gt_from_le', '_gt_from_lt', '_le_from_ge', '_le_from_gt', '_le_from_lt', '_lru_cache_wrapper', '_lt_from_ge', '_lt_from_gt', '_lt_from_le', '_make_key', 'cmp_to_key', 'get_cache_token', 'lru_cache', 'namedtuple', 'partial', 'partialmethod', 'reduce', 'singledispatch', 'total_ordering', 'update_wrapper', 'wraps']
wraps函数
使用装饰器时，有一些细节需要被注意。例如，被装饰后的函数其实已经是另外一个函数了（函数名等函数属性会发生改变）。
添加后由于函数名和函数的doc发生了改变，对测试结果有一些影响，例如:
def note(func): "note function" def wrapper(): "wrapper function" print('note something') return func() return wrapper @note def test(): "test function" print('I am test') test() print(test.__doc__)
运行结果
note something I am test wrapper function
所以，Python的functools包中提供了一个叫wraps的装饰器来消除这样的副作用。例如：
import functools def note(func): "note function" @functools.wraps(func) def wrapper(): "wrapper function" print('note something') return func() return wrapper @note def test(): "test function" print('I am test') test() print(test.__doc__)
运行结果
note something I am test test function
