左耳朵耗子：Python 修饰器的函数式编程

技术圈的噩耗：年仅 47 岁的左耳朵耗子已离开人世。很多技术大 V 和平台都发了回忆和追悼。我与他并不相识和接触，虽然很早就知道他的博客（搜任何关于独立博客的推荐，都可能在前几个里看到他的），但直到 2018 年买了他的《左耳听风》专栏后，才完整读过一些文章。我印象最深的是几篇非纯技术向的，比如：《程序员如何把控自己的职业》、《如何超过大多数人》、《技术人员的发展之路》、《什么是工程师文化》、《别让自己“墙”了自己》等。专栏有 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

下面是代码（文件名：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) + ""
        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]

参考资料

[1]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

展开阅读全文

页面更新：2024-04-26

标签：函数耗子示例副作用语句例子耳朵参数东西代码方式方法

1 2 3 4 5