Day4-装饰器

装饰器，本质是函数，为其它函数添加附加功能。

装饰器对被装饰的函数没有任何影响，原则：

1.不能修改被装饰的函数的源代码；2.不能修改调用方式；

高阶函数+嵌套函数，实现装饰器，准备知识如下：

1.函数和变量的区别：

变量存在内存中，比如x=1 ，1存在内存中，x就是内存的门牌号。若y=x,y也是一次引用，即y也是门牌号，清除变量1的话必须清除x和y。
def test(): #定义了test函数，即函数体存在内存中，test为门牌号
      pass
test = '函数体 '

python的内存回收器由python解释器回收的，清除变量通过清除所有门牌号的方式清除。

lambda匿名函数：没有起名，正是因为没有名字，它就没有门牌号，立马被python解释器回收掉
calc=lambdax:x*3
print(calc(3))
9

总结：函数就是变量，定义一个函数，等于把函数体给了函数名。变量有内存回收机制，函数一样。
先声明再调用，只要在调用之前声明就可以正常执行。因为声明是定义函数名，把函数体存在内存中。

2.高阶函数，满足的条件：

a.把一个函数名当做实参传给另外一个函数；（不修改被装饰函数源代码的情况下为其添加功能）
b.返回值中包含函数名（不修改函数的调用方式）

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

def test1(func):
    start_time = time.time()
    func()
    stop_time=time.time()
    print("in the func run time is %s" %(start_time-stop_time))

test1(bar)
结果:
in the bar
in the func run time is -3.014805555343628

3.嵌套函数：在def函数体内再def声明一个函数，叫嵌套函数

#函数的调用
def test1():
    test2()  #函数的调用，不叫嵌套
test1()

#嵌套函数
def foo():
    print("in the foo")
    def bar():
        print("in the bar")
    bar() #局部变量必须在函数内部调用
foo()
#bar()  #这引用是不对的

4.装饰器的形成步骤

a.改变函数调用方式:正常为test1()，变为deco(test1)

需求：计算test1和test2函数运行时间

import time
def deco(func):
    start_time = time.time()
    func()
    stop_time = time.time()
    print("the func run time is %s" %(start_time-stop_time))
def test1():
    time.sleep(3)
    print("in the test1")
def test2():
    time.sleep(3)
    print("in the test2")
deco(test1) #test1代表函数/变量，而test1()表示返回test1的运行结果
deco(test2)
执行结果：
in the test1
the func run time is -3.010805130004883
in the test2
the func run time is -3.012805461883545

分析：改变了函数的调用方式，违反原则。

b.返回值调用方式：func(),变成return func

import time
def deco(func):
    start_time = time.time()
    return func #返回执行结果，下面语句就不执行了
    stop_time = time.time()
    print("the func run time is %s" %(start_time-stop_time))
def test1():
    time.sleep(3)
    print("in the test1")
def test2():
    time.sleep(3)
    print("in the test2")
test1 = deco(test1)
test1()
test2 = deco(test2)
test2()

执行结果：
in the test1
in the test2

分析：返回值调用不修改源代码和调用方式，但需求未实现。

c.加了嵌套函数：函数中定义新函数，返回新函数的变量名=内存地址=函数名，把返回值赋予一个变量，执行变量即可得到结果

import time
def timer(func):#func=test1，把test1函数作为timer函数的参数传递进去
    def deco(): #函数timer中定义新函数deco，即为函数嵌套
        start_time = time.time()
        func() #func=test1，运行func()，即为运行test1()
        stop_time = time.time()
        print("the func run time is %s"%(start_time-stop_time))
    return deco #返回deco内存地址，即为高级函数
def test1():
    time.sleep(3)
    print("in the test1")
test2 = timer(test1) #把test1()函数的内存地址test1作为参数传递给timer函数
test2() #执行test2（）函数

执行结果：
in the test1
the func run time is -3.010805130004883

d.装饰器

import time
def timer(func):
    def deco():
        start_time = time.time()
        func()
        stop_time = time.time()
        print("the fun run time is %s"%(start_time-stop_time))
    return deco

@timer #给test1增加新功能
def test1():
    time.sleep(3)
    print("in the test1")

test1() #执行deco函数时，嵌套执行的是func()函数，即test1()=func()

执行结果：
in the test1
the fun run time is -3.0118050575256348

若被修饰的函数test1带位置参数，会咋样？

@timer
def test2(name):
    time.sleep(2)
    print("in the test2",name)
test2()

执行结果：报错
TypeError: test2() missing 1 required positional argument: 'name'
分析：
test2()相当于函数timer()中的func()函数，在嵌套函数deco()中执行时func()没有位置参数name，所以报错。

e.装饰器：举例说明带可变参数和不带参数

import time
def timer(func):
    def deco(*args,**kwargs):
        start_time = time.time()
        func(*args,**kwargs)
        stop_time = time.time()
        print("the fun run time is %s"%(stop_time-start_time))
    return deco

@timer
def test1():
    time.sleep(2)
    print("in the test1")
@timer
def test2(name,age):
    time.sleep(2)
    print("in the test2",name,age)

test1()
test2('alex',22)

执行结果：
in the test1
the fun run time is 2.0124034881591797
in the test2 alex 22
the fun run time is 2.0124034881591797

总结：装饰器又叫语法糖。

用途：公司有网站很多页面，一个页面一个函数，现在100个页面里有20个页面需要登录才能看到，所以在20个页面函数里加上验证功能才能看到。

需求1：编写一个登陆认证程序，主页index不需要登录，用户自己的home和bbs需要登录

#!/usr/bin/env python
import time
user,passwd = 'alex','abc123'
def auth(func):
    def wrapper(*args,**kwargs):
        username = input("Username:").strip()
        password = input("Password:").strip()

        if user == username and passwd == password:
            print("33[32:1mGreat,user got it!33[0m")
            return func(*args,**kwargs)
        else:
            exit("33[31:1mInvalid username or password33[0m")
            #exit()
    return wrapper

def index():
    print("Welcome to index page.")

@auth
def home():
    print("Great,home page got it!")
    return "from home"

@auth
def bbs():
    print("Great,bbs page got it!")

index()
home()
bbs()

执行结果：
Welcome to index page.
Username:alex #执行home()需要输入用户名和密码
Password:abc123
[32:1mGreat,user got it!
Great,home page got it!
Username:alex  #执行bbs时需要再次输入用户名和密码
Password:abc123
[32:1mGreat,user got it!
Great,bbs page got it!

需求2，终极版：home实现本地认证，bbs实现ldap认证

import time
user,passwd = 'alex','abc123'
def auth(auth_type):
    print("auth func:",auth_type)
    def out_wrapper(func):
        def wrapper(*args,**kwargs):
            print("wrapper func:",*args,**kwargs)
            if auth_type == "local":
                username = input("Username:").strip()
                password = input("Password:").strip()

                if user == username and passwd == password:
                    print("33[32:1mGreat user got it!33[0m")
                    return func(*args,**kwargs)
                else:
                    exit("33[31:1mInvaild username or password33[0m")
            elif auth_type == "ldap":
                print("搞毛线ldap，不会")
        return wrapper
    return out_wrapper

def index():
    print("Welcome to index page.")

@auth(auth_type="local")#这句话相当于home() = wrapper(),接下来home才开始执行
def home():
    print("Welcome to home page.")
    return "From home"

@auth(auth_type="ldap")
def bbs():
    print("Welcome to bbs page.")

index()
home()
bbs()

执行结果：
auth func: local
auth func: ldap
Welcome to index page.
wrapper func:
Username:alex
Password:abc123
[32:1mGreat user got it!
Welcome to home page.
wrapper func:
搞毛线ldap，不会