前提知识：
掌握位置形参、关键字实参之可变长参数，名称空间以及作用域，函数的嵌套使用，最后是对前面的综合运用————闭包函数的掌握
1、基础知识：
装饰器的功能：简而言之，就是为了给函数（大多数是，当然也可以是类class）增加新功能（注意，不是修改函数原来就有的功能）
但是要求是：
1、不改变原来函数的代码。2、不改变原来函数的调用方式。
为何需要使用装饰器：开放封闭原则
1、开放：对函数的拓展功能（增加新功能）是开放的。
2、封闭：对修改源代码是封闭的。
使用装饰器的好处：
1、源代码不会改变，保证安全性和可维护性
2、调用方式不会改变，这样子避免了对函数调用的代码的大量修改
2、准备工作
譬如：如下为原始函数
import time def hello(name, age): time.sleep(2) # 代码暂停2秒 print('Hello, I am {}, I was {} years old'.format(name, age)) hello('a', 18) # 假使这里对函数调用了上万遍
需求是，计算该函数执行完需要多久？——————这是新功能
3、提示：这里为了能更好的理解装饰器，会给出几种不符合要求的方案然后一步一步优化修改
4、方案一：修改函数内部代码
按照常规想法，自然而然地会想到需要给函数增加计时地新功能，那当然是修改函数内部代码。
所以很容易可以修改成下方地代码：
import time def hello(name, age): start = time.time() # 记录代码开始时间 time.sleep(2) # 代码暂停2秒 print('Hello, I am {}, I was {} years old'.format(name, age)) stop = time.time() # 记录代码结束时间 print(stop - start) # 相减即为代码运行时间 hello('a', 18) # 假使这里对函数调用了上万遍
缺陷：虽然不需要修改函数的调用方式，但是修改了函数的源代码，不符合要求。
5、方案二：函数调用前后增加代码
很高兴你能想到这种方式，下面是修改的代码：
import time def hello(name, age): time.sleep(2) # 代码暂停2秒 print('Hello, I am {}, I was {} years old'.format(name, age)) start = time.time() hello('a', 18) # 假使这里对函数调用了上万遍 stop = time.time() print(stop - start)
缺陷：虽然这种修改方式既没有修改函数的源代码，也没有修改函数的调用方式。但是，假使这是一个巨大的项目，由于对于原函数的调用不是一次两次，而是上万次，那么这样子修改势必会浪费巨大的时间和精力。
6、方案三：使用闭包函数实现装饰器对函数的修改
首先我们要肯定方案二的正确性（没有修改源代码，也没有修改函数的调用方式），然后在它的基础上做出修改。
原来的函数定义是这个样子的：
import time def hello(name, age): time.sleep(2) # 代码暂停2秒 print('Hello, I am {}, I was {} years old'.format(name, age)) hello('a', 18) # 假使这里对函数调用了上万遍
那么 ，我们可以一个函数调用前后增加计时功能，如下：
import time def hello(name, age): time.sleep(2) # 代码暂停2秒 print('Hello, I am {}, I was {} years old'.format(name, age)) start = time.time() hello('HZH', 18) stop = time.time() print(stop - start)
但是这样子还是不行，因为我们需要对每一个函数调用都得这么写，太累了！
所以应该修改成函数的形式，如下：
import time def hello(name, age): time.sleep(2) # 代码暂停2秒 print('Hello, I am {}, I was {} years old'.format(name, age)) def new_hello(): start = time.time() hello('HZH', 18) stop = time.time() print(stop - start)
但是这个样子还是不行，因为这个函数只能写hello(’HZH‘, 18)，换言之，我们把hello函数写死了，所以需要将修改成变量name，age。所以new_hello函数需要传入两个参数进来。
import time def hello(name, age): time.sleep(2) # 代码暂停2秒 print('Hello, I am {}, I was {} years old'.format(name, age)) def new_hello(name, age): start = time.time() hello(name, age) stop = time.time() print(stop - start)
但是这个样子还是不行，如果我需要给原来的函数hello修改源代码，譬如增加参数，那么new_hello函数形参需要修改，里面的hello()传入的实参也要修改，所以修改如下：
import time def hello(name, age): time.sleep(2) # 代码暂停2秒 print('Hello, I am {}, I was {} years old'.format(name, age)) def new_hello(*args, **kwargs): start = time.time() hello(*args, **kwargs) stop = time.time() print(stop - start)
但是这个样子还是不行，装饰器是可以为任何函数增加同样的功能，现在只能给hello函数增加计时功能，当然,函数的调用问题也还没有解决，先解决现在把hello函数写死了的问题：
import time def hello(name, age): time.sleep(2) # 代码暂停2秒 print('Hello, I am {}, I was {} years old'.format(name, age)) func = hello def new_hello(*args, **kwargs): start = time.time() func(*args, **kwargs) stop = time.time() print(stop - start)
现在只要我想要调用具有新功能的函数hello，我只需要func = hello(这里不在new_hello里面增加参数func，是因为args和kwargs什么都可以接收，无法实现)————将hello函数的内存地址传给func函数，接着只要调用new_hello函数就可以实现计时功能（当然，现在还没有解决调用方式需要修改的问题）
但是，这样子写还不是最好的，因为我们还没有将它封装一下也就是把这整个def成函数。
import time def hello(name, age): time.sleep(2) # 代码暂停2秒 print('Hello, I am {}, I was {} years old'.format(name, age)) def outer(func): # func = hello 这里如这样子写，那么就只能传入hello的内存地址了，所以应该放在上面传参 def new_hello(*args, **kwargs): start = time.time() hello(*args, **kwargs) stop = time.time() print(stop - start) # 同时原来new_hello在全局空间就能访问现在只能在局部空间访问，所以需要返回其内存地址到全局空间 return new_hello
这样子只剩下一个问题没有解决——函数的调用，假使我们调用函数，那么调用的new_hello('HZH', 18)
而原函数的调用方式是hello('HZH', 18)
所以，看下方代码：
import time def hello(name, age): time.sleep(2) # 代码暂停2秒 print('Hello, I am {}, I was {} years old'.format(name, age)) def outer(func): # func = hello 这里如这样子写，那么就只能传入hello的内存地址了，所以应该放在上面传参 def new_hello(*args, **kwargs): start = time.time() func(*args, **kwargs) stop = time.time() print(stop - start) # 同时原来new_hello在全局空间就能访问现在只能在局部空间访问，所以需要返回其内存地址到全局空间 return new_hello # 假使我们下面这个样子 hello = outer(f1) """那么我们经历了如下过程，首先函数hello的内存地址传给了func(即func保存着原始函数f1的内存地址，当然func现在是在outer函数的局部空间里)，接着执行def new_hello()(这里给函数new_hello赋了内存地址，即使还没有为其内部开辟内存空间),接着return new_hello的内存地址给了hello，那么原来的函数hello的内存地址被现在new_hello的内存地址覆盖了，而且由于现在的函数hello还引用着函数new_hello的内存地址，所以函数outer的空间不会被销毁""" # 如果现在调用hello('HZH', 18),那么实际上hello早已不是原来的那个函数hello，现在的hello指 # 向new_hello的内存地址，执行hello('HZH', 18),实际就是可以理解为调用函数new_hello # 而new_hello里面的func由于在其内部没有定义，所以按照内嵌函数的定义，func会往外层函数寻找 # 结果在函数outer里面找到了存储着原来函数hello内存地址的func
7、稍微完善一下
对于前面方案三的问题，大部分已经解决了，譬如，
1、函数的调用方式没有变化，
2、函数的源代码没有变化，
3、对函数增加新功能没有冗余代码——一个装饰器就解决了。
但是，前面还有几个小的问题还没有解决。
1、假使我们原函数有返回值（当然现在原函数hello没有返回值，那么return是None，但是以后有呢？或者其它函数有呢？），那么由于增加了新功能的new_hello函数并没有返回值，所以需要在其内部用变量接收存储着原函数hello内存地址的func函数调用后的返回值，如下：
import time def hello(name, age): time.sleep(2) # 代码暂停2秒 print('Hello, I am {}, I was {} years old'.format(name, age)) def outer(func): # func = hello 这里如这样子写，那么就只能传入hello的内存地址了，所以应该放在上面传参 def new_hello(*args, **kwargs): start = time.time() res = func(*args, **kwargs) stop = time.time() print(stop - start) return res # 同时原来new_hello在全局空间就能访问现在只能在局部空间访问，所以需要返回其内存地址到全局空间 return new_hello # 假使我们下面这个样子 hello = outer(f1) """那么我们经历了如下过程，首先函数hello的内存地址传给了func(即func保存着原始函数f1的内存地址，当然func现在是在outer函数的局部空间里)，接着执行def new_hello()(这里给函数new_hello赋了内存地址，即使还没有为其内部开辟内存空间),接着return new_hello的内存地址给了hello，那么原来的函数hello的内存地址被现在new_hello的内存地址覆盖了，而且由于现在的函数hello还引用着函数new_hello的内存地址，所以函数outer的空间不会被销毁""" # 如果现在调用hello('HZH', 18),那么实际上hello早已不是原来的那个函数hello，现在的hello指 # 向new_hello的内存地址，执行hello('HZH', 18),实际就是可以理解为调用函数new_hello # 而new_hello里面的func由于在其内部没有定义，所以按照内嵌函数的定义，func会往外层函数寻找 # 结果在函数outer里面找到了存储着原来函数hello内存地址的func
2、对于我们创建的装饰器，我们了解原理后知道，这个装饰器不仅可以为hello函数增加计时功能，也可以为其它函数增加同样的计时功能。那么需要增加功能需要使用装饰器，如下（假使有f1函数，f2函数，f3函数需要增加计时功能）：
f1 = outer(f1) f2 = outer(f2) f3 = outer(f3)
但是呢，对于装饰器为其它函数增加功能（也就是执行上面这一步），我们的python有更好的写法（语法糖），可以将装饰器的定义写在原函数的上方，然后对于需要装饰的函数，只需要在其定义上方单独加一行，里面写@装饰器名，具体如下：
import time def outer(func): # func = hello 这里如这样子写，那么就只能传入hello的内存地址了，所以应该放在上面传参 def new_hello(*args, **kwargs): start = time.time() res = func(*args, **kwargs) stop = time.time() print(stop - start) return res # 同时原来new_hello在全局空间就能访问现在只能在局部空间访问，所以需要返回其内存地址到全局空间 return new_hello @outer def hello(name, age): time.sleep(2) # 代码暂停2秒 print('Hello, I am {}, I was {} years old'.format(name, age)) # 假使我们下面这个样子 # hello = outer(f1) 我们换一种方法来进行这一步操作 """那么我们经历了如下过程，首先函数hello的内存地址传给了func(即func保存着原始函数f1的内存地址，当然func现在是在outer函数的局部空间里)，接着执行def new_hello()(这里给函数new_hello赋了内存地址，即使还没有为其内部开辟内存空间),接着return new_hello的内存地址给了hello，那么原来的函数hello的内存地址被现在new_hello的内存地址覆盖了，而且由于现在的函数hello还引用着函数new_hello的内存地址，所以函数outer的空间不会被销毁""" # 如果现在调用hello('HZH', 18),那么实际上hello早已不是原来的那个函数hello，现在的hello指 # 向new_hello的内存地址，执行hello('HZH', 18),实际就是可以理解为调用函数new_hello # 而new_hello里面的func由于在其内部没有定义，所以按照内嵌函数的定义，func会往外层函数寻找 # 结果在函数outer里面找到了存储着原来函数hello内存地址的func
