Python的装饰器的英文名叫Decorator，当你看到这个英文名的时候，你可能会把其跟Design Pattern里的Decorator搞混了，其实这是完全不同的两个东西。虽然好像，他们要干的事都很相似——都是想要对一个已有的模块做一些“修饰工作”，所谓修饰工作就是想给现有的模块加上一些小装饰（一些小功能，这些小功能可能好多模块都会用到），但又不让这个小装饰（小功能）侵入到原有的模块中的代码里去。但是OO的Decorator简直就是一场恶梦，不信你就去看看wikipedia上的词条（Decorator Pattern）里的UML图和那些代码，这就是我在《 从面向对象的设计模式看软件设计》“餐后甜点”一节中说的，OO鼓励了——“厚重地胶合和复杂层次”，也是《 如此理解面向对象编程》中所说的“OO的狂热者们非常害怕处理数据”，Decorator Pattern搞出来的代码简直就是OO的反面教程。
Python 的 Decorator在使用上和Java/C#的Annotation很相似，就是在方法名前面加一个@XXX注解来为这个方法装饰一些东西。但是，Java/C#的Annotation也很让人望而却步，太TMD的复杂了，你要玩它，你需要了解一堆Annotation的类库文档，让人感觉就是在学另外一门语言。
而Python使用了一种相对于Decorator Pattern和Annotation来说非常优雅的方法，这种方法不需要你去掌握什么复杂的OO模型或是Annotation的各种类库规定，完全就是语言层面的玩法：一种函数式编程的技巧。如果你看过本站的《函数式编程》，你一定会为函数式编程的那种“描述你想干什么，而不是描述你要怎么去实现”的编程方式感到畅快。（如果你不了解函数式编程，那在读本文之前，还请你移步去看看《函数式编程》） 好了，我们先来点感性认识，看一个Python修饰器的Hello World的代码。
Hello World
下面是代码：
文件名：hello.py
<br />def hello(fn):<br /> def wrapper():<br /> print "hello, %s" % fn.__name__<br /> fn()<br /> print "goodby, %s" % fn.__name__<br /> return wrapper<br />@hello<br />def foo():<br /> print "i am foo"<br />foo()<br />
当你运行代码，你会看到如下输出：
<br />[chenaho@chenhao-air]$ python hello.py<br />hello, foo<br />i am foo<br />goodby, foo<br />
你可以看到如下的东西：
1）函数foo前面有个@hello的“注解”，hello就是我们前面定义的函数hello
2）在hello函数中，其需要一个fn的参数（这就用来做回调的函数）
3）hello函数中返回了一个inner函数wrapper，这个wrapper函数回调了传进来的fn，并在回调前后加了两条语句。
Decorator 的本质
对于Python的这个@注解语法糖- Syntactic Sugar 来说，当你在用某个@decorator来修饰某个函数func时，如下所示:
<br />@decorator<br />def func():<br /> pass<br />
其解释器会解释成下面这样的语句：
<br />func = decorator(func)<br />
尼玛，这不就是把一个函数当参数传到另一个函数中，然后再回调吗？是的，但是，我们需要注意，那里还有一个赋值语句，把decorator这个函数的返回值赋值回了原来的func。 根据《函数式编程》中的first class functions中的定义的，你可以把函数当成变量来使用，所以，decorator必需得返回了一个函数出来给func，这就是所谓的higher order function 高阶函数，不然，后面当func()调用的时候就会出错。 就我们上面那个hello.py里的例子来说，
<br />@hello<br />def foo():<br /> print "i am foo"<br />
被解释成了：
<br />foo = hello(foo)<br />
是的，这是一条语句，而且还被执行了。你如果不信的话，你可以写这样的程序来试试看：
<br />def fuck(fn):<br /> print "fuck %s!" % fn.__name__[::-1].upper()<br />@fuck<br />def wfg():<br /> pass<br />
没了，就上面这段代码，没有调用wfg()的语句，你会发现， fuck函数被调用了，而且还很NB地输出了我们每个人的心声！
再回到我们hello.py的那个例子，我们可以看到，hello(foo)返回了wrapper()函数，所以，foo其实变成了wrapper的一个变量，而后面的foo()执行其实变成了wrapper()。
知道这点本质，当你看到有多个decorator或是带参数的decorator，你也就不会害怕了。
比如：多个decorator
<br />@decorator_one<br />@decorator_two<br />def func():<br /> pass<br />
相当于：
<br />func = decorator_one(decorator_two(func))<br />
比如：带参数的decorator：
<br />@decorator(arg1, arg2)<br />def func():<br /> pass<br />
相当于：
<br />func = decorator(arg1,arg2)(func)<br />
这意味着decorator(arg1, arg2)这个函数需要返回一个“真正的decorator”。
带参数及多个Decrorator
我们来看一个有点意义的例子：
html.py
<br />def makeHtmlTag(tag, *args, **kwds):<br /> def real_decorator(fn):<br /> css_class = " class='{0}'".format(kwds["css_class"]) \<br /> if "css_class" in kwds else ""<br /> def wrapped(*args, **kwds):<br /> return "" + fn(*args, **kwds) + ""<br /> return wrapped<br /> return real_decorator<br />@makeHtmlTag(tag="b", css_class="bold_css")<br />@makeHtmlTag(tag="i", css_class="italic_css")<br />def hello():<br /> return "hello world"<br />print hello()<br /># 输出：<br /># <b class='bold_css'><i class='italic_css'>hello world</i></b><br />
在上面这个例子中，我们可以看到：makeHtmlTag有两个参数。所以，为了让 hello = makeHtmlTag(arg1, arg2)(hello) 成功，makeHtmlTag 必需返回一个decorator（这就是为什么我们在makeHtmlTag中加入了real_decorator()的原因），这样一来，我们就可以进入到 decorator 的逻辑中去了—— decorator得返回一个wrapper，wrapper里回调hello。看似那个makeHtmlTag() 写得层层叠叠，但是，已经了解了本质的我们觉得写得很自然。
你看，Python的Decorator就是这么简单，没有什么复杂的东西，你也不需要了解过多的东西，使用起来就是那么自然、体贴、干爽、透气，独有的速效凹道和完美的吸收轨迹，让你再也不用为每个月的那几天感到焦虑和不安，再加上贴心的护翼设计，量多也不用当心。对不起，我调皮了。
什么，你觉得上面那个带参数的Decorator的函数嵌套太多了，你受不了。好吧，没事，我们看看下面的方法。
class式的 Decorator
首先，先得说一下，decorator的class方式，还是看个示例：
<br />class myDecorator(object):<br /> def __init__(self, fn):<br /> print "inside myDecorator.__init__()"<br /> self.fn = fn<br /> def __call__(self):<br /> self.fn()<br /> print "inside myDecorator.__call__()"<br />@myDecorator<br />def aFunction():<br /> print "inside aFunction()"<br />print "Finished decorating aFunction()"<br />aFunction()<br /># 输出：<br /># inside myDecorator.__init__()<br /># Finished decorating aFunction()<br /># inside aFunction()<br /># inside myDecorator.__call__()<br />
上面这个示例展示了，用类的方式声明一个decorator。我们可以看到这个类中有两个成员：
1）一个是__init__()，这个方法是在我们给某个函数decorator时被调用，所以，需要有一个fn的参数，也就是被decorator的函数。
2）一个是__call__()，这个方法是在我们调用被decorator函数时被调用的。
上面输出可以看到整个程序的执行顺序。
这看上去要比“函数式”的方式更易读一些。
下面，我们来看看用类的方式来重写上面的html.py的代码：
html.py
<br />class makeHtmlTagClass(object):<br /> def __init__(self, tag, css_class=""):<br /> self._tag = tag<br /> self._css_class = " class='{0}'".format(css_class) \<br /> if css_class !="" else ""<br /> def __call__(self, fn):<br /> def wrapped(*args, **kwargs):<br /> return "" \<br /> + fn(*args, **kwargs) + ""<br /> return wrapped<br />@makeHtmlTagClass(tag="b", css_class="bold_css")<br />@makeHtmlTagClass(tag="i", css_class="italic_css")<br />def hello(name):<br /> return "Hello, {}".format(name)<br />print hello("Hao Chen")<br />
上面这段代码中，我们需要注意这几点：
1）如果decorator有参数的话，__init__() 成员就不能传入fn了，而fn是在__call__的时候传入的。
2）这段代码还展示了 wrapped(*args, **kwargs) 这种方式来传递被decorator函数的参数。（其中：args是一个参数列表，kwargs是参数dict，具体的细节，请参考Python的文档或是StackOverflow的这个问题，这里就不展开了）
用Decorator设置函数的调用参数
你有三种方法可以干这个事：
第一种，通过 **kwargs，这种方法decorator会在kwargs中注入参数。
<br />def decorate_A(function):<br /> def wrap_function(*args, **kwargs):<br /> kwargs['str'] = 'Hello!'<br /> return function(*args, **kwargs)<br /> return wrap_function<br />@decorate_A<br />def print_message_A(*args, **kwargs):<br /> print(kwargs['str'])<br />print_message_A()<br />
第二种，约定好参数，直接修改参数
<br />def decorate_B(function):<br /> def wrap_function(*args, **kwargs):<br /> str = 'Hello!'<br /> return function(str, *args, **kwargs)<br /> return wrap_function<br />@decorate_B<br />def print_message_B(str, *args, **kwargs):<br /> print(str)<br />print_message_B()<br />
第三种，通过 *args 注入
<br />def decorate_C(function):<br /> def wrap_function(*args, **kwargs):<br /> str = 'Hello!'<br /> #args.insert(1, str)<br /> args = args +(str,)<br /> return function(*args, **kwargs)<br /> return wrap_function<br />class Printer:<br /> @decorate_C<br /> def print_message(self, str, *args, **kwargs):<br /> print(str)<br />p = Printer()<br />p.print_message()<br />
Decorator的副作用
到这里，我相信你应该了解了整个Python的decorator的原理了。
相信你也会发现，被decorator的函数其实已经是另外一个函数了，对于最前面那个hello.py的例子来说，如果你查询一下foo.__name__的话，你会发现其输出的是“wrapper”，而不是我们期望的“foo”，这会给我们的程序埋一些坑。所以，Python的functool包中提供了一个叫wrap的decorator来消除这样的副作用。下面是我们新版本的hello.py。
文件名：hello.py
<br />from functools import wraps<br />def hello(fn):<br /> @wraps(fn)<br /> def wrapper():<br /> print "hello, %s" % fn.__name__<br /> fn()<br /> print "goodby, %s" % fn.__name__<br /> return wrapper<br />@hello<br />def foo():<br /> '''foo help doc'''<br /> print "i am foo"<br /> pass<br />foo()<br />print foo.__name__ #输出 foo<br />print foo.__doc__ #输出 foo help doc<br />
当然，即使是你用了functools的wraps，也不能完全消除这样的副作用。
来看下面这个示例：
<br />from inspect import getmembers, getargspec<br />from functools import wraps<br />def wraps_decorator(f):<br /> @wraps(f)<br /> def wraps_wrapper(*args, **kwargs):<br /> return f(*args, **kwargs)<br /> return wraps_wrapper<br />class SomeClass(object):<br /> @wraps_decorator<br /> def method(self, x, y):<br /> pass<br />obj = SomeClass()<br />for name, func in getmembers(obj, predicate=inspect.ismethod):<br /> print "Member Name: %s" % name<br /> print "Func Name: %s" % func.func_name<br /> print "Args: %s" % getargspec(func)[0]<br /># 输出：<br /># Member Name: method<br /># Func Name: method<br /># Args: []<br />
你会发现，即使是你你用了functools的wraps，你在用getargspec时，参数也不见了。
要修正这一问，我们还得用Python的反射来解决，下面是相关的代码：
<br />def get_true_argspec(method):<br /> argspec = inspect.getargspec(method)<br /> args = argspec[0]<br /> if args and args[0] == 'self':<br /> return argspec<br /> if hasattr(method, '__func__'):<br /> method = method.__func__<br /> if not hasattr(method, 'func_closure') or method.func_closure is None:<br /> raise Exception("No closure for method.")<br /> method = method.func_closure[0].cell_contents<br /> return get_true_argspec(method)<br />
当然，我相信大多数人的程序都不会去getargspec。所以，用functools的wraps应该够用了。
一些decorator的示例
好了，现在我们来看一下各种decorator的例子：
给函数调用做缓存
这个例实在是太经典了，整个网上都用这个例子做decorator的经典范例，因为太经典了，所以，我这篇文章也不能免俗。
<br />from functools import wraps<br />def memo(fn):<br /> cache = {}<br /> miss = object()<br /> @wraps(fn)<br /> def wrapper(*args):<br /> result = cache.get(args, miss)<br /> if result is miss:<br /> result = fn(*args)<br /> cache[args] = result<br /> return result<br /> return wrapper<br />@memo<br />def fib(n):<br /> if n < 2:<br /> return n<br /> return fib(n - 1) + fib(n - 2)<br />
上面这个例子中，是一个斐波拉契数例的递归算法。我们知道，这个递归是相当没有效率的，因为会重复调用。比如：我们要计算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的例子
这个例子没什么高深的，就是实用一些。
<br />import cProfile, pstats, StringIO<br />def profiler(func):<br /> def wrapper(*args, **kwargs):<br /> datafn = func.__name__ + ".profile" # Name the data file<br /> prof = cProfile.Profile()<br /> retval = prof.runcall(func, *args, **kwargs)<br /> #prof.dump_stats(datafn)<br /> s = StringIO.StringIO()<br /> sortby = 'cumulative'<br /> ps = pstats.Stats(prof, stream=s).sort_stats(sortby)<br /> ps.print_stats()<br /> print s.getvalue()<br /> return retval<br /> return wrapper<br />
注册回调函数
下面这个示例展示了通过URL的路由来调用相关注册的函数示例：
<br />class MyApp():<br /> def __init__(self):<br /> self.func_map = {}<br /> def register(self, name):<br /> def func_wrapper(func):<br /> self.func_map[name] = func<br /> return func<br /> return func_wrapper<br /> def call_method(self, name=None):<br /> func = self.func_map.get(name, None)<br /> if func is None:<br /> raise Exception("No function registered against - " + str(name))<br /> return func()<br />app = MyApp()<br />@app.register('/')<br />def main_page_func():<br /> return "This is the main page."<br />@app.register('/next_page')<br />def next_page_func():<br /> return "This is the next page."<br />print app.call_method('/')<br />print app.call_method('/next_page')<br />
注意：
1）上面这个示例中，用类的实例来做decorator。
2）decorator类中没有__call__()，但是wrapper返回了原函数。所以，原函数没有发生任何变化。
给函数打日志
下面这个示例演示了一个logger的decorator，这个decorator输出了函数名，参数，返回值，和运行时间。
<br />from functools import wraps<br />def logger(fn):<br /> @wraps(fn)<br /> def wrapper(*args, **kwargs):<br /> ts = time.time()<br /> result = fn(*args, **kwargs)<br /> te = time.time()<br /> print "function = {0}".format(fn.__name__)<br /> print " arguments = {0} {1}".format<strong>本文来源gaodai#ma#com搞@@代~&码网</strong>(args, kwargs)<br /> print " return = {0}".format(result)<br /> print " time = %.6f sec" % (te-ts)<br /> return result<br /> return wrapper<br />@logger<br />def multipy(x, y):<br /> return x * y<br />@logger<br />def sum_num(n):<br /> s = 0<br /> for i in xrange(n+1):<br /> s += i<br /> return s<br />print multipy(2, 10)<br />print sum_num(100)<br />print sum_num(10000000)<br />
上面那个打日志还是有点粗糙，让我们看一个更好一点的（带log level参数的）：
<br />import inspect<br />def get_line_number():<br /> return inspect.currentframe().f_back.f_back.f_lineno<br />def logger(loglevel):<br /> def log_decorator(fn):<br /> @wraps(fn)<br /> def wrapper(*args, **kwargs):<br /> ts = time.time()<br /> result = fn(*args, **kwargs)<br /> te = time.time()<br /> print "function = " + fn.__name__,<br /> print " arguments = {0} {1}".format(args, kwargs)<br /> print " return = {0}".format(result)<br /> print " time = %.6f sec" % (te-ts)<br /> if (loglevel == 'debug'):<br /> print " called_from_line : " + str(get_line_number())<br /> return result<br /> return wrapper<br /> return log_decorator<br />
但是，上面这个带log level参数的有两具不好的地方，
1） loglevel不是debug的时候，还是要计算函数调用的时间。
2） 不同level的要写在一起，不易读。
我们再接着改进：
<br />import inspect<br />def advance_logger(loglevel):<br /> def get_line_number():<br /> return inspect.currentframe().f_back.f_back.f_lineno<br /> def _basic_log(fn, result, *args, **kwargs):<br /> print "function = " + fn.__name__,<br /> print " arguments = {0} {1}".format(args, kwargs)<br /> print " return = {0}".format(result)<br /> def info_log_decorator(fn):<br /> @wraps(fn)<br /> def wrapper(*args, **kwargs):<br /> result = fn(*args, **kwargs)<br /> _basic_log(fn, result, args, kwargs)<br /> return wrapper<br /> def debug_log_decorator(fn):<br /> @wraps(fn)<br /> def wrapper(*args, **kwargs):<br /> ts = time.time()<br /> result = fn(*args, **kwargs)<br /> te = time.time()<br /> _basic_log(fn, result, args, kwargs)<br /> print " time = %.6f sec" % (te-ts)<br /> print " called_from_line : " + str(get_line_number())<br /> return wrapper<br /> if loglevel is "debug":<br /> return debug_log_decorator<br /> else:<br /> return info_log_decorator<br />
你可以看到两点，
1）我们分了两个log level，一个是info的，一个是debug的，然后我们在外尾根据不同的参数返回不同的decorator。
2）我们把info和debug中的相同的代码抽到了一个叫_basic_log的函数里，DRY原则。
一个MySQL的Decorator
下面这个decorator是我在工作中用到的代码，我简化了一下，把DB连接池的代码去掉了，这样能简单点，方便阅读。
<br />import umysql<br />from functools import wraps<br />class Configuraion:<br /> def __init__(self, env):<br /> if env == "Prod":<br /> self.host = "coolshell.cn"<br /> self.port = 3306<br /> self.db = "coolshell"<br /> self.user = "coolshell"<br /> self.passwd = "fuckgfw"<br /> elif env == "Test":<br /> self.host = 'localhost'<br /> self.port = 3300<br /> self.user = 'coolshell'<br /> self.db = 'coolshell'<br /> self.passwd = 'fuckgfw'<br />def mysql(sql):<br /> _conf = Configuraion(env="Prod")<br /> def on_sql_error(err):<br /> print err<br /> sys.exit(-1)<br /> def handle_sql_result(rs):<br /> if rs.rows > 0:<br /> fieldnames = [f[0] for f in rs.fields]<br /> return [dict(zip(fieldnames, r)) for r in rs.rows]<br /> else:<br /> return []<br /> def decorator(fn):<br /> @wraps(fn)<br /> def wrapper(*args, **kwargs):<br /> mysqlconn = umysql.Connection()<br /> mysqlconn.settimeout(5)<br /> mysqlconn.connect(_conf.host, _conf.port, _conf.user, \<br /> _conf.passwd, _conf.db, True, 'utf8')<br /> try:<br /> rs = mysqlconn.query(sql, {})<br /> except umysql.Error as e:<br /> on_sql_error(e)<br /> data = handle_sql_result(rs)<br /> kwargs["data"] = data<br /> result = fn(*args, **kwargs)<br /> mysqlconn.close()<br /> return result<br /> return wrapper<br /> return decorator<br />@mysql(sql = "select * from coolshell" )<br />def get_coolshell(data):<br /> ... ...<br /> ... ..<br />
线程异步
下面量个非常简单的异步执行的decorator，注意，异步处理并不简单，下面只是一个示例。
<br />from threading import Thread<br />from functools import wraps<br />def async(func):<br /> @wraps(func)<br /> def async_func(*args, **kwargs):<br /> func_hl = Thread(target = func, args = args, kwargs = kwargs)<br /> func_hl.start()<br /> return func_hl<br /> return async_func<br />if __name__ == '__main__':<br /> from time import sleep<br /> @async<br /> def print_somedata():<br /> print 'starting print_somedata'<br /> sleep(2)<br /> print 'print_somedata: 2 sec passed'<br /> sleep(2)<br /> print 'print_somedata: 2 sec passed'<br /> sleep(2)<br /> print 'finished print_somedata'<br /> def main():<br /> print_somedata()<br /> print 'back in main'<br /> print_somedata()<br /> print 'back in main'<br /> main()<br />
虽然本文很长，但是都是非常实用，非常基础的知识，希望小伙伴们可以耐心开完。
转载请注明原文链接：Python装饰器的函数式编程详解
