Python学习—装饰器的力量

这篇具有很好参考价值的文章主要介绍了Python学习—装饰器的力量。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

Python学习—装饰器的力量

作为许多语言都存在的高级语法之一,装饰器是你必须掌握的知识点。

Python的装饰器(Decorator)允许你扩展和修改可调用对象(函数、方法和类)的行为,而无需永久修改可调用的对象本身。进一步解释就是装饰器(Decorator):从字面上理解,就是装饰对象的器件。可以在不修改原有代码的情况下,为被装饰的对象增加新的功能或者附加限制条件或者帮助输出。装饰器有很多种,有函数的装饰器,也有类的装饰器。装饰器在很多语言中的名字也不尽相同,它体现的是设计模式中的装饰模式,强调的是开放封闭原则。装饰器的语法是将@装饰器名,放在被装饰对象上面。

@dec
def func():    
    pass

在进行装饰器的介绍之前,我们必须先明确几个概念和原则:

​ 首先,Python程序是从上往下顺序执行的,而且碰到函数的定义代码块是不会立即执行的,只有等到该函数被调用时,才会执行其内部的代码块。

def foo():    
    print("foo函数被运行了!")
#如果就这么样,foo里的语句是不会被执行的。
#程序只是简单的将定义代码块读入内存中。
# foo()    只有调用了,才会执行

​ 其次,由于顺序执行的原因,如果你真的对同一个函数定义了两次,那么,后面的定义会覆盖前面的定义。因此,在Python中代码的放置位置是有区别的,不能随意摆放,通常函数体要放在调用的语句之前。

def foo():    
    print("我是上面的函数定义!")
    
foo()

def foo():    
    print("我是下面的函数定义!")
    
foo()
#----------------
#执行结果:
我是上面的函数定义!
我是下面的函数定义!

​ 然后,我们还要先搞清楚几样东西:函数名、函数体、返回值,函数的内存地址、函数名加括号、函数名被当作参数、函数名加括号被当作参数、返回函数名、返回函数名加括号。

def outer(func):    
    def inner():        
        print("我是内层函数!")    
    return inner

def foo():    
    print("我是原始函数!")
    
outer(foo)
outer(foo())

运行结果如下:

D:\anaconda3\python.exe D:/pythonProject/明日科技网络爬虫/aiohttp复现.py
我是原始函数!

Process finished with exit code 0
  • 函数名:foo、outer、inner

  • 函数体:函数的整个代码结构

  • 返回值:return后面的表达式

  • 函数的内存地址:id(foo)、id(outer)等等

  • 函数名加括号:对函数进行调用,比如foo()、outer(foo)

  • 函数名作为参数:outer(foo)中的foo本身是个函数,但作为参数被传递给了outer函数

  • 函数名加括号被当做参数:其实就是先调用函数,再将它的返回值当做别的函数的参数,例如outer(foo())

  • 返回函数名:return inner

  • 返回函数名加括号:return inner(),其实就是先执行inner函数,再将其返回值作为别的函数的返回值。

如果你能理解函数也是一个对象,就能很容易地理解上面的概念。

有了这些基本的概念,我们就可以通过一个实例来讲解Python中装饰器的作用了。

下例是针对函数的装饰器。

虚拟场景

有一个大公司,下属的基础平台部负责内部应用程序及API的开发。另外还有上百个业务部门负责不同的业务,这些业务部门各自调用基础平台部提供的不同函数,也就是API处理自己的业务,情况如下:

# 基础平台部门开发了上百个函数API
def f1():    
    print("业务部门1的数据接口......")
def f2():    
    print("业务部门2的数据接口......")
def f3():    
    print("业务部门3的数据接口......")
def f100():    
    print("业务部门100的数据接口......")
#各部门分别调用自己需要的API
f1()
f2()
f3()
f100()

运行结果如下:

D:\anaconda3\python.exe D:/pythonProject/明日科技网络爬虫/aiohttp复现.py
业务部门1的数据接口......
业务部门2的数据接口......
业务部门3的数据接口......
业务部门100的数据接口......

Process finished with exit code 0

公司还在创业初期时,基础平台部就开发了这些函数。由于各种原因,比如时间紧,比如人手不足,比如架构缺陷,比如考虑不周等等,没有为函数的调用进行安全认证。现在,公司发展壮大了,不能再像初创时期的“草台班子”一样将就下去了,基础平台部主管决定弥补这个缺陷,于是(纯属虚构场景):

第一天:主管叫来了一个运维工程师,工程师跑上跑下逐个部门进行通知,让他们在代码里加上认证功能,然后,当天他被开除了。

第二天:主管又叫来了一个运维工程师,工程师用shell写了个复杂的脚本,勉强实现了功能。但他很快就回去接着做运维了,不会开发的运维不是好运维…

第三天:主管叫来了一个python自动化开发工程师。哥们是这么干的,只对基础平台的代码进行重构,让N个业务部门无需做任何修改。这哥们很快也被开了,连运维也没得做。

def f1():    
    #加入认证程序代码    
    print("业务部门1数据接口......")
def f2():   
    # 加入认证程序代码    
    print("业务部门2数据接口......")
def f3():    
    # 加入认证程序代码    
    print("业务部门3数据接口......")
def f100():    #
    加入认证程序代码    
    print("业务部门100数据接口......")
#各部门分别调用
f1()
f2()
f3()
f100()

第四天:主管又换了个开发工程师。他是这么干的:定义个认证函数,在原来其他的函数中调用它,代码如下。

def login():    
    print("认证成功!")
def f1():    
    login()    
    print("业务部门1数据接口......")
def f2():    
    login()    
    print("业务部门2数据接口......")
def f3():    
    login()    
    print("业务部门3数据接口......")
def f100():    
    login()    
    print("业务部门100数据接口......")
#各部门分别调用
f1()
f2()
f3()
f100()

但是主管依然不满意,不过这一次他解释了为什么。主管说:写代码要遵循开放封闭原则,简单来说,已经实现的功能代码内部不允许被修改,但外部可以被扩展。如果将开放封闭原则应用在上面的需求中,那么就是不允许在函数f1 、f2、f3…f100的内部进行代码修改,但是可以在外部对它们进行扩展。

第五天:已经没有时间让主管找别人来干这活了,他决定亲自上阵,使用装饰器完成这一任务,并且打算在函数执行后再增加个日志功能。主管的代码如下:

def outer(func):    
    def inner():        
        print("认证成功!")        
        result = func()        
        print("日志添加成功")        
        return result   
    return inner
@outerdef 
f1():    
    print("业务部门1数据接口......")
@outerdef 
f2():    
    print("业务部门2数据接口......")
    
@outer
def f3():    
    print("业务部门3数据接口......")
@outer
def f100():    
    print("业务部门100数据接口......")
#各部门分别调用
f1()
f2()
f3()
af100()

使用装饰器@outer,也是仅需对基础平台的代码进行拓展,就可以实现在其他部门调用函数API之前都进行认证操作,在操作结束后保存日志,并且其他业务部门无需对他们自己的代码做任何修改,调用方式也不用变。

装饰器机制分析

下面以f1函数为例,对装饰器的运行机制进行分析:

def outer(func):    
    def inner():        
        print("认证成功!")        
        result = func()        
        print("日志添加成功")        
        return result    
    return inner


@outerdef f1():    
    print("业务部门1数据接口......")

  1. 程序开始运行,从上往下解释,读到def outer(func):的时候,发现这是个“一等公民”函数,于是把函数体加载到内存里,然后过。

  2. 读到@outer的时候,程序被@这个语法糖吸引住了,知道这是个装饰器,按规矩要立即执行的,于是程序开始运行@后面那个名字outer所定义的函数。

  3. 程序返回到outer函数,开始执行装饰器的语法规则。规则是:**被装饰的函数的名字会被当作参数传递给装饰函数。**装饰函数执行它自己内部的代码后,会将它的返回值赋值给被装饰的函数。原来的f1函数被当做参数传递给了func,而f1这个函数名之后会指向inner函数。

    Python学习—装饰器的力量

注意:@outer和@outer()有区别,没有括号时,outer函数依然会被执行,这和传统的用括号才能调用函数不同,需要特别注意!

另外,是f1这个函数名(而不是f1()这样被调用后)当做参数传递给装饰函数outer,也就是:func = f1,@outer等于outer(f1),实际上传递了f1的函数体,而不是执行f1后的返回值。

还有,outer函数return的是inner这个函数名,而不是inner()这样被调用后的返回值。

4.程序开始执行outer函数内部的内容,一开始它又碰到了一个函数inner,inner函数定义块被程序观察到后不会立刻执行,而是读入内存中(这是默认规则)。

5.再往下,碰到return inner,返回值是个函数名,并且这个函数名会被赋值给f1这个被装饰的函数,也就是f1 = inner。根据前面的知识,我们知道,此时f1函数被新的函数inner覆盖了(实际上是f1这个函数名更改成指向inner这个函数名指向的函数体内存地址,f1不再指向它原来的函数体的内存地址),再往后调用f1的时候将执行inner函数内的代码,而不是先前的函数体。那么先前的函数体去哪了?还记得我们将f1当做参数传递给func这个形参么?func这个变量保存了老的函数在内存中的地址,通过它就可以执行老的函数体,你能在inner函数里看到result = func()这句代码,它就是这么干的!

6.接下来,还没有结束。当业务部门,依然通过f1()的方式调用f1函数时,执行的就不再是旧的f1函数的代码,而是inner函数的代码。在本例中,它首先会打印个“认证成功”的提示,很显然你可以换成任意的代码,这只是个示例;然后,它会执行func函数并将返回值赋值给变量result,这个func函数就是旧的f1函数;接着,它又打印了“日志保存”的提示,这也只是个示例,可以换成任何你想要的;最后返回result这个变量。我们在业务部门的代码上可以用r = f1()的方式接受result的值。

7.以上流程走完后,你应该看出来了,在没有对业务部门的代码和接口调用方式做任何修改的同时,也没有对基础平台部原有的代码做内部修改,仅仅是添加了一个装饰函数,就实现了我们的需求,在函数调用前进行认证,调用后写入日志。这就是装饰器的最大作用。

那么为什么我们要搞一个outer函数一个inner函数这么复杂呢?一层函数不行吗?

答:请注意,@outer这句代码在程序执行到这里的时候就会自动执行outer函数内部的代码,如果不封装一下,在业务部门还未进行调用的时候,就执行了,这和初衷不符。当然,如果你对这个有需求也不是不行。请看下面的例子,它只有一层函数。

def outer(func):    
    print("认证成功!")    
    result = func()    
    print("日志添加成功")    
    return result

@outerdef f1():    
    print("业务部门1数据接口......")
    
    
# 业务部门并没有调用f1函数------------------------------------------
执行结果:
认证成功!
业务部门1数据接口......
日志添加成功

看见了吗?我们只是定义好了装饰器,业务部门还没有调用f1函数呢,程序就把工作全做了。这就是为什么要封装一层函数的原因。

细心的同学可能已经发现了,上面的例子中,f1函数没有参数,在实际情况中肯定会需要参数的,函数的参数怎么传递的呢?

def outer(func):    
    def inner(username):        
        print("认证成功!")        
        result = func(username)        
        print("日志添加成功")        
        return result    
    return inner

@outerdef f1(name):    
    print("%s 正在连接业务部门1数据接口......"%name)
    
# 调用方法
f1("jack")

在inner函数的定义部分也加上一个参数,调用func函数的时候传递这个参数,很好理解吧?可问题又来了,那么另外一个部门调用的f2有2个参数呢?f3有3个参数呢?你怎么传递?很简单,我们有*args和**kwargs嘛!号称“万能参数”!简单修改一下上面的代码:

def outer(func):    
    def inner(*args, **kwargs):        
        print("认证成功!")         
        result = func(*args, **kwargs)        
        print("日志添加成功")        
        return result    
    return inner

@outerdef f1(name,age):    
    print("%s 正在连接业务部门1数据接口......" %name)
# 调用方法
f1("老王", 58)

运行结果如如下:

D:\anaconda3\python.exe D:/pythonProject/明日科技网络爬虫/aiohttp复现.py
认证成功!
老王 正在连接业务部门1数据接口......
日志添加成功

Process finished with exit code 0

介绍到这里,装饰器的基本概念和初级使用方法,你应该有了一定的了解了。那么进一步思考一下,一个函数可以被多个函数装饰吗?可以的!看下面的例子!

def outer1(func):    
    def inner(*args,**kwargs):        
        print("认证成功!")        
        result = func(*args,**kwargs)        
        print("日志添加成功")        
        return result    
    return inner

def outer2(func):    
    def inner(*args,**kwargs):        
        print("一条欢迎信息。。。")        
        result = func(*args,**kwargs)        
        print("一条欢送信息。。。")        
        return result    
    return inner

@outer1
@outer2
def f1(name,age):    
    print("%s 正在连接业务部门1数据接口......"%name)
    
# 调用方法
f1("老王", 58)

运行结果如下:

D:\anaconda3\python.exe D:/pythonProject/明日科技网络爬虫/aiohttp复现.py
认证成功!
一条欢迎信息。。。
老王 正在连接业务部门1数据接口......
一条欢送信息。。。
日志添加成功

Process finished with exit code 0

更更进一步,装饰器自己可以有参数吗?可以的!看下面的例子:

# 认证函数
def auth(request, kargs):
    print("认证成功!")


# 日志函数
def log(request, kargs):
    print("日志添加成功")


# 装饰器函数。接收两个参数,这两个参数应该是某个函数的名字。
def Filter(auth_func, log_func):
    # 第一层封装,f1函数实际上被传递给了main_fuc这个参数
    def outer(main_func):
        # 第二层封装,auth和log函数的参数值被传递到了这里
        def wrapper(request, kargs):
            # 下面代码的判断逻辑不重要,重要的是参数的引用和返回值
            before_result = auth(request, kargs)
            if (before_result != None):
                return before_result

            main_result = main_func(request, kargs)
            if(main_result != None):
                return main_result

            after_result = log(request, kargs)
            if (after_result != None):
                return after_result

        return wrapper
    return outer


# 注意了,这里的装饰器函数有参数哦,它的意思是先执行filter函数
# 然后将filter函数的返回值作为装饰器函数的名字返回到这里,所以,
# 其实这里,Filter(auth,log) = outer , @Filter(auth,log) =  @outer

@Filter(auth, log)
def f1(name, age):
    print("%s 正在连接业务部门1数据接口......" % name)


# 调用方法
f1("老王", 58)

运行结果如如下:

D:\anaconda3\python.exe D:/pythonProject/明日科技网络爬虫/aiohttp复现.py
认证成功!
老王 正在连接业务部门1数据接口......
日志添加成功

Process finished with exit code 0

装饰器的学问博大精深,需要我们不断的学习思考。官方文档和框架源码是比较好的学习对象。

的装饰器函数有参数哦,它的意思是先执行filter函数

然后将filter函数的返回值作为装饰器函数的名字返回到这里,所以,

其实这里,Filter(auth,log) = outer , @Filter(auth,log) = @outer

@Filter(auth, log)
def f1(name, age):
print(“%s 正在连接业务部门1数据接口…” % name)

调用方法

f1(“老王”, 58)


运行结果如如下:

```shell
D:\anaconda3\python.exe D:/pythonProject/明日科技网络爬虫/aiohttp复现.py
认证成功!
老王 正在连接业务部门1数据接口......
日志添加成功

Process finished with exit code 0

装饰器的学问博大精深,需要我们不断的学习思考。官方文档和框架源码是比较好的学习对象。文章来源地址https://www.toymoban.com/news/detail-495848.html

到了这里,关于Python学习—装饰器的力量的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • CBV添加装饰器的三种方式

    2024年02月08日
    浏览(35)
  • CocosCreator3.8研究笔记(六)CocosCreator 脚本装饰器的理解

    一、什么是装饰器? 装饰器是TypeScript脚本语言中的概念。 TypeScript的解释:在一些场景下,我们需要额外的特性来支持标注或修改类及其成员。装饰器(Decorators)为我们在类的声明及成员上通过元编程语法添加标注提供了一种方式。 在TypeScript中,装饰器分为:类装饰器、属

    2024年02月09日
    浏览(40)
  • Next.js使用装饰器decorator 解决[作为表达式调用时,无法解析类修饰器的签名。]

    Next.js 会自动检测 jsconfig.json 或 tsconfig.json 中的 experimentalDecorators 。 tsconfig.json 然后重启服务 否则装饰器无法识别 不声明的话vscode 执行 ts检测 也会报错 作为表达式调用时,无法解析类修饰器的签名。 支持的四种装饰器 类装饰器 也可以这样写 下方写法可以将属性写在当前

    2024年02月14日
    浏览(44)
  • 系统学习Python——装饰器:类装饰器-[初探类装饰器和元类]

    分类目录:《系统学习Python》总目录 函数装饰器是如此有用,以至于Python2.X和Python3.X都扩展了这一模式,允许装饰器应用于类和函数。简而言之,类装饰器类似于函数装饰器,但它们是在一条 class 语句的末尾运行,并把一个类名重新绑定到一个可调用对象。同样,它们可以

    2024年02月19日
    浏览(35)
  • 系统学习Python——装饰器:函数装饰器-[添加装饰器参数:基础知识]

    分类目录:《系统学习Python》总目录 前面文章介绍的计时器装饰器有效运行,但是如果它可配置性更强的话,就会更好一一一例如提供一个输出标签并且可以打开或关闭跟踪消息,这些在一个多用途工具中可能很有用。装饰器参数在这里派上了用场:对它们适当编写后,我们

    2024年02月22日
    浏览(36)
  • 【Python机器学习】分类器的不确定估计——预测概率

            predict_proba的输出是每个类别的概率,通常比decision_function的输出更容易理解,对于二分类问题,它的形状始终是(n_samples,2)。         可以从结果看到,每行的第一个元素是第一个类别的估计概率,第二个元素是第二个类别的估计概率,两个类别的概率之和始终

    2024年01月20日
    浏览(43)
  • 电力系统强大的Gurobi 求解器的学习(Python&Matlab)

      到底有多强大,看看就知道,必须👍👍👍:  目录 1 概述   2 算例理解【Python】 2.1 算例1——详细入门  2.2 算例2——一般线性规划问题  2.3 算例3——非凸问题   3 算例升级【Matlab】 3.1 模型 3.2 电力系统经济调度(Matlab代码实现)[Yalmip + Gurobi]  4 致谢  我们经常提到

    2023年04月21日
    浏览(39)
  • 系统学习Python——单元测试unittest:内置装饰器

    分类目录:《系统学习Python》总目录 相关文章: · 单元测试unittest:框架结构 · 单元测试unittest:测试固件 · 单元测试unittest:编写测试用例 · 单元测试unittest:执行测试用例 · 单元测试unittest:用例执行次序 · 单元测试unittest:内置装饰器 · 单元测试unittest:命令行执行测

    2023年04月13日
    浏览(45)
  • 机器学习:塑造未来的核心力量

    着科技的飞速发展,机器学习已经成为我们生活中不可或缺的一部分。无论是搜索引擎、推荐系统,还是自动驾驶汽车和机器人,都依赖于机器学习算法。本文将探讨机器学习的基本概念、应用领域以及未来发展趋势。 一、机器学习的基本概念 机器学习是一种让计算机系统

    2024年02月10日
    浏览(32)
  • VanillaNet:深度学习极简主义的力量

    基础模型的核心是“更多不同”的理念,计算机视觉和自然语言处理方面的出色表现就是例证。然而,Transformer模型的优化和固有复杂性的挑战要求范式向简单性转变。在本文中,我们介绍了VanillaNET,这是一种设计优雅的神经网络架构。通过避免高深度、shortcuts和自注意力等

    2024年02月07日
    浏览(44)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包