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