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("1")
def fun2():
    print("fun2")
    logger("2")

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("33[32;1mUser has passed authentication33[0m")
                    res = func(*args, **kwargs)  # from home
                    print("---after authenticaion ")
                    return res
                else:
                    exit("33[31;1mInvalid username or password33[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()

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