详解Python的装饰器

Python中的装饰器是你进入Python大门的一道坎，不管你跨不跨过去它都在那里。

为什么需要装饰器

我们假设你的程序实现了say_hello()和say_goodbye()两个函数。

 
 
    
  
  
  1. def say_hello():
    2. 
  
  
  2.     print "hello!"
    3. 
  
  
  3.     
    4. 
  
  
  4. def say_goodbye():
    5. 
  
  
  5.     print "hello!"  # bug here
    6. 
  
  
  6. 
  
  
  7. if __name__ == '__main__':
    8. 
  
  
  8.     say_hello()
    9. 
  
  
  9.     say_goodbye() 
    10.

但是在实际调用中，我们发现程序出错了，上面的代码打印了两个hello。经过调试你发现是say_goodbye()出错了。老板要求调用每个方法前都要记录进入函数的名称，比如这样：

 
 
    
  
  
  1. [DEBUG]: Enter say_hello()
    2. 
  
  
  2. Hello!
    3. 
  
  
  3. [DEBUG]: Enter say_goodbye()
    4. 
  
  
  4. Goodbye! 
    5.

好，小A是个毕业生，他是这样实现的。

 
 
    
  
  
  1. def say_hello():
    2. 
  
  
  2.     print "[DEBUG]: enter say_hello()"
    3. 
  
  
  3.     print "hello!"
    4. 
  
  
  4. 
  
  
  5. def say_goodbye():
    6. 
  
  
  6.     print "[DEBUG]: enter say_goodbye()"
    7. 
  
  
  7.     print "hello!"
    8. 
  
  
  8. 
  
  
  9. if __name__ == '__main__':
    10. 
  
  
  10.     say_hello()
    11. 
  
  
  11.     say_goodbye() 
    12.

很low吧? 嗯是的。小B工作有一段时间了，他告诉小A可以这样写。

 
 
    
  
  
  1. def debug():
    2. 
  
  
  2.     import inspect
    3. 
  
  
  3.     caller_name = inspect.stack()[1][3]
    4. 
  
  
  4.     print "[DEBUG]: enter {}()".format(caller_name)   
    5. 
  
  
  5. 
  
  
  6. def say_hello():
    7. 
  
  
  7.     debug()
    8. 
  
  
  8.     print "hello!"
    9. 
  
  
  9. 
  
  
  10. def say_goodbye():
    11. 
  
  
  11.     debug()
    12. 
  
  
  12.     print "goodbye!"
    13. 
  
  
  13. 
  
  
  14. if __name__ == '__main__':
    15. 
  
  
  15.     say_hello()
    16. 
  
  
  16.     say_goodbye() 
    17.

是不是好一点?那当然，但是每个业务函数里都要调用一下debug()函数，是不是很难受?万一老板说say相关的函数不用debug，do相关的才需要呢?

那么装饰器这时候应该登场了。

装饰器本质上是一个Python函数，它可以让其他函数在不需要做任何代码变动的前提下增加额外功能，装饰器的返回值也是一个函数对象。它经常用于有切面需求的场景，比如：插入日志、性能测试、事务处理、缓存、权限校验等场景。装饰器是解决这类问题的***设计，有了装饰器，我们就可以抽离出大量与函数功能本身无关的雷同代码并继续重用。

概括的讲，装饰器的作用就是为已经存在的函数或对象添加额外的功能。

怎么写一个装饰器

在早些时候 (Python Version < 2.4，2004年以前)，为一个函数添加额外功能的写法是这样的。

 
 
    
  
  
  1. def debug(func):
    2. 
  
  
  2.     def wrapper():
    3. 
  
  
  3.         print "[DEBUG]: enter {}()".format(func.__name__)
    4. 
  
  
  4.         return func()
    5. 
  
  
  5.     return wrapper
    6. 
  
  
  6. 
  
  
  7. def say_hello():
    8. 
  
  
  8.     print "hello!"
    9. 
  
  
  9. 
  
  
  10. say_hello = debug(say_hello)  # 添加功能并保持原函数名不变 
    11.

上面的debug函数其实已经是一个装饰器了，它对原函数做了包装并返回了另外一个函数，额外添加了一些功能。因为这样写实在不太优雅，在后面版本的Python中支持了@语法糖，下面代码等同于早期的写法。

 
 
    
  
  
  1. def debug(func):
    2. 
  
  
  2.     def wrapper():
    3. 
  
  
  3.         print "[DEBUG]: enter {}()".format(func.__name__)
    4. 
  
  
  4.         return func()
    5. 
  
  
  5.     return wrapper
    6. 
  
  
  6. 
  
  
  7. @debug
    8. 
  
  
  8. def say_hello():
    9. 
  
  
  9.     print "hello!" 
    10.

这是最简单的装饰器，但是有一个问题，如果被装饰的函数需要传入参数，那么这个装饰器就坏了。因为返回的函数并不能接受参数，你可以指定装饰器函数wrapper接受和原函数一样的参数，比如：

 
 
    
  
  
  1. def debug(func):
    2. 
  
  
  2.     def wrapper(something):  # 指定一毛一样的参数
    3. 
  
  
  3.         print "[DEBUG]: enter {}()".format(func.__name__)
    4. 
  
  
  4.         return func(something)
    5. 
  
  
  5.     return wrapper  # 返回包装过函数
    6. 
  
  
  6. 
  
  
  7. @debug
    8. 
  
  
  8. def say(something):
    9. 
  
  
  9.     print "hello {}!".format(something) 
    10.

这样你就解决了一个问题，但又多了N个问题。因为函数有千千万，你只管你自己的函数，别人的函数参数是什么样子，鬼知道?还好Python提供了可变参数*args和关键字参数**kwargs，有了这两个参数，装饰器就可以用于任意目标函数了。

 
 
    
  
  
  1. def debug(func):
    2. 
  
  
  2.     def wrapper(*args, **kwargs):  # 指定宇宙无敌参数
    3. 
  
  
  3.         print "[DEBUG]: enter {}()".format(func.__name__)
    4. 
  
  
  4.         print 'Prepare and say...',
    5. 
  
  
  5.         return func(*args, **kwargs)
    6. 
  
  
  6.     return wrapper  # 返回
    7. 
  
  
  7. 
  
  
  8. @debug
    9. 
  
  
  9. def say(something):
    10. 
  
  
  10.     print "hello {}!".format(something) 
    11.

至此，你已完全掌握初级的装饰器写法。

高级一点的装饰器

带参数的装饰器和类装饰器属于进阶的内容。在理解这些装饰器之前，***对函数的闭包和装饰器的接口约定有一定了解。(参见http://betacat.online/posts/p...

带参数的装饰器

假设我们前文的装饰器需要完成的功能不仅仅是能在进入某个函数后打出log信息，而且还需指定log的级别，那么装饰器就会是这样的。

 
 
    
  
  
  1. def logging(level):
    2. 
  
  
  2.     def wrapper(func):
    3. 
  
  
  3.         def inner_wrapper(*args, **kwargs):
    4. 
  
  
  4.             print "[{level}]: enter function {func}()".format(
    5. 
  
  
  5.                 level=level,
    6. 
  
  
  6.                 func=func.__name__)
    7. 
  
  
  7.             return func(*args, **kwargs)
    8. 
  
  
  8.         return inner_wrapper
    9. 
  
  
  9.     return wrapper
    10. 
  
  
  10. 
  
  
  11. @logging(level='INFO')
    12. 
  
  
  12. def say(something):
    13. 
  
  
  13.     print "say {}!".format(something)
    14. 
  
  
  14. 
  
  
  15. # 如果没有使用@语法，等同于
    16. 
  
  
  16. # say = logging(level='INFO')(say)
    17. 
  
  
  17. 
  
  
  18. @logging(level='DEBUG')
    19. 
  
  
  19. def do(something):
    20. 
  
  
  20.     print "do {}...".format(something)
    21. 
  
  
  21. 
  
  
  22. if __name__ == '__main__':
    23. 
  
  
  23.     say('hello')
    24. 
  
  
  24.     do("my work") 
    25.

是不是有一些晕?你可以这么理解，当带参数的装饰器被打在某个函数上时，比如@logging(level='DEBUG')，它其实是一个函数，会马上被执行，只要这个它返回的结果是一个装饰器时，那就没问题。细细再体会一下。

基于类实现的装饰器

装饰器函数其实是这样一个接口约束，它必须接受一个callable对象作为参数，然后返回一个callable对象。在Python中一般callable对象都是函数，但也有例外。只要某个对象重载了__call__()方法，那么这个对象就是callable的。

 
 
    
  
  
  1. class Test():
    2. 
  
  
  2.     def __call__(self):
    3. 
  
  
  3.         print 'call me!'
    4. 
  
  
  4. 
  
  
  5. t = Test()
    6. 
  
  
  6. t()  # call me 
    7.

像__call__这样前后都带下划线的方法在Python中被称为内置方法，有时候也被称为魔法方法。重载这些魔法方法一般会改变对象的内部行为。上面这个例子就让一个类对象拥有了被调用的行为。

回到装饰器上的概念上来，装饰器要求接受一个callable对象，并返回一个callable对象(不太严谨，详见后文)。那么用类来实现也是也可以的。我们可以让类的构造函数__init__()接受一个函数，然后重载__call__()并返回一个函数，也可以达到装饰器函数的效果。

 
 
    
  
  
  1. class logging(object):
    2. 
  
  
  2.     def __init__(self, func):
    3. 
  
  
  3.         self.func = func
    4. 
  
  
  4. 
  
  
  5.     def __call__(self, *args, **kwargs):
    6. 
  
  
  6.         print "[DEBUG]: enter function {func}()".format(
    7. 
  
  
  7.             func=self.func.__name__)
    8. 
  
  
  8.         return self.func(*args, **kwargs)
    9. 
  
  
  9. @logging
    10. 
  
  
  10. def say(something):
    11. 
  
  
  11.     print "say {}!".format(something) 
    12.

带参数的类装饰器

如果需要通过类形式实现带参数的装饰器，那么会比前面的例子稍微复杂一点。那么在构造函数里接受的就不是一个函数，而是传入的参数。通过类把这些参数保存起来。然后在重载__call__方法是就需要接受一个函数并返回一个函数。

 
 
    
  
  
  1. class logging(object):
    2. 
  
  
  2.     def __init__(self, level='INFO'):
    3. 
  
  
  3.         self.level = level
    4. 
  
  
  4.         
    5. 
  
  
  5.     def __call__(self, func): # 接受函数
    6. 
  
  
  6.         def wrapper(*args, **kwargs):
    7. 
  
  
  7.             print "[{level}]: enter function {func}()".format(
    8. 
  
  
  8.                 level=self.level,
    9. 
  
  
  9.                 func=func.__name__)
    10. 
  
  
  10.             func(*args, **kwargs)
    11. 
  
  
  11.         return wrapper  #返回函数
    12. 
  
  
  12. 
  
  
  13. @logging(level='INFO')
    14. 
  
  
  14. def say(something):
    15. 
  
  
  15.     print "say {}!".format(something) 
    16.

内置的装饰器

内置的装饰器和普通的装饰器原理是一样的，只不过返回的不是函数，而是类对象，所以更难理解一些。

@property

在了解这个装饰器前，你需要知道在不使用装饰器怎么写一个属性。

 
 
    
  
  
  1. def getx(self):
    2. 
  
  
  2.     return self._x
    3. 
  
  
  3. 
  
  
  4. def setx(self, value):
    5. 
  
  
  5.     self._x = value
    6. 
  
  
  6.     
    7. 
  
  
  7. def delx(self):
    8. 
  
  
  8.    del self._x
    9. 
  
  
  9. 
  
  
  10. # create a property
    11. 
  
  
  11. x = property(getx, setx, delx, "I am doc for x property")
    12.

以上就是一个Python属性的标准写法，其实和Java挺像的，但是太罗嗦。有了@语法糖，能达到一样的效果但看起来更简单。

 
 
    
  
  
  1. @property
    2. 
  
  
  2. def x(self): ...
    3. 
  
  
  3. 
  
  
  4. # 等同于
    5. 
  
  
  5. 
  
  
  6. def x(self): ...
    7. 
  
  
  7. x = property(x) 
    8.

属性有三个装饰器：setter, getter, deleter ，都是在property()的基础上做了一些封装，因为setter和deleter是property()的第二和第三个参数，不能直接套用@语法。getter装饰器和不带getter的属性装饰器效果是一样的，估计只是为了凑数，本身没有任何存在的意义。经过@property装饰过的函数返回的不再是一个函数，而是一个property对象。

 
 
    
  
  
  1. >>> property()
    2. 
  
  
  2.  
    3.

@staticmethod，@classmethod

有了@property装饰器的了解，这两个装饰器的原理是差不多的。@staticmethod返回的是一个staticmethod类对象，而@classmethod返回的是一个classmethod类对象。他们都是调用的是各自的__init__()构造函数。

 
 
    
  
  
  1. class classmethod(object):
    2. 
  
  
  2.     """
    3. 
  
  
  3.     classmethod(function) -> method
    4. 
  
  
  4.     """    
    5. 
  
  
  5.     def __init__(self, function): # for @classmethod decorator
    6. 
  
  
  6.         pass
    7. 
  
  
  7.     # ...
    8. 
  
  
  8. class staticmethod(object):
    9. 
  
  
  9.     """
    10. 
  
  
  10.     staticmethod(function) -> method
    11. 
  
  
  11.     """
    12. 
  
  
  12.     def __init__(self, function): # for @staticmethod decorator
    13. 
  
  
  13.         pass
    14. 
  
  
  14.     # ... 
    15.

装饰器的@语法就等同调用了这两个类的构造函数。

 
 
    
  
  
  1. class Foo(object):
    2. 
  
  
  2. 
  
  
  3.     @staticmethod
    4. 
  
  
  4.     def bar():
    5. 
  
  
  5.         pass
    6. 
  
  
  6.     
    7. 
  
  
  7.     # 等同于 bar = staticmethod(bar) 
    8.

至此，我们上文提到的装饰器接口定义可以更加明确一些，装饰器必须接受一个callable对象，其实它并不关心你返回什么，可以是另外一个callable对象(大部分情况)，也可以是其他类对象，比如property。

装饰器里的那些坑

装饰器可以让你代码更加优雅，减少重复，但也不全是优点，也会带来一些问题。

位置错误的代码

让我们直接看示例代码。

 
 
    
  
  
  1. def html_tags(tag_name):
    2. 
  
  
  2.     print 'begin outer function.'
    3. 
  
  
  3.     def wrapper_(func):
    4. 
  
  
  4.         print "begin of inner wrapper function."
    5. 
  
  
  5.         def wrapper(*args, **kwargs):
    6. 
  
  
  6.             content = func(*args, **kwargs)
    7. 
  
  
  7.             print "<{tag}>{content}".format(tag=tag_name, content=content)
    8. 
  
  
  8.         print 'end of inner wrapper function.'
    9. 
  
  
  9.         return wrapper
    10. 
  
  
  10.     print 'end of outer function'
    11. 
  
  
  11.     return wrapper_
    12. 
  
  
  12. 
  
  
  13. @html_tags('b')
    14. 
  
  
  14. def hello(name='Toby'):
    15. 
  
  
  15.     return 'Hello {}!'.format(name)
    16. 
  
  
  16. 
  
  
  17. hello()
    18. 
  
  
  18. hello() 
    19.

在装饰器中我在各个可能的位置都加上了print语句，用于记录被调用的情况。你知道他们***打印出来的顺序吗?如果你心里没底，那么***不要在装饰器函数之外添加逻辑功能，否则这个装饰器就不受你控制了。以下是输出结果：

 
 
    
  
  
  1. begin outer function.
    2. 
  
  
  2. end of outer function
    3. 
  
  
  3. begin of inner wrapper function.
    4. 
  
  
  4. end of inner wrapper function.
    5. 
  
  
  5. Hello Toby!
    6. 
  
  
  6. Hello Toby! 
    7.

错误的函数签名和文档

装饰器装饰过的函数看上去名字没变，其实已经变了。

 
 
    
  
  
  1. def logging(func):
    2. 
  
  
  2.     def wrapper(*args, **kwargs):
    3. 
  
  
  3.         """print log before a function."""
    4. 
  
  
  4.         print "[DEBUG] {}: enter {}()".format(datetime.now(), func.__name__)
    5. 
  
  
  5.         return func(*args, **kwargs)
    6. 
  
  
  6.     return wrapper
    7. 
  
  
  7. 
  
  
  8. @logging
    9. 
  
  
  9. def say(something):
    10. 
  
  
  10.     """say something"""
    11. 
  
  
  11.     print "say {}!".format(something)
    12. 
  
  
  12. 
  
  
  13. print say.__name__  # wrapper 
    14.

为什么会这样呢?只要你想想装饰器的语法糖@代替的东西就明白了。@等同于这样的写法。

 
 
    
  
  
  1. say = logging(say)
    2.

logging其实返回的函数名字刚好是wrapper，那么上面的这个语句刚好就是把这个结果赋值给say，say的__name__自然也就是wrapper了，不仅仅是name，其他属性也都是来自wrapper，比如doc，source等等。

使用标准库里的functools.wraps，可以基本解决这个问题。

 
 
    
  
  
  1. from functools import wraps
    2. 
  
  
  2. 
  
  
  3. def logging(func):
    4. 
  
  
  4.     @wraps(func)
    5. 
  
  
  5.     def wrapper(*args, **kwargs):
    6. 
  
  
  6.         """print log before a function."""
    7. 
  
  
  7.         print "[DEBUG] {}: enter {}()".format(datetime.now(), func.__name__)
    8. 
  
  
  8.         return func(*args, **kwargs)
    9. 
  
  
  9.     return wrapper
    10. 
  
  
  10. 
  
  
  11. @logging
    12. 
  
  
  12. def say(something):
    13. 
  
  
  13.     """say something"""
    14. 
  
  
  14.     print "say {}!".format(something)
    15. 
  
  
  15. 
  
  
  16. print say.__name__  # say
    17. 
  
  
  17. print say.__doc__ # say something 
    18.

看上去不错!主要问题解决了，但其实还不太***。因为函数的签名和源码还是拿不到的。

 
 
    
  
  
  1. import inspect
    2. 
  
  
  2. print inspect.getargspec(say)  # failed
    3. 
  
  
  3. print inspect.getsource(say)  # failed 
    4.

如果要彻底解决这个问题可以借用第三方包，比如wrapt。后文有介绍。

不能装饰@staticmethod 或者 @classmethod

当你想把装饰器用在一个静态方法或者类方法时，不好意思，报错了。

 
 
    
  
  
  1. class Car(object):
    2. 
  
  
  2.     def __init__(self, model):
    3. 
  
  
  3.         self.model = model
    4. 
  
  
  4. 
  
  
  5.     @logging  # 装饰实例方法，OK
    6. 
  
  
  6.     def run(self):
    7. 
  
  
  7.         print "{} is running!".format(self.model)
    8. 
  
  
  8. 
  
  
  9.     @logging  # 装饰静态方法，Failed
    10. 
  
  
  10.     @staticmethod
    11. 
  
  
  11.     def check_model_for(obj):
    12. 
  
  
  12.         if isinstance(obj, Car):
    13. 
  
  
  13.             print "The model of your car is {}".format(obj.model)
    14. 
  
  
  14.         else:
    15. 
  
  
  15.             print "{} is not a car!".format(obj)
    16. 
  
  
  16. 
  
  
  17. """
    18. 
  
  
  18. Traceback (most recent call last):
    19. 
  
  
  19. ...
    20. 
  
  
  20.   File "example_4.py", line 10, in logging
    21. 
  
  
  21.     @wraps(func)
    22. 
  
  
  22.   File "C:\Python27\lib\functools.py", line 33, in update_wrapper
    23. 
  
  
  23.     setattr(wrapper, attr, getattr(wrapped, attr))
    24. 
  
  
  24. AttributeError: 'staticmethod' object has no attribute '__module__'
    25. 
  
  
  25. """ 
    26.

前面已经解释了@staticmethod这个装饰器，其实它返回的并不是一个callable对象，而是一个staticmethod对象，那么它是不符合装饰器要求的(比如传入一个callable对象)，你自然不能在它之上再加别的装饰器。要解决这个问题很简单，只要把你的装饰器放在@staticmethod之前就好了，因为你的装饰器返回的还是一个正常的函数，然后再加上一个@staticmethod是不会出问题的。

 
 
    
  
  
  1. class Car(object):
    2. 
  
  
  2.     def __init__(self, model):
    3. 
  
  
  3.         self.model = model
    4. 
  
  
  4. 
  
  
  5.     @staticmethod
    6. 
  
  
  6.     @logging  # 在@staticmethod之前装饰，OK
    7. 
  
  
  7.     def check_model_for(obj):
    8. 
  
  
  8.         pass 
    9.

如何优化你的装饰器

嵌套的装饰函数不太直观，我们可以使用第三方包类改进这样的情况，让装饰器函数可读性更好。

decorator.py

decorator.py 是一个非常简单的装饰器加强包。你可以很直观的先定义包装函数wrapper()，再使用decorate(func, wrapper)方法就可以完成一个装饰器。

 
 
    
  
  
  1. from decorator import decorate
    2. 
  
  
  2. 
  
  
  3. def wrapper(func, *args, **kwargs):
    4. 
  
  
  4.     """print log before a function."""
    5. 
  
  
  5.     print "[DEBUG] {}: enter {}()".format(datetime.now(), func.__name__)
    6. 
  
  
  6.     return func(*args, **kwargs)
    7. 
  
  
  7. 
  
  
  8. def logging(func):
    9. 
  
  
  9.     return decorate(func, wrapper)  # 用wrapper装饰func 
    10.

你也可以使用它自带的@decorator装饰器来完成你的装饰器。

 
 
    
  
  
  1. from decorator import decorator
    2. 
  
  
  2. 
  
  
  3. @decorator
    4. 
  
  
  4. def logging(func, *args, **kwargs):
    5. 
  
  
  5.     print "[DEBUG] {}: enter {}()".format(datetime.now(), func.__name__)
    6. 
  
  
  6.     return func(*args, **kwargs) 
    7.

decorator.py实现的装饰器能完整保留原函数的name，doc和args，唯一有问题的就是inspect.getsource(func)返回的还是装饰器的源代码，你需要改成inspect.getsource(func.__wrapped__)。

wrapt

wrapt是一个功能非常完善的包，用于实现各种你想到或者你没想到的装饰器。使用wrapt实现的装饰器你不需要担心之前inspect中遇到的所有问题，因为它都帮你处理了，甚至inspect.getsource(func)也准确无误。

 
 
    
  
  
  1. import wrapt
    2. 
  
  
  2. 
  
  
  3. # without argument in decorator
    4. 
  
  
  4. @wrapt.decorator
    5. 
  
  
  5. def logging(wrapped, instance, args, kwargs):  # instance is must
    6. 
  
  
  6.     print "[DEBUG]: enter {}()".format(wrapped.__name__)
    7. 
  
  
  7.     return wrapped(*args, **kwargs)
    8. 
  
  
  8. 
  
  
  9. @logging
    10. 
  
  
  10. def say(something): pass 
    11.

使用wrapt你只需要定义一个装饰器函数，但是函数签名是固定的，必须是(wrapped, instance, args, kwargs)，注意第二个参数instance是必须的，就算你不用它。当装饰器装饰在不同位置时它将得到不同的值，比如装饰在类实例方法时你可以拿到这个类实例。根据instance的值你能够更加灵活的调整你的装饰器。另外，args和kwargs也是固定的，注意前面没有星号。在装饰器内部调用原函数时才带星号。

如果你需要使用wrapt写一个带参数的装饰器，可以这样写。

 
 
    
  
  
  1. def logging(level):
    2. 
  
  
  2.     @wrapt.decorator
    3. 
  
  
  3.     def wrapper(wrapped, instance, args, kwargs):
    4. 
  
  
  4.         print "[{}]: enter {}()".format(level, wrapped.__name__)
    5. 
  
  
  5.         return wrapped(*args, **kwargs)
    6. 
  
  
  6.     return wrapper
    7. 
  
  
  7. 
  
  
  8. @logging(level="INFO")
    9. 
  
  
  9. def do(work): pass 
    10.

关于wrapt的使用，建议查阅官方文档，在此不在赘述。

  • http://wrapt.readthedocs.io/e...

小结

Python的装饰器和Java的注解(Annotation)并不是同一回事，和C#中的特性(Attribute)也不一样，完全是两个概念。

装饰器的理念是对原函数、对象的加强，相当于重新封装，所以一般装饰器函数都被命名为wrapper()，意义在于包装。函数只有在被调用时才会发挥其作用。比如@logging装饰器可以在函数执行时额外输出日志，@cache装饰过的函数可以缓存计算结果等等。

而注解和特性则是对目标函数或对象添加一些属性，相当于将其分类。这些属性可以通过反射拿到，在程序运行时对不同的特性函数或对象加以干预。比如带有Setup的函数就当成准备步骤执行，或者找到所有带有TestMethod的函数依次执行等等。

至此我所了解的装饰器已经讲完，但是还有一些内容没有提到，比如装饰类的装饰器。有机会再补充。谢谢观看。

文章标题：详解Python的装饰器
标题网址：http://www.shufengxianlan.com/qtweb/news6/379906.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

解决方案知识

行业网站建设

网站建设公司　　 　主机租用　　 　成都app软件开发　　 　快照排名　　 　成都做网站　　 　信衡房屋鉴定　　 　成都模板网站　　 　研学实践　　 　混凝土搅拌车　　 　雅安电信机房　　 　成都微信小程序开发　　 　高县网站建设　　 　成都石膏隔墙板　　 　路面机械及配件　　 　四川瑞杰　　 　云服务器　　 　产品包装设计　　 　主动防护网　　 　成都酒店服定制　　 　南充网站建设