python 装饰器decorator

最新推荐文章于 2025-04-14 09:43:01 发布

幻欢子

最新推荐文章于 2025-04-14 09:43:01 发布

阅读量713

点赞数

分类专栏： python 文章标签： python 装饰器

本文链接：https://blog.youkuaiyun.com/u012424148/article/details/88988796

版权

python 专栏收录该内容

19 篇文章

订阅专栏

本文深入讲解Python装饰器的概念、本质及应用，包括多个装饰器、带参数装饰器的使用，以及如何利用装饰器进行函数缓存、性能分析和日志记录。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

2.4、用Decorator设置函数的调用参数

一、基本介绍

Python的装饰器的英文名叫Decorator，当你看到这个英文名的时候，你可能会把其跟Design Pattern里的Decorator搞混了，其实这是完全不同的两个东西。虽然好像，他们要干的事都很相似——都是想要对一个已有的模块做一些“修饰工作”，所谓修饰工作就是想给现有的模块加上一些小装饰（一些小功能，这些小功能可能好多模块都会用到），但又不让这个小装饰（小功能）侵入到原有的模块中的代码里去。但是OO的Decorator简直就是一场恶梦，不信你就去看看wikipedia上的词条（Decorator Pattern）里的UML图和那些代码，Decorator Pattern搞出来的代码简直就是OO的反面教程。

Python 的 Decorator在使用上和Java/C#的Annotation很相似，就是在方法名前面加一个@XXX注解来为这个方法装饰一些东西。但是，Java/C#的Annotation也很让人望而却步，太TMD的复杂了，你要玩它，你需要了解一堆Annotation的类库文档，让人感觉就是在学另外一门语言。

而Python使用了一种相对于Decorator Pattern和Annotation来说非常优雅的方法，这种方法不需要你去掌握什么复杂的OO模型或是Annotation的各种类库规定，完全就是语言层面的玩法：一种函数式编程的技巧。好了，我们先来点感性认识，看一个Python修饰器的Hello World的代码。

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()

结果输出如下：

代码解析：

函数foo前面有个@hello的“注解”，hello就是我们前面定义的函数hello。
在hello函数中，其需要一个fn的参数（这就用来做回调的函数）。
hello函数中返回了一个inner函数wrapper，这个wrapper函数回调了传进来的fn，并在回调前后加了两条语句修饰输出。

二、Decorator 的本质

2.1、本质说明

对于Python的这个@注解语法糖- Syntactic Sugar 来说，当你在用某个@decorator来修饰某个函数func时，如下所示:

@decorator
def func():
    pass

其解释器会解释成下面这样的语句：

func = decorator(func)

这不就是把一个函数当参数传到另一个函数中，然后再回调吗？是的，但是，我们需要注意，那里还有一个赋值语句，把decorator这个函数的返回值赋值回了原来的func。根据《函数式编程》中的first class functions中的定义的，你可以把函数当成变量来使用，所以，decorator必需得返回了一个函数出来给func，这就是所谓的higher order function 高阶函数，不然，后面当func()调用的时候就会出错。就我们上面那个hello.py里的例子来说：

@hello
def foo():
    print "i am foo"

被解释成了：

foo = hello(foo)

是的，这是一条语句，而且还被执行了。你如果不信的话，你可以写这样的程序来试试看：

def hello(fn):
    print('hello! %s' % fn.__name__)

@hello
def wfg():
    pass

不需要调用wfg()函数直接会被执行输出hello! wfg。

再回到我们hello.py的那个例子，我们可以看到，hello(foo)返回了wrapper()函数，所以，foo其实变成了wrapper的一个变量，而后面的foo()执行其实变成了wrapper()。

知道这点本质，当你看到有多个decorator或是带参数的decorator，你也就不会害怕了。

2.2、多个decorator

@decorator_one
@decorator_two
def func():
    pass

等价于：

func = decorator_one(decorator_two(func))

2.3、带参数的decorator

@decorator(arg1, arg2)
def func():
    pass

等价于：

func = decorator(arg1,arg2)(func)

这意味着decorator(arg1, arg2)这个函数需要返回一个“真正的decorator”。

2.4、参数及多个Decrorator

看一个有点意义的例子：html.py

def makeHtmlTag(tag, *args, **kwds):
    def real_decorator(fn):
        css_class = " class='{0}'".format(kwds["css_class"]) \
                                     if "css_class" in kwds else ""
        def wrapped(*args, **kwds):
            return "<"+tag+css_class+">" + fn(*args, **kwds) + "</"+tag+">"
        return wrapped
    return real_decorator

@makeHtmlTag(tag="b", css_class="bold_css")
@makeHtmlTag(tag="i", css_class="italic_css")
def hello():
    return "hello world"

print(hello())
# 输出：
# <b class='bold_css'><i class='italic_css'>hello world</i></b>

在上面这个例子中，我们可以看到：makeHtmlTag有两个参数。所以，为了让 hello = makeHtmlTag(arg1, arg2)(hello) 成功，makeHtmlTag 必需返回一个decorator（这就是为什么我们在makeHtmlTag中加入了real_decorator()的原因），这样一来，我们就可以进入到 decorator 的逻辑中去了—— decorator得返回一个wrapper，wrapper里回调hello。看似那个makeHtmlTag() 写得层层叠叠，但是，已经了解了本质的我们觉得写得很自然。

什么，你觉得上面那个带参数的Decorator的函数嵌套太多了，你受不了。好吧，没事，我们看看下面的方法。

class式的 Decorator

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。我们可以看到这个类中有两个成员：

一个是__init__()，这个方法是在我们给某个函数decorator时被调用，所以，需要有一个fn的参数，也就是被decorator的函数。
一个是__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("World!"))
# <b class='bold_css'><i class='italic_css'>Hello, World!</i></b>

上面这段代码中，我们需要注意这几点：

如果decorator有参数的话，__init__() 成员就不能传入fn了，而fn是在__call__的时候传入的。
这段代码还展示了 wrapped(*args, **kwargs) 这种方式来传递被decorator函数的参数。（其中：args是一个参数列表，kwargs是参数dict，具体的细节，请参考Python的文档或是StackOverflow的这个问题，这里就不展开了）

2.4、用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()

2.5、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)

三、decorator的应用示例

3.1、给函数调用做缓存

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，在调用函数前查询一下缓存，如果没有才调用了，有了就从缓存中返回值。一下子，这个递归从二叉树式的递归成了线性的递归。

3.2、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'))

# This is the main page.
# This is the next page.

注意：

上面这个示例中，用类的实例来做decorator。
decorator类中没有__call__()，但是wrapper返回了原函数。所以，原函数没有发生任何变化。

3.3、给函数打日志

下面这个示例演示了一个logger的decorator，这个decorator输出了函数名，参数，返回值，和运行时间。

from functools import wraps
import time

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 range(n+1):
        s += i
    return s

print(multipy(2, 10))
print(sum_num(100))
print(sum_num(10000000))

上面那个打日志还是有点粗糙，让我们看一个更好一点的（带log level参数的）：

import inspect
import time

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参数的有两具不好的地方，

loglevel不是debug的时候，还是要计算函数调用的时间。
不同level的要写在一起，不易读。

再接着改进：

import inspect
import time
from functools import wraps

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

可以看到两点：