Python-基础知识-装饰器
一、函数相关基础
1、Python是从上往下顺序执行代码,当碰到定义函数的代码块时,并不会立即执行。只有等到该函数被调用时,才会执行相应的代码块。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | def foo(): print ( "foo函数被运行了!" ) 如果就这样定义了函数,foo函数里面的语句是不会执行的。 python解释器只是简单地在内存定义了一个名为foo的内存地址。 相当于: foo = print ( "foo函数被运行了!" ) 再看看,下面的例子: def foo(): print ( "我是上面的函数定义!" ) def foo(): print ( "我是下面的函数定义!" ) foo() 运行结果: 我是下面的函数定义! |
可见,Python是从上往下顺序执行代码,下面的foo将上面的foo覆盖了。因此,最后执行是第二个定义的函数foo。在Python中代码的放置位置是有一定要求的,不能随意摆放,函数体要放在被调用的语句之前。
2、函数体
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | def foo(): print ( "foo函数被运行了!" ) return "OK" 分别运行: foo foo() 函数名:foo 函数体: 1 - 3 行 返回值:字符串 "OK" ,如不定义,默认返回NONE 函数的内存地址:当函数体被python解释器读进内存后,它有标识符即函数名foo引用, 简单的说,foo指向的是函数体在内存中的保存位置 函数名加括号:foo(),函数的调用方法,只有见到这个括号,程序才会根据函数名从内存中找到函数体并执行。 |
二、装饰器
先看下面的例子:
1 2 3 4 5 6 7 8 9 10 | def outer(func): def inner(): print ( "我是内层函数!" ) return inner def foo(): print ( "我是原始函数!" ) outer(foo) outer(foo()) |
在python中,一切都是对象,函数也不例外。因此可以将函数名,甚至函数名加括号进行调用的方式作为另一个函数的返回值。
上面代码中,outer和foo是两个函数,outer(foo)表示将foo函数名当作参数传递给outer函数并执行outer函数;outer(foo())表示将foo函数执行后的返回值当作参数传递给outer函数并执行outer函数,由于foo函数没有指定返回值,实际上它传递给了outer函数一个None。注意其中的差别,有没有括号是关键!
同样,在outer函数内部,返回了一个inner,inner是在outer函数内部定义的一个函数,注意,由于inner后面没有加括号,所以返回的是inner的函数体,实际上也就是inner这个名字,一个简单的引用而已。
那么,如果outer函数返回的是inner()呢?现在你应该已经很清楚了,它会先执行inner函数的内容,然后返回个None给outer,outer再把这个None返回给调用它的对象。
请记住,函数名、函数加括号可以被当做参数传递,也可以被当做返回值return,有没有括号是两个截然不同的意思!
三、装饰器的使用场景
装饰器通常用于在不改变原有函数代码和功能的情况下,为其添加额外的功能。比如在原函数执行前先执行点什么,在执行后执行点什么。
软件开发中有一个原则“开放-封闭”原则,简单来说,他规定已经实现的功能代码不允许被修改,但可以被扩展,即:
- 封闭:已实现的功能代码块
- 开放:对扩展开发
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 | 有一个大公司,下属的基础平台部负责内部应用程序及API的开发 有上百个业务部门负责不同的业务,他们各自调用基础平台部提供的不同函数处理自己的业务 情况如下: # 基础平台部门开发了上百个函数 def f1(): print ( "业务部门1数据接口......" ) def f2(): print ( "业务部门2数据接口......" ) def f3(): print ( "业务部门3数据接口......" ) def f100(): print ( "业务部门100数据接口......" ) #各部门分别调用 f1() f2() f3() f100() 由于公司在创业初期,基础平台部开发这些函数时, 由于各种原因,比如时间,比如考虑不周等等,没有为函数调用进行安全认证。 现在,平台部主管决定弥补这个缺陷,于是: 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() ########################## 以上实现方法虽然可行,但是它对已经实现的功能代码内部进行了修改。违反了“开放 - 封闭”原则 再继续往下看: def outer(func): def inner(): print ( "认证成功!" ) result = func() print ( "日志添加成功" ) return result return inner @outer def f1(): print ( "业务部门1数据接口......" ) @outer def f2(): print ( "业务部门2数据接口......" ) @outer def f3(): print ( "业务部门3数据接口......" ) @outer def f100(): print ( "业务部门100数据接口......" ) #各部门分别调用 f1() f2() f3() f100() 对于上述代码,也是仅需对基础平台的代码进行拓展,就可以实现在其他部门调用函数 f1 f2 f3 f100 之前都进行认证操作。 在操作结束后保存日志,并且其他业务部门无需他们自己的代码做任何修改,调用方式也不用变。 |
分析上面的这段代码:
1、程序开始运行,从上往下读取,发现函数体并将函数体加载到内存中,然后继续往下读取。
2、读到@outer的时候,python知道@outer是个装饰器(语法糖)后,立即执行outer这个函数。
3、由于outer函数做了2件事,一是定义了inner这个函数,二是返回inner在内存中的地址。
4、由于装饰器的语法规则,被装饰的函数的名字会被当作参数传递给装饰函数。装饰函数按顺序执行自己的代码后,将它的返回值赋值给被装饰的函数。
5、执行outer函数的时候,python解释器又发现了另外一个函数inner,但是并不会马上执行inner代码块的内容。下一步,就是return inner。返回值是个函数名。由第四点得出,inner这个函数名会被复制给f1这个被装饰的函数,也就是f1 = inner。此时f1函数被新的函数inner覆盖。(即f1这个函数名的内存地址指向到inner的函数内存地址)
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | 一个装饰器: def deco(func): def inner(): print ( "这是inner函数" ) result = func() return result return inner @deco def func1(): print ( "这个是func1" ) func1() 实际上相当于: fun1 = deco(func1) |
6、业务部门依然通过f1()的方式调用f1函数,但执行的不再是原本f1函数的代码,而是inner函数的代码。
注意:
1、@outer和@outer()是有区别的,没有括号时,outer函数依然会被执行。这和传统的用括号才能调用函数不同,需要特别注意。
2、f1这个函数名当作参数传递给装饰函数outer,func = f1,@outer等于outer(f1),实际上传递了f1的函数体,而不是执行f1后的返回值。
3、outer函数return的是inner这个函数名,而不是inner()被调用后的返回值。
四、装饰器的参数传递
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 | 一个参数的情况: def outer(func): def inner(username): print ( "认证成功!" ) result = func(username) print ( "日志添加成功" ) return result return inner @outer def 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 @outer def f1(name,age): print ( "%s 正在连接业务部门1数据接口......" % name) # 调用方法 f1( "jack" , 18 ) |
五、装饰器高级用法
1、一个函数被多个装饰器装饰:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 | 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( "jack" , 18 ) 执行结果: 认证成功! 一条欢迎信息。。。 jack 正在连接业务部门 1 数据接口...... 一条欢送信息。。。 日志添加成功 |
分析:
多个装饰器:
f1 = outer1(outer2(f1))
2、带参数的装饰器:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 | # 认证函数 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( "jack" , 18 ) 运行结果: 认证成功! jack 正在连接业务部门 1 数据接口...... 日志添加成功 |
分析:
带参数的装饰器:
f1 = Filter(auth,log)(f1)
3、带有参数的多个装饰器:
1 2 3 4 5 6 7 8 9 10 11 | 带有参数的多个装饰器: @deco1 (deco_arg) @deco2 () def foo(): pass 实际上相当于: def foo(): pass foo = deco1(deco_arg)(deco2(foo)) |
分析:
带有参数的多个装饰器:
deco1接受参数deco_arg,处理完成后的结果作为装饰器去装饰deco2(foo)
【推荐】编程新体验,更懂你的AI,立即体验豆包MarsCode编程助手
【推荐】凌霞软件回馈社区,博客园 & 1Panel & Halo 联合会员上线
【推荐】抖音旗下AI助手豆包,你的智能百科全书,全免费不限次数
【推荐】博客园社区专享云产品让利特惠,阿里云新客6.5折上折
【推荐】轻量又高性能的 SSH 工具 IShell:AI 加持,快人一步
· 为什么说在企业级应用开发中,后端往往是效率杀手?
· 用 C# 插值字符串处理器写一个 sscanf
· Java 中堆内存和栈内存上的数据分布和特点
· 开发中对象命名的一点思考
· .NET Core内存结构体系(Windows环境)底层原理浅谈
· 为什么说在企业级应用开发中,后端往往是效率杀手?
· DeepSeek 解答了困扰我五年的技术问题。时代确实变了!
· 本地部署DeepSeek后,没有好看的交互界面怎么行!
· 趁着过年的时候手搓了一个低代码框架
· 推荐一个DeepSeek 大模型的免费 API 项目!兼容OpenAI接口!