装饰器

装饰器定义：

本质是函数。函数的目的是为了完成特定的功能，那么装饰器的功能是什么呢？——饰器的功能是装饰其他函数。（为其他函数添加附加功能）。

装饰器的原则：装饰器对被它装饰的函数是完全透明的，即意味着用着被装饰的函数根本无法感知到装饰器。

　　1.不能修改被装饰的函数的源代码

　　2.不能修改被装饰的函数的调用方式

——如，用装饰器将add()函数变为减法函数，但是add()还是认为自己是个加法函数。

装饰器的知识储备：

　　1.函数即“变量”

　　2.高阶函数

　　3.嵌套函数

高阶函数+嵌套函数-->装饰器

1.函数即“变量”

函数即“变量”在内存中的存储引用和清空机制：

#本段代码是为了说明函数即变量，另外函数是如何在内存中存储，调用和清除的。
#第一段代码：
def foo():
    print('in the foo')
    bar()

foo()  #调用foo(),在内存中由于没有bar的函数体，也没有定义相应的函数bar，所以会报错:NameError: name 'bar' is not defined

#第二段代码：
def bar():
    print('in the bar')
def foo():
    print('in the foo')
    bar()

foo()  #调用foo(),返回"in the foo" "in the bar"

#第三段代码：
def foo():
    print('in the foo')
    bar()
def bar():
    print('in the bar')

foo()  #调用foo(),返回"in the foo" "in the bar" 


#第四段代码：
def foo():
    print('in the foo')
    bar()

foo()  # 调用foo()

def bar():
    print('in the bar')
#返回结果报错，NameError: name 'bar' is not defined

下图是关于函数和变量在内存中的存储，调用和清除的图示。

 综上所述，函数的函数体作为字符串的形式存放在内存开辟的一个空间内，当其赋值给一个函数名或变量时，在内存中存放着；当函数调用时，则执行在内存中的函数体；但函数没有函数名（如lambda函数），并且没有相应的变量与之相对应时，函数体在内存中会消失。

另外调高阶函数时，无论函数的定义的顺序，只要是在调用之前，内存中都有相应的函数体和函数对应，则调用就不会出错。如果在调用函数前，内存中并没有相应的函数或变量，则一定会报错。

2.高阶函数

满足下列两个条件之一的就是高阶函数：

　　a.把一个函数名当作实参传给另外一个函数（在不修改被装饰函数源代码的情况下为其添加功能）

　　b.返回值中包含函数名（不修改函数的调用方式）

 a实例

import time
def bar():   #被装饰的函数
    time.sleep(3)
    print('in the bar')

def test1(func):   #装饰函数，也是高阶函数，这个高阶函数实现了在不修改被装饰的函数bar的源代码的情况下为其增加了新功能
    start_time=time.time()  #在func()之前记录的是func()开始的时间
    func()
    stop_time=time.time()   #在func()之后，记录的是func()运行结束的时间
    print('the func run time is %s'%(stop_time-start_time))   #统计func()运行的总时长

test1(bar)

返回：

b实例：

import time
def bar():
    time.sleep(3)
    print('in the bar')

def test2(func):
    print(func)
    return func

bar=test2(bar)   #将函数bar的门牌号取下另外赋值，bar代表的是test2(bar)
bar()  #函数bar的调用方式未发生变化

返回：

3.嵌套函数

定义：在一个函数体内创建另外一个函数，这种函数就叫内嵌函数(基于python支持静态嵌套域)

表现的形式一定是在def函数下继续嵌套定义def函数。如下面的实例：

def foo():
    print('in the foo')
    def bar():
        print('in the bar')
    bar() #嵌套函数中想要通过foo()直接调用内部嵌套的函数，必须在内部调用bar()

foo()

 返回：

以上这个案例仅仅是嵌套函数。在函数内想要通过调用最外层的函数自动触发内部定义的函数需要在内部的最外层调用内层的函数。并且调用是逐层调用的，在上面的案例中因为仅有两层，所以仅调用了内部的bar().

 写一个装饰器：

import time
def timer(func):    #timer(test1)  高阶函数+嵌套函数==>装饰器
    def deco():
        start_time=time.time()
        func()   #run test1()
        stop_time=time.time()
        print('the func run time is %s'%(stop_time-start_time))
    return deco  #在函数timer(func)中直接返回deco，返回deco的内存地址，供test1调用。

@timer  #等价于test1=timer(test1)
def test1():  #函数的源代码不变
    time.sleep(3)
    print('in the test1')

test1() #函数的调用方式不变

 通过debugger断点，上面这个简单的装饰器的执行顺序为：

1.执行import time

2.def timer(func):

3.@timer  #调用装饰器

4.def deco():   #执行装饰器timer()，先执行def deco(),再执行return deco
5.return deco  #返回deco的内存地址

6.test1()  #调用函数test1()
8.start_time=time.time()   #开始执行传入的deco内存地址的内容，执行deco()的代码
9.func()   #调用test1()，执行test1()
10.time.sleep(3)   #执行test1()
11.print('in the test1')  #执行test1()
12.stop_time=time.time()   #执行test1()完毕，回到deco()，执行deco后面的命令
13.print('the func run time is %s'%(stop_time-start_time))
结束。

优化版（针对不同函数之间不同参数设定）：

import time
def timer(func):    #timer(test1)  高阶函数+嵌套函数==>装饰器
    def deco(*args,**kwargs):   #在deco上传入不固定参数
        start_time=time.time()
        func(*args,**kwargs)  #调用不固定参数的函数
        stop_time=time.time()
        print('the func run time is %s'%(stop_time-start_time))
    return deco  #在函数timer(func)中直接返回deco，返回deco的内存地址，供test1调用。

  #等价于test1=timer(test1)
@timer
def test1():  #函数的源代码不变
    time.sleep(3)
    print('in the test1')

@timer
def test2(name):
    print('test2:',name)

test1() #函数的调用方式不变
test2('Zoe')

 只是优化了参数，执行顺序和上面的装饰器一致。

终极版：

'''需求：
一个网站的页面代表一个函数，现在设定指定数量的页面需要验证登录'''

import time

#定义auth装饰器，用于页面登陆
user,passwd='zoe','123456'
def auth(auth_type):
    print('auth func',auth_type)
    def outer_wrapper(func):
        def wrapper(*args, **kwargs):
            print('wrapper func args',)
            if auth_type=='local':
                username = input('Username:'.strip())
                password = input('Password:'.strip())
                if user == username and passwd == password:
                    print('33[32;1m User has passed authentication 33[0m')
                    return func(*args, **kwargs)
                else:
                    exit('33[32;1m Invalid 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')
def home():
    print('welcome to home page')
    return 'from home'

#bbs论坛，需要登陆
@auth(auth_type='ldap')
def bbs():
    print('welcome to bbs page')

index()
home()
bbs()

 用调用'@auth(auth_type='local') def home()'来debugger：

1.import time
2.user,passwd='zoe','123456' 

3.def auth(auth_type):  
4.@auth(auth_type='local')  #调用装饰器，输入参数auth_type='local'

5.    print('auth type',auth_type)
6.    def outer_wrapper(func):
7.    return outer_wrapper

8.        def wrapper(*args,**kwargs):
9.        return wrapper

10.home()

11.            print('wrapper fun args')
12.            if auth_type=='local':
13.                username=input('username:'.strip())
14.                password=input('password:'.strip()) 
15.            print('成功登陆')