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()
虽然本文很长，但是都是非常实用，非常基础的知识，希望小伙伴们可以耐心开完。