装饰器

Posted 2021-12-18 chenwang-23

1、装饰器介绍与简单实现

1.1、什么是装饰器

? 器：指的是具备某一个功能的工具

? 装饰：指的是为被装饰对象添加新功能

? 装饰器就是用来为被装饰对象添加新功能的工具。

? 注意：装饰器本身可以是任意可调用对象，被装饰的对象也可以是任意可调用对象。

1.2、为何要用装饰器

? 开放封闭原则：封闭指的是对修改封闭，对扩展开放。

? 装饰器的实现必须遵循两大原则：

? 1、不修改被装饰对象的源代码。

? 2、不修改被装饰对象的调用方式。

1.3、怎么用装饰器

# 给index函数添加上一个计时功能
import time
def index():
    print("welcome to index page")
    time.sleep(3)

def outter(func):   # func=最原始的那个index的内存地址
    def wrapper():
        start = time.time()
        func()
        stop = time.time()
        print("run time is %s"%(stop - start))
    return wrapper

index = outter(index)  # index = outter(最原始的那个index的内存地址) # index = wrapper的内存地址
index()  # wrapper的内存地址()

2、装饰器升级版

? 考虑到某些函数会有返回值和参数，而上面的简易版装饰器并不能实现这两个条件，所以：

import time
def home(name):
    print("Welcome %s to home page"%name)
    time.sleep(2)
    return 123

def timmer(func):  # func=最原始的那个index的内存地址
    def wrapper(*args,**kwargs):  # args = ("egon",) kwargs = 
        start = time.time()
        res = func(*args,**kwargs)  # 最原始的那个home函数的内存地址("egon")
        stop = time.time()
        print("run time is %s"%(stop - start))
        return res
    return wrapper

home = timmer(home)  # home=timmer(最原始那个home函数的内地址)  # home=wrapper函数的内地址
res = home("egon")  # res=wrapper函数的内存地址('egon')
print(res)

3、装饰器的语法糖

? 装饰器的语法糖：在被装饰对象正上方单独一行写@装饰器的名字。

? 运行原理：

? python解释器一旦运行到@装饰器的名字，就会调用装饰器，然后将被装饰函数的内存地址当作参数传给装饰器，最后将装饰器调用的结果赋值给原函数名。

import time

def timmer(func):  # func=最原始的那个index的内存地址
    def wrapper(*args,**kwargs):  # args = ("egon",) kwargs = 
        start = time.time()
        res = func(*args,**kwargs)  # 最原始的那个home函数的内存地址("egon")
        stop = time.time()
        print("run time is %s"%(stop - start))
        return res
    return wrapper

# 注意：语法糖要写在装饰器的后面，被装饰对象的前面
@timmer  # index = timmer(index)
def home(name):
    print("Welcome %s to home page"%name)
    time.sleep(2)
    return 123

res = home("egon")  # res=wrapper函数的内地址('egon')
print(res)

装饰器模板

def outter(func):
    def wrapper(*args,**kwargs):
        # 在调用函数前加功能
        res = func(*args,**kwargs)
        # 在调用函数后加功能
        return res
    return wrapper
@outter
def f():
    pass
f()

4、小练习：登录认证功能装饰器

def auth(func):
    def wrapper(*args,**kwargs):
        inp_user = input('please input your username: ').strip()
        inp_pwd = input('please input your password: ').strip()
        if inp_user == 'egon' and inp_pwd == '123':
            print('login successfull')
            res=func(*args,**kwargs) # 调用最原始的那个/也就是被装饰的那个函数
            return res
        else:
            print('username or password error')
    return wrapper

@auth # index=auth(index) #index=wrapper
def index():
    print('welcome to index page')
    time.sleep(3)
index() #wrapper()

5、叠加多个装饰器

# 解释@语法的时候是自下而上运行
# 而执行装饰器内的那个wrapper函数时的是自上而下
import time
def outter1(func1):  # func1=wrapper2
    print('outter1')
    def wrapper1(*args,**kwargs):
        print('wrapper1')
        res1=func1(*args,**kwargs)  # res1=wrapper2(*args,**kwargs)
        return res1
    return wrapper1

def outter2(func2):  # func2=最原始的那个index的内存地址
    print('outter2')
    def wrapper2(*args,**kwargs):
        print('wrapper2')
        res2=func2(*args,**kwargs)
        return res2
    return wrapper2

@outter1  # index=outter1(wrapper2) #index=wrapper1
@outter2  # outter2(最原始的那个index的内存地址) ===> wrapper2
def index():
    print('welcome to index page')
    time.sleep(3)
index()  #wrapper1()

'''
运行结果如下：
outter2
outter1
wrapper1
wrapper2
'''

6、有参装饰器

import time

current_user='username':None

def login(engine='file'): #engine='mysql'
    def auth(func): #func=最原始那个index的内存地址
        def wrapper(*args,**kwargs):
            if current_user['username']:
                print('已经登录过了,无需再次登陆')
                res=func(*args,**kwargs)
                return res

            if engine == 'file':
                inp_user = input('please input your username: ').strip()
                inp_pwd = input('please input your password: ').strip()
                if inp_user == 'egon' and inp_pwd == '123':
                    print('login successfull')
                    current_user['username']=inp_user # 在登陆成功之后立刻记录登录状态
                    res=func(*args,**kwargs) # res=最原始那个index的内存地址(*args,**kwargs)
                    return res
                else:
                    print('username or password error')
            elif engine == 'mysql':
                print('基于mysql的认证机制')
            elif engine == 'ldap':
                print('基于ldap的认证机制')
            else:
                print('无法识别的认证源')
        return wrapper
    return auth

@login('file')  #@auth # index=auth(最原始那个index的内存地址) #index=wrapper
def index():
    print('welcome to index page')
    time.sleep(3)

@login('file')
def home(name):
    print('welcome %s to home page' %name)
    time.sleep(2)
    return 123


index() #wrapper()
res=home('egon')
print(res)

有参装饰器模板

def outter1(x,y,z):
    def outter2(func):
        def wrapper(*args,**kwargs):
            res=func(*args,**kwargs)
            return res
        return wrapper
    return outter2

无参装饰器模板

def outter(func):
    def wrapper(*args,**kwargs):
        res=func(*args,**kwargs)
        return res
    return wrapper

7、from functools import wraps

? 在使用装饰器时，被装饰好的函数在调用时实际上是在调用wrapper函数，而wrapper函数并不具有原函数的所有名称空间内的值，比如函数名(func._name__)、函数功能(func._doc__)等，这时后就要用到from functools import wraps。

#wraps装饰器应该加到装饰器最内层的函数上
from functools import wraps
import time

def deco(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        res = func(*args, **kwargs)
        return res
    # wrapper.__name__=func.__name__
    # wrapper.__doc__=func.__doc__
    return wrapper

@deco #index=deco(index) #index=wrapper函数的内存地址
def index():
    """
    index 功能
    """
    print('welcome to index page')
    time.sleep(3)
    
print(index.__name__)
print(index.__doc__)