Python Decorator

本文内容纲要：

由于没时间编写，就把几张写的不错的文章摘录整合到一起。原文地址：PythonDecoratorpythondecorator心得体会可爱的Python:Decorator简化元编程

Python之美--Decorator深入详解(一)PythonDecorators（二）：Decorator参数PythonDecorator初体验

Python的修饰器的英文名叫Decorator，当你看到这个英文名的时候，你可能会把其跟DesignPattern里的Decorator搞混了，其实这是完全不同的两个东西。在认识装饰器之前，我们先来点感性认识，看一个Python修饰器的HelloWorld的代码。

下面是代码：文件名：hello.py defhello(fn): defwrapper(): print"hello,%s"%fn.__name__ fn() print"goodby,%s"%fn.__name__ returnwrapper @hello deffoo(): print"iamfoo" foo()

当你运行代码，你会看到如下输出：

[chenaho@chenhao-air]$pythonhello.py hello,foo iamfoo goodby,foo

你可以看到如下的东西：

1）函数foo前面有个@hello的“注解”，hello就是我们前面定义的函数hello；

2）在hello函数中，其需要一个fn的参数（这就用来做回调的函数）；

3）hello函数中返回了一个inner函数wrapper，这个wrapper函数回调了传进来的fn，并在回调前后加了两条语句。

Decorator的本质

对于Python的这个@注解语法糖-SyntacticSugar来说，当你在用某个@decorator来修饰某个函数func时，如下所示:

@decorator deffunc(): pass

其解释器会解释成下面这样的语句：

func=decorator(func)

了然，这不就是把一个函数当参数传到另一个函数中，然后再回调吗？是的，但是，我们需要注意，那里还有一个赋值语句，把decorator这个函数的返回值赋值回了原来的func。根据《函数式编程》中的firstclassfunctions中的定义的，你可以把函数当成变量来使用，所以，decorator必需得返回了一个函数出来给func，这就是所谓的higherorderfunction高阶函数，不然，后面当func()调用的时候就会出错。就我们上面那个hello.py里的例子来说，

@hello deffoo(): print"iamfoo"

被解释成了：

foo=hello(foo)

是的，这是一条语句，而且还被执行了。你如果不信的话，你可以写这样的程序来试试看：

deffuck(fn): print"fuck%s!"%fn.__name__[::-1].upper() @fuck defwfg(): pass

没了，就上面这段代码，没有调用wfg()的语句，你会发现，fuck函数被调用了，而且还很NB地输出了我们每个人的心声！

再回到我们hello.py的那个例子，我们可以看到，hello(foo)返回了wrapper()函数，所以，foo其实变成了wrapper的一个变量，而后面的foo()执行其实变成了wrapper()。知道这点本质，当你看到有多个decorator或是带参数的decorator，你也就不会害怕了。

比如：多个decorator：

@decorator_one @decorator_two deffunc(): pass

相当于：

func=decorator_one(decorator_two(func))

比如：带参数的decorator：

@decorator(arg1,arg2) deffunc(): pass

相当于：

func=decorator(arg1,arg2)(func)

这意味着decorator(arg1,arg2)这个函数需要返回一个“真正的decorator”。

带参数及多个Decrorator

我们来看一个有点意义的例子：

defmakeHtmlTag(tag,*args,**kwds): defreal_decorator(fn): css_class="class={0}".format(kwds["css_class"])if"css_class"inkwdselse"" defwrapped(*args,**kwds): return"<"+tag+css_class+">"+fn(*args,**kwds)+"</"+tag+">" returnwrapped returnreal_decorator @makeHtmlTag(tag="b",css_class="bold_css") @makeHtmlTag(tag="i",css_class="italic_css") defhello(): return"helloworld" printhello() #输出： #<bclass=bold_css><iclass=italic_css>helloworld</i></b>

在上面这个例子中，我们可以看到：makeHtmlTag有两个参数。所以，为了让hello=makeHtmlTag(arg1,arg2)(hello)成功，makeHtmlTag必需返回一个decorator（这就是为什么我们在makeHtmlTag中加入了real_decorator()的原因），这样一来，我们就可以进入到decorator的逻辑中去了——decorator得返回一个wrapper，wrapper里回调hello。看似那个makeHtmlTag()写得层层叠叠，但是，已经了解了本质的我们觉得写得很自然。

初识Decorator Decorator，修饰符，是在Python2.4中增加的功能，也是pythoner实现元编程的最新方式，同时它也是最简单的元编程方式。为什么是“最简单”呢？是的，其实在Decorator之前就已经 有classmethod()和staticmethod()内置函数，但他们的缺陷是会导致函数名的重复使用(可以看看DavidMertz的CharmingPython:Decoratorsmakemagiceasy)， 以下是摘自他本人的原文： classC: deffoo(cls,y): print"classmethod",cls,y foo=classmethod(foo) 是的，classmethod做的只是函数转换，但是它却让foo这个名字另外出现了2次。记得有一句话是：人类因懒惰而进步。Decorator的诞生，让foo少出现2次。 classC: @classmethod deffoo(cls,y): print"classmethod",cls,y 读者也许已经想到Decorator在python中是怎么处理的了(如果还没头绪的，强烈建议先去看看limodou写的Decorator学习笔记)。下面我列出4种用法。 单个Decorator，不带参数 设想一个情景，你平时去买衣服的时候，跟售货员是怎么对话的呢？售货员会先向你问好，然后你会试穿某件你喜爱的衣服。 defsalesgirl(method): defserve(*args): print"Salesgirl:Hello,whatdoyouwant?",method.__name__ method(*args) returnserve @salesgirl deftry_this_shirt(size): ifsize<35: print"I:%dinchesistosmalltome"%(size) else: print"I:%dinchesisjustenough"%(size) try_this_shirt(38) 结果是： Salesgirl:Hello,whatdoyouwant?try_this_shirt I:38inchesisjustenough 这只是一个太简单的例子，以至一些“细节”没有处理好，你试穿完了好歹也告诉salesgirl到底要不要买啊。。。这样try_this_shirt方法需要改成带返回值 (假设是bool类型,True就是要买，False就是不想买)，那么salesgirl中的serve也应该带返回值，并且返回值就是method(*args)。 修改后的salesgirl defsalesgirl(method): defserve(*args): print"Salesgirl:Hello,whatdoyouwant?",method.__name__ returnmethod(*args) returnserve @salesgirl deftry_this_shirt(size): ifsize<35: print"I:%dinchesistosmalltome"%(size) returnFalse else: print"I:%dinchesisjustenough"%(size) returnTrue result=try_this_shirt(38) print"Mum:doyouwanttobuythis?",result 结果是： Salesgirl:Hello,whatdoyouwant?try_this_shirt I:38inchesisjustenough Mum:doyouwanttobuythis?True 现在我们的salesgirl还不算合格，她只会给客人打招呼，但是客人要是买衣服了，也不会给他报价；客人不买的话，也应该推荐其他款式！ 会报价的salesgirl: defsalesgirl(method): defserve(*args): print"Salesgirl:Hello,whatdoyouwant?",method.__name__ result=method(*args) ifresult: print"Salesgirl:Thisshirtis50$." else: print"Salesgirl:Well,howabouttryinganotherstyle?" returnresult returnserve @salesgirl deftry_this_shirt(size): ifsize<35: print"I:%dinchesistosmalltome"%(size) returnFalse else: print"I:%dinchesisjustenough"%(size) returnTrue result=try_this_shirt(38) print"Mum:doyouwanttobuythis?",result 结果是： Salesgirl:Hello,whatdoyouwant?try_this_shirt I:38inchesisjustenough Salesgirl:Thisshirtis50$. Mum:doyouwanttobuythis?True 这样的salesgirl总算是合格了，但离出色还很远，称职的salesgirl是应该对熟客让利，老用户总得有点好处吧？ 单个Decorator，带参数 会报价并且带折扣的salesgirl： defsalesgirl(discount): defexpense(method): defserve(*args): print"Salesgirl:Hello,whatdoyouwant?",method.__name__ result=method(*args) ifresult: print"Salesgirl:Thisshirtis50$.Asanolduser,wepromisedtodiscountat%d%%"%(discount) else: print"Salesgirl:Well,howabouttryinganotherstyle?" returnresult returnserve returnexpense @salesgirl(50) deftry_this_shirt(size): ifsize<35: print"I:%dinchesistosmalltome"%(size) returnFalse else: print"I:%dinchesisjustenough"%(size) returnTrue result=try_this_shirt(38) print"Mum:doyouwanttobuythis?",result 结果是： Salesgirl:Hello,whatdoyouwant?try_this_shirt I:38inchesisjustenough Salesgirl:Thisshirtis50$.Asanolduser,wepromisedtodiscountat50% Mum:doyouwanttobuythis?True 这里定义的salesgirl是会给客户50%的折扣，因为salesgirl描述符是带参数，而参数就是折扣。如果你是第一次看到这个salesgirl， 会被她里面嵌套的2个方法而感到意外，没关系，当你习惯了Decorator之后，一切都变得很亲切啦

你看，Python的Decorator就是这么简单，没有什么复杂的东西，你也不需要了解过多的东西，使用起来就是那么自然、体贴，但是你觉得上面那个带参数的Decorator的函数嵌套太多了，你受不了。好吧，没事，我们看看下面的方法。

class式的Decorator(重点)

1、首先，先得说一下，decorator的class方式，还是看个示例：

classmyDecorator(object): def__init__(self,fn): print"insidemyDecorator.__init__()" self.fn=fn def__call__(self): self.fn() print"insidemyDecorator.__call__()" @myDecorator defaFunction(): print"insideaFunction()" print"FinisheddecoratingaFunction()" aFunction() #输出： #insidemyDecorator.__init__() #FinisheddecoratingaFunction() #insideaFunction() #insidemyDecorator.__call__()

上面这个示例展示了，用类的方式声明一个decorator。我们可以看到这个类中有两个成员：

1）一个是__init__()，这个方法是在我们给某个函数decorator时被调用，所以，需要有一个fn的参数，也就是被decorator的函数。

2）一个是__call__()，这个方法是在我们调用被decorator函数时被调用的。

上面输出可以看到整个程序的执行顺序。这看上去要比“函数式”的方式更易读一些。

2、下面，我们来看看用类的方式来重写上面的html.py的代码：html.py

classmakeHtmlTagClass(object): def__init__(self,tag,css_class=""): self._tag=tag self._css_class="class={0}".format(css_class)\ ifcss_class!=""else"" def__call__(self,fn): defwrapped(*args,**kwargs): return"<"+self._tag+self._css_class+">"\ +fn(*args,**kwargs)+"</"+self._tag+">" returnwrapped @makeHtmlTagClass(tag="b",css_class="bold_css") @makeHtmlTagClass(tag="i",css_class="italic_css") defhello(name): return"Hello,{}".format(name) printhello("HaoChen")

上面这段代码中，我们需要注意这几点：

1）如果decorator有参数的话，__init__()成员就不能传入fn了，而fn是在__call__的时候传入的。

2）这段代码还展示了wrapped(*args,**kwargs)这种方式来传递被decorator函数的参数。（其中：args是一个参数列表，kwargs是参数dict，具体的细节，请参考Python的文档或是StackOverflow的这个问题，这里就不展开了）

3、用Decorator设置函数的调用参数，你有三种方法可以干这个事：

第一种，通过**kwargs，这种方法decorator会在kwargs中注入参数。

defdecorate_A(function): defwrap_function(*args,**kwargs): kwargs[str]=Hello! returnfunction(*args,**kwargs) returnwrap_function @decorate_A defprint_message_A(*args,**kwargs): print(kwargs[str]) print_message_A()

第二种，约定好参数，直接修改参数

defdecorate_B(function): defwrap_function(*args,**kwargs): str=Hello! returnfunction(str,*args,**kwargs) returnwrap_function @decorate_B defprint_message_B(str,*args,**kwargs): print(str) print_message_B()

第三种，通过*args注入

defdecorate_C(function): defwrap_function(*args,**kwargs): str=Hello! #args.insert(1,str) args=args+(str,) returnfunction(*args,**kwargs) returnwrap_function classPrinter: @decorate_C defprint_message(self,str,*args,**kwargs): print(str) p=Printer() p.print_message()

Decorator的副作用

到这里，我相信你应该了解了整个Python的decorator的原理了。相信你也会发现，被decorator的函数其实已经是另外一个函数了，对于最前面那个hello.py的例子来说，如果你查询一下foo.__name__的话，你会发现其输出的是“wrapper”，而不是我们期望的“foo”，这会给我们的程序埋一些坑。所以，Python的functool包中提供了一个叫wrap的decorator来消除这样的副作用。下面是我们新版本的hello.py。

文件名：hello.py fromfunctoolsimportwraps defhello(fn): @wraps(fn) defwrapper(): print"hello,%s"%fn.__name__ fn() print"goodby,%s"%fn.__name__ returnwrapper @hello deffoo(): foohelpdoc print"iamfoo" pass foo() printfoo.__name__#输出foo printfoo.__doc__#输出foohelpdoc

当然，即使是你用了functools的wraps，也不能完全消除这样的副作用。来看下面这个示例：

frominspectimportgetmembers,getargspec fromfunctoolsimportwraps defwraps_decorator(f): @wraps(f) defwraps_wrapper(*args,**kwargs): returnf(*args,**kwargs) returnwraps_wrapper classSomeClass(object): @wraps_decorator defmethod(self,x,y): pass obj=SomeClass() forname,funcingetmembers(obj,predicate=inspect.ismethod): print"MemberName:%s"%name print"FuncName:%s"%func.func_name print"Args:%s"%getargspec(func)[0] #输出： #MemberName:method #FuncName:method #Args:[]

你会发现，即使是你你用了functools的wraps，你在用getargspec时，参数也不见了。要修正这一问，我们还得用Python的反射来解决，下面是相关的代码：

defget_true_argspec(method): argspec=inspect.getargspec(method) args=argspec[0] ifargsandargs[0]==self: returnargspec ifhasattr(method,__func__): method=method.__func__ ifnothasattr(method,func_closure)ormethod.func_closureisNone: raiseException("Noclosureformethod.") method=method.func_closure[0].cell_contents returnget_true_argspec(method)

当然，我相信大多数人的程序都不会去getargspec。所以，用functools的wraps应该够用了。一些decorator的示例。好了，现在我们来看一下各种decorator的例子：**给函数调用做缓存。**这个例实在是太经典了，整个网上都用这个例子做decorator的经典范例，因为太经典了，所以，我这篇文章也不能免俗。

fromfunctoolsimportwraps defmemo(fn): cache={} miss=object() @wraps(fn) defwrapper(*args): result=cache.get(args,miss) ifresultismiss: result=fn(*args) cache[args]=result returnresult returnwrapper @memo deffib(n): ifn<2: returnn returnfib(n-1)+fib(n-2)

上面这个例子中，是一个斐波拉契数例的递归算法。我们知道，这个递归是相当没有效率的，因为会重复调用。比如：我们要计算fib(5)，于是其分解成fib(4)+fib(3)，而fib(4)分解成fib(3)+fib(2)，fib(3)又分解成fib(2)+fib(1)……你可看到，基本上来说，fib(3),fib(2),fib(1)在整个递归过程中被调用了两次。而我们用decorator，在调用函数前查询一下缓存，如果没有才调用了，有了就从缓存中返回值。一下子，这个递归从二叉树式的递归成了线性的递归。

Profiler的例子

这个例子没什么高深的，就是实用一些。

importcProfile,pstats,StringIO defprofiler(func): defwrapper(*args,**kwargs): datafn=func.__name__+".profile"#Namethedatafile prof=cProfile.Profile() retval=prof.runcall(func,*args,**kwargs) #prof.dump_stats(datafn) s=StringIO.StringIO() sortby=cumulative ps=pstats.Stats(prof,stream=s).sort_stats(sortby) ps.print_stats() prints.getvalue() returnretval returnwrapper

注册回调函数

下面这个示例展示了通过URL的路由来调用相关注册的函数示例：

classMyApp(): def__init__(self): self.func_map={} defregister(self,name): deffunc_wrapper(func): self.func_map[name]=func returnfunc returnfunc_wrapper defcall_method(self,name=None): func=self.func_map.get(name,None) iffuncisNone: raiseException("Nofunctionregisteredagainst-"+str(name)) returnfunc() app=MyApp() @app.register(/) defmain_page_func(): return"Thisisthemainpage." @app.register(/next_page) defnext_page_func(): return"Thisisthenextpage." printapp.call_method(/) printapp.call_method(/next_page)

注意：

1）上面这个示例中，用类的实例来做decorator。

2）decorator类中没有__call__()，但是wrapper返回了原函数。所以，原函数没有发生任何变化。

给函数打日志 下面这个示例演示了一个logger的decorator，这个decorator输出了函数名，参数，返回值，和运行时间。

fromfunctoolsimportwraps deflogger(fn): @wraps(fn) defwrapper(*args,**kwargs): ts=time.time() result=fn(*args,**kwargs) te=time.time() print"function={0}".format(fn.__name__) print"arguments={0}{1}".format(args,kwargs) print"return={0}".format(result) print"time=%.6fsec"%(te-ts) returnresult returnwrapper @logger defmultipy(x,y): returnx*y @logger defsum_num(n): s=0 foriinxrange(n+1): s+=i returns printmultipy(2,10) printsum_num(100) printsum_num(10000000)

上面那个打日志还是有点粗糙，让我们看一个更好一点的（带loglevel参数的）：

importinspect defget_line_number(): returninspect.currentframe().f_back.f_back.f_lineno deflogger(loglevel): deflog_decorator(fn): @wraps(fn) defwrapper(*args,**kwargs): ts=time.time() result=fn(*args,**kwargs) te=time.time() print"function="+fn.__name__, print"arguments={0}{1}".format(args,kwargs) print"return={0}".format(result) print"time=%.6fsec"%(te-ts) if(loglevel==debug): print"called_from_line:"+str(get_line_number()) returnresult returnwrapper returnlog_decorator

但是，上面这个带loglevel参数的有两具不好的地方，

1）loglevel不是debug的时候，还是要计算函数调用的时间。

2）不同level的要写在一起，不易读。

我们再接着改进：

mportinspect defadvance_logger(loglevel): defget_line_number(): returninspect.currentframe().f_back.f_back.f_lineno def_basic_log(fn,result,*args,**kwargs): print"function="+fn.__name__, print"arguments={0}{1}".format(args,kwargs) print"return={0}".format(result) definfo_log_decorator(fn): @wraps(fn) defwrapper(*args,**kwargs): result=fn(*args,**kwargs) _basic_log(fn,result,args,kwargs) returnwrapper defdebug_log_decorator(fn): @wraps(fn) defwrapper(*args,**kwargs): ts=time.time() result=fn(*args,**kwargs) te=time.time() _basic_log(fn,result,args,kwargs) print"time=%.6fsec"%(te-ts) print"called_from_line:"+str(get_line_number()) returnwrapper ifloglevelis"debug": returndebug_log_decorator else: returninfo_log_decorator

你可以看到两点，

1）我们分了两个loglevel，一个是info的，一个是debug的，然后我们在外尾根据不同的参数返回不同的decorator。

2）我们把info和debug中的相同的代码抽到了一个叫_basic_log的函数里，DRY原则。

一个MySQL的Decorator 下面这个decorator是我在工作中用到的代码，我简化了一下，把DB连接池的代码去掉了，这样能简单点，方便阅读。

importumysql fromfunctoolsimportwraps classConfiguraion: def__init__(self,env): ifenv=="Prod": self.host="coolshell.cn" self.port=3306 self.db="coolshell" self.user="coolshell" self.passwd="fuckgfw" elifenv=="Test": self.host=localhost self.port=3300 self.user=coolshell self.db=coolshell self.passwd=fuckgfw defmysql(sql): _conf=Configuraion(env="Prod") defon_sql_error(err): printerr sys.exit(-1) defhandle_sql_result(rs): ifrs.rows>0: fieldnames=[f[0]forfinrs.fields] return[dict(zip(fieldnames,r))forrinrs.rows] else: return[] defdecorator(fn): @wraps(fn) defwrapper(*args,**kwargs): mysqlconn=umysql.Connection() mysqlconn.settimeout(5) mysqlconn.connect(_conf.host,_conf.port,_conf.user,\ _conf.passwd,_conf.db,True,utf8) try: rs=mysqlconn.query(sql,{}) exceptumysql.Errorase: on_sql_error(e) data=handle_sql_result(rs) kwargs["data"]=data result=fn(*args,**kwargs) mysqlconn.close() returnresult returnwrapper returndecorator @mysql(sql="select*fromcoolshell") defget_coolshell(data): ...... .....

线程异步

下面量个非常简单的异步执行的decorator，注意，异步处理并不简单，下面只是一个示例。

fromthreadingimportThread fromfunctoolsimportwraps defasync(func): @wraps(func) defasync_func(*args,**kwargs): func_hl=Thread(target=func,args=args,kwargs=kwargs) func_hl.start() returnfunc_hl returnasync_func if__name__==__main__: fromtimeimportsleep @async defprint_somedata(): printstartingprint_somedata sleep(2) printprint_somedata:2secpassed sleep(2) printprint_somedata:2secpassed sleep(2) printfinishedprint_somedata defmain(): print_somedata() printbackinmain print_somedata() printbackinmain main()

本文内容总结：

原文链接：https://www.cnblogs.com/zh605929205/p/7704902.html