python装饰器原函数的简单介绍
请教:python装饰器如何不改变原函数名
装饰器是用在函数不修改添加新功能的情况下诞生的,一般在需要装饰的函数上写
10多年的巴中网站建设经验,针对设计、前端、开发、售后、文案、推广等六对一服务,响应快,48小时及时工作处理。营销型网站的优势是能够根据用户设备显示端的尺寸不同,自动调整巴中建站的显示方式,使网站能够适用不同显示终端,在浏览器中调整网站的宽度,无论在任何一种浏览器上浏览网站,都能展现优雅布局与设计,从而大程度地提升浏览体验。创新互联公司从事“巴中网站设计”,“巴中网站推广”以来,每个客户项目都认真落实执行。
@funcname
def funb(){
.....
}
然后再装饰的函数里面去调用原函数,以达到不修改添加功能的作用
python装饰器是什么意思
装饰器是程序开发中经常会用到的一个功能,用好了装饰器,开发效率如虎添翼,所以这也是Python面试中必问的问题,但对于好多小白来讲,这个功能 有点绕,自学时直接绕过去了,然后面试问到了就挂了,因为装饰器是程序开发的基础知识,这个都 不会,别跟人家说你会Python, 看了下面的文章,保证你学会装饰器。
1、先明白这段代码
#### 第一波 ####
def foo():
print 'foo'
foo #表示是函数
foo() #表示执行foo函数
#### 第二波 ####
def foo():
print 'foo'
foo = lambda x: x + 1
foo() # 执行下面的lambda表达式,而不再是原来的foo函数,因为函数 foo 被重新定义了
2、需求来了
初创公司有N个业务部门,1个基础平台部门,基础平台负责提供底层的功能,如:数据库操作、redis调用、监控API等功能。业务部门使用基础功能时,只需调用基础平台提供的功能即可。如下:
############### 基础平台提供的功能如下 ###############
def f1():
print 'f1'
def f2():
print 'f2'
def f3():
print 'f3'
def f4():
print 'f4'
############### 业务部门A 调用基础平台提供的功能 ###############
f1()
f2()
f3()
f4()
############### 业务部门B 调用基础平台提供的功能 ###############
f1()
f2()
f3()
f4()
目前公司有条不紊的进行着,但是,以前基础平台的开发人员在写代码时候没有关注验证相关的问题,即:基础平台的提供的功能可以被任何人使用。现在需要对基础平台的所有功能进行重构,为平台提供的所有功能添加验证机制,即:执行功能前,先进行验证。
老大把工作交给 Low B,他是这么做的:
跟每个业务部门交涉,每个业务部门自己写代码,调用基础平台的功能之前先验证。诶,这样一来基础平台就不需要做任何修改了。
当天Low B 被开除了…
老大把工作交给 Low BB,他是这么做的:
############### 基础平台提供的功能如下 ###############
def f1():
# 验证1
# 验证2
# 验证3
print 'f1'
def f2():
# 验证1
# 验证2
# 验证3
print 'f2'
def f3():
# 验证1
# 验证2
# 验证3
print 'f3'
def f4():
# 验证1
# 验证2
# 验证3
print 'f4'
############### 业务部门不变 ###############
### 业务部门A 调用基础平台提供的功能###
f1()
f2()
f3()
f4()
### 业务部门B 调用基础平台提供的功能 ###
f1()
f2()
f3()
f4()
过了一周 Low BB 被开除了…
老大把工作交给 Low BBB,他是这么做的:
只对基础平台的代码进行重构,其他业务部门无需做任何修改
############### 基础平台提供的功能如下 ###############
def check_login():
# 验证1
# 验证2
# 验证3
pass
def f1():
check_login()
print 'f1'
def f2():
check_login()
print 'f2'
def f3():
check_login()
print 'f3'
def f4():
check_login()
print 'f4'
老大看了下Low BBB 的实现,嘴角漏出了一丝的欣慰的笑,语重心长的跟Low BBB聊了个天:
老大说:
写代码要遵循开发封闭原则,虽然在这个原则是用的面向对象开发,但是也适用于函数式编程,简单来说,它规定已经实现的功能代码不允许被修改,但可以被扩展,即:
封闭:已实现的功能代码块
开放:对扩展开发
如果将开放封闭原则应用在上述需求中,那么就不允许在函数 f1 、f2、f3、f4的内部进行修改代码,老板就给了Low BBB一个实现方案:
def w1(func):
def inner():
# 验证1
# 验证2
# 验证3
return func()
return inner
@w1
def f1():
print 'f1'
@w1
def f2():
print 'f2'
@w1
def f3():
print 'f3'
@w1
def f4():
print 'f4'
对于上述代码,也是仅仅对基础平台的代码进行修改,就可以实现在其他人调用函数 f1 f2 f3 f4 之前都进行【验证】操作,并且其他业务部门无需做任何操作。
Low BBB心惊胆战的问了下,这段代码的内部执行原理是什么呢?
老大正要生气,突然Low BBB的手机掉到地上,恰恰屏保就是Low BBB的女友照片,老大一看一紧一抖,喜笑颜开,交定了Low BBB这个朋友。详细的开始讲解了:
单独以f1为例:
def w1(func):
def inner():
# 验证1
# 验证2
# 验证3
return func()
return inner
@w1
def f1():
print 'f1'
当写完这段代码后(函数未被执行、未被执行、未被执行),python解释器就会从上到下解释代码,步骤如下:
def w1(func): ==将w1函数加载到内存
@w1
没错,从表面上看解释器仅仅会解释这两句代码,因为函数在没有被调用之前其内部代码不会被执行。
从表面上看解释器着实会执行这两句,但是 @w1 这一句代码里却有大文章,@函数名 是python的一种语法糖。
如上例@w1内部会执行一下操作:
执行w1函数,并将 @w1 下面的 函数 作为w1函数的参数,即:@w1 等价于 w1(f1)
所以,内部就会去执行:
def inner:
#验证
return f1() # func是参数,此时 func 等于 f1
return inner # 返回的 inner,inner代表的是函数,非执行函数
其实就是将原来的 f1 函数塞进另外一个函数中
将执行完的 w1 函数返回值赋值给@w1下面的函数的函数名
w1函数的返回值是:
def inner:
#验证
return 原来f1() # 此处的 f1 表示原来的f1函数
然后,将此返回值再重新赋值给 f1,即:
新f1 = def inner:
#验证
return 原来f1()
所以,以后业务部门想要执行 f1 函数时,就会执行 新f1 函数,在 新f1 函数内部先执行验证,再执行原来的f1函数,然后将 原来f1 函数的返回值 返回给了业务调用者。
如此一来, 即执行了验证的功能,又执行了原来f1函数的内容,并将原f1函数返回值 返回给业务调用着
Low BBB 你明白了吗?要是没明白的话,我晚上去你家帮你解决吧!!!
先把上述流程看懂,之后还会继续更新…
3、问答时间
问题:被装饰的函数如果有参数呢?
#一个参数
def w1(func):
def inner(arg):
# 验证1
# 验证2
# 验证3
return func(arg)
return inner
@w1
def f1(arg):
print 'f1'
#两个参数
def w1(func):
def inner(arg1,arg2):
# 验证1
# 验证2
# 验证3
return func(arg1,arg2)
return inner
@w1
def f1(arg1,arg2):
print 'f1'
#三个参数
def w1(func):
def inner(arg1,arg2,arg3):
# 验证1
# 验证2
# 验证3
return func(arg1,arg2,arg3)
return inner
@w1
def f1(arg1,arg2,arg3):
print 'f1'
问题:可以装饰具有处理n个参数的函数的装饰器?
def w1(func):
def inner(*args,**kwargs):
# 验证1
# 验证2
# 验证3
return func(*args,**kwargs)
return inner
@w1
def f1(arg1,arg2,arg3):
print 'f1'
问题:一个函数可以被多个装饰器装饰吗?
def w1(func):
def inner(*args,**kwargs):
# 验证1
# 验证2
# 验证3
return func(*args,**kwargs)
return inner
def w2(func):
def inner(*args,**kwargs):
# 验证1
# 验证2
# 验证3
return func(*args,**kwargs)
return inner
@w1
@w2
def f1(arg1,arg2,arg3):
print 'f1'
问题:还有什么更吊的装饰器吗?
#!/usr/bin/env python
#coding:utf-8
def Before(request,kargs):
print 'before'
def After(request,kargs):
print 'after'
def Filter(before_func,after_func):
def outer(main_func):
def wrapper(request,kargs):
before_result = before_func(request,kargs)
if(before_result != None):
return before_result;
main_result = main_func(request,kargs)
if(main_result != None):
return main_result;
after_result = after_func(request,kargs)
if(after_result != None):
return after_result;
return wrapper
return outer
@Filter(Before, After)
def Index(request,kargs):
print 'index'
如何理解Python装饰器
简言之,打个比方,我写了一个python的插件,提供给用户使用,但是在使用的过程中我添加了一些功能,可是又不希望用户改变调用的方式,那么该怎么办呢?这个时候就用到了装饰器。
python装饰器就是用于拓展原来函数功能的一种函数,这个函数的特殊之处在于它的返回值也是一个函数,使用python装饰器的好处就是在不用更改原函数的代码前提下给函数增加新的功能。一般而言,我们要想拓展原来函数代码,比较直接的办法就是侵入代码里面修改。
而且装饰器是程序开发中经常会用到的一个功能,用好了装饰器,开发效率如虎添翼,所以这也是Python面试中必问的问题,但对于好多小白来讲,这个功能有点绕,自学时直接绕过去了,然后面试问到了就挂了,因为装饰器是程序开发的基础知识,不懂就太说不过去啦。
讲完装饰器,相信大家对于Python的发展前景也比较感兴趣,随着人工智能的发展,Python作为人工智能的首选语言,自然也是发展得如火如荼。现在入行,肯定是一个好时机!
什么是Python装饰器
装饰器(decorator)是Python中的高级语法。装饰的意思就是动态扩展被装饰对象的功能。装饰器可以用于装饰函数、方法和类。
一 嵌套函数
# 定义一个外层函数def foo(): # 定义了一个内部函数 def bar(): print("hello world")
函数bar是一个定义在foo函数内部的函数。
Python中的函数是支持嵌套的,也就是可以在一个函数内部再定义一个函数。
然后,我们还知道函数是可以当作变量的,于是我们就可以在foo函数中把定义的这个bar函数返回。就像下面这样:
# 定义一个外层函数def foo(): # 定义了一个内层函数 def bar(): print("hello world") return
barfunc = foo()func() # func -- bar,这里执行func其实就相当于执行了在foo函数内部定义的bar函数
二 闭包形态1
# 闭包形态1def foo(): name = "Andy" # 外部函数的局部变量 # 定义了一个内部函数 def bar():
print(name) # 虽然bar函数中没有定义name变量,但是它可以访问外部函数的局部变量name return barfunc =
foo()func() # func -- bar -- 除了是一个函数,还包含一个值(它外层函数的局部变量)的引用
三 闭包形态2
# 闭包形态2def foo(name): # 给一个函数传参也相当于给函数定义了一个局部变量 # 定义了一个内部函数 def bar():
print(name) # 内部函数同样可以获取到传到外部函数的变量(参数) return barfunc = foo("Andy") #
把“Andy”当成参数传入foo函数 -- 其内部定义的bar函数也能拿到这个“Andy”func() # func -- bar --
除了是一个函数,还包含一个值(它外层函数的参数)的引用
四 装饰器形态1
# 还是定义一个外层函数def foo(name): # 我接收的参数是一个函数名 # 定义了一个内部函数 def bar():
print("这是新功能。。。") # 新功能 name() # 函数名加()就相当于执行-- 我传进来原函数的函数名,这里就相当于执行了原函数
return bar# 定义一个被装饰的函数def f1(): print("hello world.") # 用foo函数装饰f1函数f1 =
foo(f1)# 不改变f1的调用方式f1() # -- 此时函数已经扩展了新功能
五 装饰器形态2
# 还是定义一个外层函数def foo(name): # 接收的参数是一个函数名 # 定义了一个内部函数 def bar():
print("这是新功能。。。") # 新功能 name() # 函数名加()就相当于执行-- 传进来原函数的函数名,这里就相当于执行了原函数
return bar# 定义一个被装饰的函数# 用foo函数装饰f1函数@foo # 使用f1 =
foo(f1)语法装饰的话稍显啰嗦,Python就提供了@语法,让装饰过程更简便def f1(): print("hello world.") #
不改变f1的调用方式f1() # -- 此时函数已经扩展了新功能。
「低门槛 手把手」python 装饰器(Decorators)原理说明
本文目的是由浅入深地介绍python装饰器原理
装饰器(Decorators)是 Python 的一个重要部分
其功能是, 在不修改原函数(类)定义代码的情况下,增加新的功能
为了理解和实现装饰器,我们先引入2个核心操作:
在这个例子中,函数hi的形参name,默认为'world'
在函数内部,又定义了另一个函数 howdoyoudo,定义这个函数时,将形参name作为新函数的形参name2的默认值。
因此,在函数内部调用howdoyoudo()时,将以调用hi时的实参为默认值,但也可以给howdoyoudo输入其他参数。
上面的例子运行后输出结果为:
这里新定义的howdoyoudo可以称作一个“闭包”。不少关于装饰器的blog都提到了这个概念,但其实没必要给它取一个多专业的名字。我们知道闭包是 函数内的函数 就可以了
当我们进行 def 的时候,我们在做什么?
这时,hi函数,打印一个字符串,同时返回一个字符串。
但hi函数本身也是一个对象,一个可以执行的对象。执行的方式是hi()。
这里hi和hi()有本质区别,
hi 代表了这个函数对象本身
hi() 则是运行了函数,得到函数的返回值。
作为对比,可以想象以下代码
此时也是b存在,可以正常使用。
我们定义2个函数,分别实现自加1, 自乘2,
再定义一个函数double_exec,内容是将某个函数调用2次
在调用double_exec时,可以将函数作为输入传进来
输出结果就是
7
27
同样,也可以将函数作为输出
输出结果为
6
10
有了以上两个核心操作,我们可以尝试构造装饰器了。
装饰器的目的: 在不修改原函数(类)定义代码的情况下,增加新的功能
试想一下,现在有一个原函数
在不修改原函数定义代码的情况下,如果想进行函数内容的添加,可以将这个函数作为一个整体,添加到这样的包裹中:
我们定义了一个my_decorator函数,这个函数进行了一种操作:
对传入的f,添加操作(运行前后增加打印),并把添加操作后的内容连同运行原函数的内容,一起传出
这个my_decorator,定义了一种增加前后打印内容的行为
调用my_decorator时,对这个行为进行了操作。
因此,new_function是一个在original_function上增加了前后打印行为的新函数
这个过程被可以被称作装饰。
这里已经可以发现,装饰器本身对于被装饰的函数是什么,是不需要考虑的。装饰器本身只定义了一种装饰行为,这个行为是通过装饰器内部的闭包函数()进行定义的。
运行装饰前后的函数,可以清晰看到装饰的效果
我们复现一下实际要用装饰器的情况,我们往往有一种装饰器,想应用于很多个函数,比如
此时,如果我们想给3个print函数都加上装饰器,需要这么做
实际调用的时候,就需要调用添加装饰器的函数名了
当然,也可以赋值给原函数名
这样至少不需要管理一系列装饰前后的函数。
同时,在不需要进行装饰的时候,需要把
全部删掉。
事实上,这样并不方便,尤其对于更复杂的装饰器来说
为此,python提供了一种简写方式
这个定义print1函数前的@my_decorator,相当于在定义完print1后,自动直接运行了
不论采用@my_decorator放在新函数前,还是显示地重写print1 = my_decorator(print1),都会存在一个问题:
装饰后的函数,名字改变了(其实不止名字,一系列的索引都改变了)
输出结果为:
这个现象的原因是,装饰行为本身,是通过构造了一个新的函数(例子中是wrap_func函数)来实现装饰这个行为的,然后把这个修改后的函数赋给了原函数名。
这样,会导致我们预期的被装饰函数的一些系统变量(比如__name__)发生了变化。
对此,python提供了解决方案:
经过这个行为后,被装饰函数的系统变量问题被解决了
输出结果为
刚才的例子都比较简单,被装饰的函数是没有参数的。如果被装饰的函数有参数,只需要在定义装饰行为时(事实上,这个才更通用),增加(*args, **kwargs)描述即可
之前的描述中可以感受到,对于例子中的装饰行为(前后加打印),函数被装饰后,本质上是调用了新的装饰函数wrap_func。
因此,如果原函数需要有输入参数传递,只需要在wrap_func(或其他任意名字的装饰函数)定义时,也增加参数输入(*args, **kwargs),并将这些参数,原封不动地传给待装饰函数f。
这种定义装饰行为的方式更具有普遍性,忘记之前的定义方式吧
我们试一下
输出
这里需要注意的是,如果按照以下的方式定义装饰器
那么以下语句将不会执行
因为装饰后实际的函数wrap_func(虽然名字被改成了原函数,系统参数也改成了原函数),运行到return f(*args, **kwargs) 的时候已经结束了
因为装饰器my_decorator本身也是可以输入的,因此,只需要在定义装饰器时,增加参数,并在后续函数中使用就可以了,比如
此时装饰器已经可以有输入参数了
输出
你可能发现,为什么不用简写版的方法了
因为以上代码会报错!!
究其原因,虽然
等价于
但是,
并不等价于
这本身和@语法有关,使用@my_decorator时,是系统在应用一个以单个函数作为参数的闭包函数。即,@是不能带参数的。
但是你应该发现了,之前的@wraps(f)不是带参数了吗?请仔细观察以下代码
通过一层嵌套,my_decorator_with_parma本质上是返回了一个参数仅为一个函数的函数(my_decorator),但因为my_decorator对my_decorator_with_parma来说是一个闭包,my_decorator_with_parma是可以带参数的。(这句话真绕)
通过以上的定义,我们再来看
可以这么理解,my_decorator_with_parma(msg='yusheng')的结果是原来的my_decorator函数,同时,因为my_decorator_with_parma可以传参,参数实际上是参与了my_decorator的(因为my_decorator对my_decorator_with_parma是闭包), my_decorator_with_parma(msg='yusheng') 全等于 一个有参数参加的my_decorator
因此,以上代码等价于有参数msg传递的
比较绕,需要理解一下,或者干脆强记这种范式:
以上范式包含函数的输入输出、装饰器的输入,可以应对大部分情况了。
实验一下:
输出
以上是一个log装饰器,利用datetime统计了函数的耗时,
并且,装饰器可以进行输出文件操作,如果给出了文件路径,则输出文件,否则就打印。
利用这个装饰器,可以灵活地进行耗时统计
不设置输出文件地址,则打印。运行结果为:
也可以输出到文件
输出结果为
同时在当前目录生成了一个test.log 文件,内容为:
以上的装饰器都是以函数形式出现的,但我们可以稍做改写,将装饰器以类的形式实现。
这个装饰器类Log 上个例子里的装饰器函数log功能是一样的,同时,这个装饰器类还可以作为基类被其他继承,进一步增加功能。
原文
python装饰器听了N次也没印象,读完这篇你就懂了
装饰器其实一直是我的一个"老大难"。这个知识点就放在那,但是拖延症。。。
其实在平常写写脚本的过程中,这个知识点你可能用到不多
但在面试的时候,这可是一个高频问题。
所谓的装饰器,其实就是通过装饰器函数,来修改原函数的一些功能,使得原函数不需要修改。
这一句话理解起来可能没那么轻松,那先来看一个"傻瓜"函数。
放心,绝对不是"Hello World"!
怎么样,没骗你吧? 哈哈,这个函数不用运行相信大家都知道输出结果: "你好,装饰器" 。
那如果我想让 hello() 函数再实现个其他功能,比如多打印一句话。
那么,可以这样"增强"一下:
运行结果:
很显然,这个"增强"没啥作用,但是可以帮助理解装饰器。
当运行最后的 hello() 函数时,调用过程是这样的:
那上述代码里的 my_decorator() 就是一个装饰器。
它改变了 hello() 的行为,但是并没有去真正的改变 hello()函数 的内部实现。
但是,python一直以"优雅"被人追捧,而上述的代码显然不够优雅。
所以,想让上述装饰器变得优雅,可以这样写:
这里的 @my_decorator 就相当于旧代码的 hello = my_decorator(hello) , @ 符号称为语法糖。
那如果还有其他函数也需要加上类似的装饰,直接在函数的上方加上 @my_decorator 就可以,大大提高函数
的重复利用与可读性。
输出:
上面的只是一个非常简单的装饰器,但是实际场景中,很多函数都是要带有参数的,比如hello(people_name)。
其实也很简单,要什么我们就给什么呗,直接在对应装饰器的 wrapper() 上,加上对应的参数:
输出:
但是还没完,这样虽然简单,但是随之而来另一个问题:因为并不是所有函数参数都是一样的,
当其他要使用装饰器的函数参数不止这个一个肿么办?比如:
没关系,在python里, *args 和 **kwargs 表示接受任意数量和类型的参数,所以我们可以这样
写装饰器里的 wrapper() 函数:
同时运行下 hello("老王") ,和 hello3("张三", "李四") ,看结果:
上面2种,装饰器都是接收外来的参数,其实装饰器还可以接收自己的参数。
比如,我加个参数来控制下装饰器中打印信息的次数:
注意,这里 count 装饰函数中的2个 return .
运行下,应该会出现3次:
现在多做一步 探索 ,我们来打印下下面例子中的hello()函数的元信息:
输出:
这说明了,它不再是以前的那个 hello() 函数,而是被 wrapper() 函数取代了。
如果我们需要用到元函数信息,那怎么保留它呢?这时候可以用内置装饰器 @functools.wrap 。
运行下:
好记性不如烂笔头,写一下理解一下会好很多。
下面还分享类的装饰器,以及装饰器所用场景。
网站栏目:python装饰器原函数的简单介绍
URL分享:http://myzitong.com/article/hgehco.html