百万年薪python之路 -- 装饰器

Posted 2020-11-10 zhangchaoyin

装饰器

1.1 开放封闭原则

开放封闭原则具体定义是这样：

1.对扩展是开放的

我们说，任何一个程序，不可能在设计之初就已经想好了所有的功能并且未来不做任何更新和修改。所以我们必须允许代码扩展、添加新功能。

2.对修改是封闭的

因为我们写的一个函数，很有可能已经交付给其他人使用了，如果这个时候我们对函数内部进行修改，或者修改了函数的调用方式，很有可能影响其他已经在使用该函数的用户。

定义：在不改变原被装饰的函数的源代码以及调用方式下，为其添加额外的功能。

实现真正的开放封闭原则：装饰器。

运用闭包原理:

import time
def index():
    time.sleep(2)  # 模拟一下网络延迟以及代码的效率
    print('这是一个主页')

def access_index(name):
    time.sleep(3)  # 模拟一下网络延迟以及代码的效率
    print(f'欢迎访问{name}主页')

套一层最外面的函数timer，然后将里面的inner函数名作为最外面的函数的返回值

def timer(func):  # func = index
    def inner():
        start_time = time.time()
        func()
        end_time = time.time()
        print(f'此函数的执行效率为{end_time-start_time}')
    return inner
# f = timer(index)
# f()

我们分析一下代码，代码执行到这一行：f = timer(index) 先执行谁？看见一个等号先要执行等号右边， timer(index) 执行timer函数将index函数名传给了func形参。内层函数inner执行么？不执行，inner函数返回 给f变量。所以我们执行f() 就相当于执行inner闭包函数。 f(),这样既测试效率又执行了原函数，有没有问题？当然有啦！！我们要解决原函数执行方式不改变的问题，怎么做？ 所以你可以把 f 换成 index变量就完美了！ index = timer(index) 特别要注意 函数外面的index实际是inner函数的内存地址而不是index函数。这个timer就是最简单版本装饰器，在不改变原index函数的源码以及调用方式前提下，为其增加了额外的功能，测试执行效率。

1.2标准版装饰器

def wrapper(func):
    def inner(*args,**kwargs):
        '''执行被装饰函数之前的操作'''
        ret = func(*args,**kwargs)
        '''执行被装饰函数之后的操作'''
        return ret
    return inner

import time
def wrapper(f):
    def inner(*args,**kwargs):
        start = time.time()     #调用函数之前的操作
        f(*args,**kwargs)
        end = time.time()
        print(end - start)  #调用函数之后的操作
    return inner

def func(*args,**kwargs):
    time.sleep(0.5)
    print(f"{args[0]}暴打{args[1]}页面!")

func = wrapper(func)
func("章超印","煞笔周道镕")

语法糖:@xxx

import time
def wrapper(f):
    def inner(*args,**kwargs):
        start = time.time()     #调用函数之前的操作
        f(*args,**kwargs)
        end = time.time()
        print(end - start)  #调用函数之后的操作
    return inner

@wapper     # 等于 func = wapper(func)
def func(*args,**kwargs):
    time.sleep(0.5)
    print(f"{args[0]}暴打{args[1]}页面!")

# func = wapper(func)
func("章超印","煞笔周道镕")

带参数的装饰器:

在装饰器的基础上再套一层

你现在要完成的就是你的装饰器要分情况去判断账号和密码，不同的函数用的账号和密码来源不同。 但是你之前写的装饰器只能接受一个参数就是函数名，所以你写一个可以接受参数的装饰器。

dic = {
    "flag":False,
    "username":None

}
msg ="""
QQ
微信
抖音
邮箱
>>>
"""
choose = input(msg).upper()
def auth(argv):
    def wrapper(func):
        def inner(*args, **kwargs):
            if dic["flag"]:
                foo(*args, **kwargs)
            else:
                if argv == "QQ":
                    print("欢迎来到QQ!")
                    user = input("username:")
                    pwd = input("password:")
                    if user == "zcy1" and pwd == "123":
                        dic["flag"] = True
                        dic["username"] = user
                elif argv == "微信":
                    print("欢迎来到微信!")
                    user = input("username:")
                    pwd = input("password:")
                    if user == "zcy2" and pwd == "1234":
                        dic["flag"] = True
                        dic["username"] = user
                elif argv == "抖音":
                    print("欢迎来到抖音!")
                    user = input("username:")
                    pwd = input("password:")
                    if user == "zcy3" and pwd == "12345":
                        dic["flag"] = True
                        dic["username"] = user
                else:
                    print("欢迎来到邮箱!")
                    user = input("username:")
                    pwd = input("password:")
                    if user == "zcy4" and pwd == "123456":
                        dic["flag"] = True
                        dic["username"] = user
            ret = func(*args, **kwargs)
            return ret
        return inner
    return wrapper

@auth(choose)
# wrapper = auth(choose)
# foo = wrapper()
def foo():
    return "我不管,章超印超帅!"


# @auth(choose)  等于下面的两行
# wrapper = auth(choose)
# foo = wrapper()
print(foo())

@auth(‘choose‘) :分两步：

第一步先执行auth(‘choose‘)函数，得到返回值wrapper

第二步@与wrapper结合，形成装饰器@wrapper然后在依次执行。

这样就是带参数的装饰器，参数可以传入多个

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

被装饰的函数正上方有多个装饰器,先执行离被装饰函数最近的装饰器

我们现在知道标准装饰器和带参数的装饰器,我们来看看多个装饰器装饰一个函数:

def wrapper1(func):
    def inner1(*args,**kwargs):
        print("这是装饰器一开始")
        func(*args,**kwargs)
        print("这是装饰器一结束")
    return inner1

def wrapper2(func):  
    def inner2(*args,**kwargs):
        print("这是装饰器二开始")
        func(*args,**kwargs)
        print("这是装饰器二结束")
    return inner2


@wrapper1  
@wrapper2  
def func():
    print("这是被装饰的函数")

func()

大家来推断一下,这个的打印结果

这是装饰器一开始
这是装饰器二开始
这是被装饰的函数
这是装饰器二结束
这是装饰器一结束

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