Python 之 装饰器

装饰器 中的“器”代指函数

所以装饰器本质是函数，用来装饰其它函数。例如：为其它函数添加其他功能

实现装饰器需要的知识：  高阶函数+嵌套函数 == 装饰器

1、函数就是“变量”

　　函数就是“变量”说的就是 函数在内存的存储和回收 和变量类似。

2、高阶函数（函数调用另一个函数，把函数名作为另一个函数的参数）

 def foo():
     print("foo ...")
 
 def fun(fun):
     print(fun)
     fun()   # fun = foo  相当于foo 和 fun 所指的内存一样
 fun(foo)
 
 #结果  <function foo at 0x0000000003C6E8C8>
 #       foo ...

我们发现 foo.. .执行了 ，是因为foo 和 fun 所指的内存一样 ，函数即变量 可以赋值

但是我们为什么要多此一举，这样执行呢？ 来看下面代码：

 import time
 def foo():
     time.sleep(1)
     print("foo ...")
 
 def fun(fun):
     start_time = time.time()
     fun()   # fun = foo  相当于foo 和 fun 所指的内存一样
     stop_time = time.time()
     print("cost time %s" %(stop_time - start_time))
 
 foo()
 fun(foo)
 
 #结果：foo ...
 #     foo ...
 #     cost time 1.0000572204589844

我们发现我们实现了装饰一个函数 我们执行 foo() 和 fun(foo) 效果不一样 ，fun装饰了 foo 函数

现在 我们已经满足了原则1 ：不改变源代码

我们再看另一个函数：

 import time
 def bar():
     time.sleep(3)
     print('in the bar')
 def test2(func):
     print(func)
     return func
 print(test2(bar))
 print("------------------")
 bar=test2(bar)
 bar()  #run bar
 
 #结果
 # <function bar at 0x0000000003C6E8C8>
 # <function bar at 0x0000000003C6E8C8>
 # ------------------
 # <function bar at 0x0000000003C6E8C8>
 # in the bar

我们满足了两个原则

3、嵌套函数

 def grandpa():
     # x=1
     def dad():   #只是定义阶段
         x=2
         def son():  #只是定义阶段
             x=3
             print (x)
         son()  #必须在这个位置执行
     dad()   #必须在这个位置执行  运行dad
 grandpa()

看下面的例子： 假如我们实际场景有100个函数（这里列举两个），这里的函数已经上线运行，现在需要为每一个函数增加一个日志。如果用下面的方式相当于修改了函数的源代码，万一产生错误那么后果很严重（业务崩溃）。

 __author__ = "WSX"
 
 def fun1():
     print("fun1")
     logger("")
 def fun2():
     print("fun2")
     logger("")
 
 def logger( fun):
     print("Logger %s" %fun)
 fun1()
 fun2()

所以函数一旦写好不要去修改函数源代码。

这里我们就需要装饰器。

装饰器的原则：

1、不会修改被修饰的函数源码

2、不要修改函数的调用方式

现在我们来写一个简单的装饰器：

 import time
 def timmer(func):  #这是一个装饰器 ，计算时间
     def warpper(*args,**kwargs):
         start_time=time.time()
         func(*args,**kwargs)
         stop_time=time.time()
         print('the func run time is %s' %(stop_time-start_time))
     return warpper
 
 @timmer
 def test1():
     time.sleep(3)
     print('in the test1')
 test1()

结果：
in the test1
the func run time is 3.0001718997955322

上面的代码满足装饰器的原则。现在来分析程序：

@timmer  相当于test1 = timmer(test1)
现在我们就完成了一个装饰器。timmer是装饰器    test1是需要被装饰的函数
 
下面是老男孩教育Alex写的复杂的带函数返回值的装饰器（堪称高潮）：

 __author__ = "Alex Li"
 import time
 user,passwd = 'alex','abc123'
 def auth(auth_type):
     print("auth func:",auth_type)
     def outer_wrapper(func):
         def wrapper(*args, **kwargs):
             print("wrapper func args:", *args, **kwargs)
             if auth_type == "local":
                 username = input("Username:").strip()
                 password = input("Password:").strip()
                 if user == username and passwd == password:
                     print("\033[32;1mUser has passed authentication\033[0m")
                     res = func(*args, **kwargs)  # from home
                     print("---after authenticaion ")
                     return res
                 else:
                     exit("\033[31;1mInvalid username or password\033[0m")
             elif auth_type == "ldap":
                 print("搞毛线ldap,不会。。。。")
 
         return wrapper
     return outer_wrapper
 
 def index():
     print("welcome to index page")
 @auth(auth_type="local") # home = wrapper()
 def home():
     print("welcome to home  page")
     return "from home"
 
 @auth(auth_type="ldap")
 def bbs():
     print("welcome to bbs  page")
 
 index()
 print(home()) #wrapper()
 bbs()

采用三层嵌套，第二层用于返回需要被装饰的函数的返回值。