装饰器

目录

• 1. 开放封闭原则
• 3. 带参数的装饰器
• 4. 多个装饰器装饰一个函数

1. 开放封闭原则

扩展是开放的，增加新的功能；修改源码（修改已经实现的功能）是封闭的。
在不改变源码及调用方式的前提下额外增加新的功能。

# 版一：
import time
start_time = time.time()  #起始时间
def func():
    time.sleep(2)   #睡眠，模拟网络延迟
    print("我要飞")
func()
print(time.time()- start_time) # 打印执行世界

# 版二：
import time
def times(s):
    start_time = time.time()
    s()
    print(time.time()- start_time)
def foo():
    time.sleep(2)
    print("我要飞")
times(foo)    #改变了调用方式


# 版三（初版装饰器）：
import time
def times(s):
    def inner():
        start_time = time.time()
        s()
        print(time.time()- start_time)
    return inner
def func():
    time.sleep(1)
    print("我也要飞")
func = times(func)    # 不需改调用方式
func()

# 版四（升级）：
def wrapper(f):
    def inner(a):   #加入参数
        f(a)
    return inner    # 切记不加括号

def func(a):        # 加参数
    print(f"这是{a}的函数")
func = wrapper(func)
func("alex")


# 升级 万能传参：
import time
def wrapper(f):
    def inner(*args,**kwargs):
        start_time = time.time()
        f(*args,**kwargs)
        print(time.time() - start_time)
    return inner    # 切记不加括号

def func(*args,**kwargs):        # 加形参
    time.sleep(1)
    print(f"这是{args,kwargs}的函数")
func = wrapper(func)
func("alex",1,2,a = 3,b = 4)

def foo(*args,**kwargs):        # 加形参
    time.sleep(2)
    print(f"这是{args,kwargs}的函数")
foo = wrapper(foo)
foo("meet",1,2,a = 3,b = 4)

#语法糖   放在被装饰函数的上方
#替代func = wrapper(func) 和 foo = wrapper(foo)

import time
def wrapper(f):
    def inner(*args,**kwargs):
        start_time = time.time()
        f(*args,**kwargs)
        print(time.time() - start_time)
    return inner    # 不加括号
@wrapper   			#语法糖
def func(*args,**kwargs):        # 加形参
    time.sleep(1)
    print(f"这是{args,kwargs}的函数")
# func = wrapper(func)
@wrapper			#语法糖
def foo(*args,**kwargs):        # 加形参
    time.sleep(2)
    print(f"这是{args,kwargs}的函数")
# foo = wrapper(foo)

func("alex",1,2,a = 3,b = 4)
foo("meet",5,6,a = 7,b = 8)


# 标准版：
import time
def wrapper(f):
    def inner(*args,**kwargs):
        start_time = time.time()
        ret = f(*args,**kwargs)
        print(time.time() - start_time)
        return ret  #增加返回值
    return inner    # 切记不加括号
@wrapper  			#语法糖
def func(*args,**kwargs):        # 加形参
    time.sleep(1)
    print(f"这是{args,kwargs}的函数")
    return "这是alex的返回"
print(func("alex",1,2,a = 3,b = 4))  # 会打印"这是alex的返回"

#语法糖  放在被装饰函数的上方
#标准版的装饰器：
def wrapper(func):
    def inner(*args,**kwargs):
        '''执行被装饰函数之前的操作'''
        ret = func(*args,**kwargs)
        '''执行被装饰函数之后的操作'''
        return ret  # 返回inner(),也就是func()打印
    return inner
@wrapper    # 相当于 func = wrapper(func)
def func(*args,**kwargs)
	print(args,kwargs)
	return "返回的内容"     # 返回ret
print(func())  	# 能够打印返回值，也可以传参

3. 带参数的装饰器

#在装饰器的基础上再套一层
def auth(argv):
    def wrapper(func):
        def inner(*args,**kwargs):
            func(*args,**kwargs)
        return inner
    return wrapper
@auth()  # 可传参
def func():
    pass
func()
#解开：
"""
wrapper = auth()
func = wrapper(func)
func()
"""

#示例：实现选择不同的登录方式
login_dic = {"username": None,"flag": False}

msg = """
QQ
微信
抖音
邮箱
请输入您要选择登陆的app:
"""
chose = input(msg).upper()

def auth(argv):
    def wrapper(func):
        def inner(*args,**kwargs):
            if login_dic["flag"]:
                func(*args,**kwargs)
            else:
                if argv == "QQ":
                    print("欢迎登陆QQ")
                    user = input("username:")
                    pwd = input("password:")
                    if user == "alex" and pwd == "alex123":  # qq
                        login_dic["flag"] = True
                        login_dic["username"] = user
                        func(*args,**kwargs)
                    else:
                        print("用户名或密码错误!")
                elif argv == "微信":
                    print("欢迎登陆微信")
                    user = input("username:")
                    pwd = input("password:")
                    if user == "1351101501" and pwd == "alex":  # 微信
                        login_dic["flag"] = True
                        login_dic["username"] = user
                        func(*args, **kwargs)
                    else:
                        print("用户名或密码错误!")
                elif argv == "抖音":
                    print("来了,老弟!")
                    user = input("username:")
                    pwd = input("password:")
                    if user == "alexdsb" and pwd == "alex":  # 抖音
                        login_dic["flag"] = True
                        login_dic["username"] = user
                        func(*args, **kwargs)
                    else:
                        print("用户名或密码错误!")
                else:
                    print("欢迎登陆dab邮箱")
                    user = input("username:")
                    pwd = input("password:")
                    if user == "alexdsb@dsb.com" and pwd == "alex":  # 邮箱
                        login_dic["flag"] = True
                        login_dic["username"] = user
                        func(*args, **kwargs)
                    else:
                        print("用户名或密码错误!")

        return inner
    return wrapper
@auth(chose)
def foo():
    print("这是一个被装饰的函数")
foo()
"""
# @auth(chose) 相等于以下两行代码的解构:
# wrapper = auth(chose)
# foo = wrapper(foo)
"""

4. 多个装饰器装饰一个函数

#先执行离被装饰的函数最近的语法糖。
#小技巧:进入装饰器从上往下,走到最会一个装饰器执行被装饰的函数,退出装饰器从下往上走。

def wrapper1(f):
    def inner1(*args,**kwargs):
        print("这是第一个函数的开始！")
        f()
        print("这是第一个函数的结束！")
    return inner1
def wrapper2(f):    # f = inner3
    def inner2(*args,**kwargs):
        print("这是第二个函数的开始！")
        f()
        print("这是第二个函数的结束！")
    return inner2
def wrapper3(f):
    def inner3(*args,**kwargs):
        print("这是第三个函数的开始！")
        f()
        print("这是第三个函数的结束！")
    return inner3
@wrapper1
@wrapper2
@wrapper3
def func():
    print("这是被调用的函数！")
func()

#解开：
#func = wrapper3(func)     #func == inner3
#func = wrapper2(func)     #func == wrapper2(inner3)  func = inner2
#func = wrapper1(func)     #func == wrapper1(inner2)  func = inner1
#func()                    #inner1()


"""
这是第一个函数的开始！
这是第二个函数的开始！
这是第三个函数的开始！
这是被调用的函数！
这是第三个函数的结束！
这是第二个函数的结束！
这是第一个函数的结束！
"""