Python装饰器的函数式编程详解
Python的装饰器的英文名叫Decorator,当你看到这个英文名的时候,你可能会把其跟DesignPattern里的Decorator搞混了,其实这是完全不同的两个东西。虽然好像,他们要干的事都很相似——都是想要对一个已有的模块做一些“修饰工作”,所谓修饰工作就是想给现有的模块加上一些小装饰(一些小功能,这些小功能可能好多模块都会用到),但又不让这个小装饰(小功能)侵入到原有的模块中的代码里去。但是OO的Decorator简直就是一场恶梦,不信你就去看看wikipedia上的词条(DecoratorPattern)里的UML图和那些代码,这就是我在《从面向对象的设计模式看软件设计》“餐后甜点”一节中说的,OO鼓励了——“厚重地胶合和复杂层次”,也是《如此理解面向对象编程》中所说的“OO的狂热者们非常害怕处理数据”,DecoratorPattern搞出来的代码简直就是OO的反面教程。
Python的Decorator在使用上和Java/C#的Annotation很相似,就是在方法名前面加一个@XXX注解来为这个方法装饰一些东西。但是,Java/C#的Annotation也很让人望而却步,太TMD的复杂了,你要玩它,你需要了解一堆Annotation的类库文档,让人感觉就是在学另外一门语言。
而Python使用了一种相对于DecoratorPattern和Annotation来说非常优雅的方法,这种方法不需要你去掌握什么复杂的OO模型或是Annotation的各种类库规定,完全就是语言层面的玩法:一种函数式编程的技巧。如果你看过本站的《函数式编程》,你一定会为函数式编程的那种“描述你想干什么,而不是描述你要怎么去实现”的编程方式感到畅快。(如果你不了解函数式编程,那在读本文之前,还请你移步去看看《函数式编程》)好了,我们先来点感性认识,看一个Python修饰器的HelloWorld的代码。
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
我们来看一个有点意义的例子:
html.py
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()写得层层叠叠,但是,已经了解了本质的我们觉得写得很自然。
你看,Python的Decorator就是这么简单,没有什么复杂的东西,你也不需要了解过多的东西,使用起来就是那么自然、体贴、干爽、透气,独有的速效凹道和完美的吸收轨迹,让你再也不用为每个月的那几天感到焦虑和不安,再加上贴心的护翼设计,量多也不用当心。对不起,我调皮了。
什么,你觉得上面那个带参数的Decorator的函数嵌套太多了,你受不了。好吧,没事,我们看看下面的方法。
class式的Decorator
首先,先得说一下,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函数时被调用的。
上面输出可以看到整个程序的执行顺序。
这看上去要比“函数式”的方式更易读一些。
下面,我们来看看用类的方式来重写上面的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的这个问题,这里就不展开了)
用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的要写在一起,不易读。
我们再接着改进:
importinspect 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(): print'startingprint_somedata' sleep(2) print'print_somedata:2secpassed' sleep(2) print'print_somedata:2secpassed' sleep(2) print'finishedprint_somedata' defmain(): print_somedata() print'backinmain' print_somedata() print'backinmain' main()
虽然本文很长,但是都是非常实用,非常基础的知识,希望小伙伴们可以耐心开完。