雖然用python用了很久了，但是主要還是寫一些模型或者算子，對于python中的高級(jí)特性用的不多，但是時(shí)常閱讀大牛的代碼或者框架源碼，其中python特性應(yīng)用的非常流暢，所以今天決定與python中的裝飾器@，做個(gè)了斷！！

Python中的@：

援引廖雪峰老師對裝飾器的解釋以及一些自己對裝飾器的理解：

python中在代碼運(yùn)行期間動(dòng)態(tài)增加功能的方式，稱之為“裝飾器”（Decorator）。@是裝飾器的語法。裝飾器是在函數(shù)調(diào)用之上的修飾，這些修飾僅是當(dāng)聲明一個(gè)函數(shù)或者方法的時(shí)候，才會(huì)應(yīng)用的額外調(diào)用。 我們可以用裝飾器來增加計(jì)時(shí)邏輯來檢測性能，或者引入日志等等。

函數(shù)也是一個(gè)對象，而且函數(shù)對象可以被賦值給變量，所以，通過變量也能調(diào)用該函數(shù)。

>>> def now():
...   print('2015-3-25')
...
>>> f = now
>>> f()
2015-3-25

函數(shù)對象有一個(gè)__name__屬性，可以拿到函數(shù)的名字：

>>> now.__name__
'now'
>>> f.__name__
'now'

現(xiàn)在，假設(shè)我們要增強(qiáng)now()函數(shù)的功能，比如，在函數(shù)調(diào)用前后自動(dòng)打印日志，但又不希望修改now()函數(shù)的定義。本質(zhì)上，decorator就是一個(gè)返回函數(shù)的高階函數(shù)。所以，我們要定義一個(gè)能打印日志的decorator，可以定義如下：

def log(func):
  def wrapper(*args, **kw):
    print('call %s():' % func.__name__)
    return func(*args, **kw)
  return wrapper

觀察上面的log，因?yàn)樗且粋€(gè)decorator，所以接受一個(gè)函數(shù)作為參數(shù)，并返回一個(gè)函數(shù)。我們要借助Python的@語法，把decorator置于函數(shù)的定義處：

@log
def now():
  print('2015-3-25')

調(diào)用now()函數(shù)，不僅會(huì)運(yùn)行now()函數(shù)本身，還會(huì)在運(yùn)行now()函數(shù)前打印一行日志：

>>> now()
call now():
2015-3-25

把@log放到now()函數(shù)的定義處，相當(dāng)于執(zhí)行了語句：

now = log(now)

由于log()是一個(gè)decorator，返回一個(gè)函數(shù)，所以，原來的now()函數(shù)仍然存在，只是現(xiàn)在同名的now變量指向了新的函數(shù)，于是調(diào)用now()將執(zhí)行新函數(shù)，即在log()函數(shù)中返回的wrapper()函數(shù)。

wrapper()函數(shù)的參數(shù)定義是(*args, **kw)，因此，wrapper()函數(shù)可以接受任意參數(shù)的調(diào)用。在wrapper()函數(shù)內(nèi)，首先打印日志，再緊接著調(diào)用原始函數(shù)。

如果decorator本身需要傳入?yún)?shù)，那就需要編寫一個(gè)返回decorator的高階函數(shù)，寫出來會(huì)更復(fù)雜。比如，要自定義log的文本：

def log(text):
  def decorator(func):
    def wrapper(*args, **kw):
      print('%s %s():' % (text, func.__name__))
      return func(*args, **kw)
    return wrapper
  return decorator

這個(gè)3層嵌套的decorator用法如下：

@log('execute')
def now():
  print('2015-3-25')

執(zhí)行結(jié)果如下：

>>> now()
execute now():
2015-3-25

和兩層嵌套的decorator相比，3層嵌套的效果是這樣的：

>>> now = log('execute')(now)

我們來剖析上面的語句，首先執(zhí)行l(wèi)og('execute')，返回的是decorator函數(shù)，再調(diào)用返回的函數(shù)，參數(shù)是now函數(shù)，返回值最終是wrapper函數(shù)。

以上兩種decorator的定義都沒有問題，但還差最后一步。因?yàn)槲覀冎v了函數(shù)也是對象，它有__name__等屬性，但你去看經(jīng)過decorator裝飾之后的函數(shù)，它們的__name__已經(jīng)從原來的'now'變成了'wrapper'：

>>> now.__name__
'wrapper'

因?yàn)榉祷氐哪莻€(gè)wrapper()函數(shù)名字就是'wrapper'，所以，需要把原始函數(shù)的__name__等屬性復(fù)制到wrapper()函數(shù)中，否則，有些依賴函數(shù)簽名的代碼執(zhí)行就會(huì)出錯(cuò)。

不需要編寫wrapper.__name__ = func.__name__這樣的代碼，Python內(nèi)置的functools.wraps就是干這個(gè)事的，所以，一個(gè)完整的decorator的寫法如下：

import functools 
def log(func):
  @functools.wraps(func)
  def wrapper(*args, **kw):
    print('call %s():' % func.__name__)
    return func(*args, **kw)
  return wrapper

或者針對帶參數(shù)的decorator：

import functools 
def log(text):
  def decorator(func):
    @functools.wraps(func)
    def wrapper(*args, **kw):
      print('%s %s():' % (text, func.__name__))
      return func(*args, **kw)
    return wrapper
  return decorator

import functools是導(dǎo)入functools模塊。模塊的概念稍候講解?，F(xiàn)在，只需記住在定義wrapper()的前面加上@functools.wraps(func)即可。

python中常見的@：

@property ：對于類的方法，裝飾器一樣起作用,Python內(nèi)置的@property裝飾器就是負(fù)責(zé)把一個(gè)方法變成屬性調(diào)用的.廣泛應(yīng)用在類的定義中，可以讓調(diào)用者寫出簡短的代碼，同時(shí)保證對參數(shù)進(jìn)行必要的檢查，這樣，程序運(yùn)行時(shí)就減少了出錯(cuò)的可能性。

class Student(object): 
  @property
  def score(self):
    return self._score 
  @score.setter
  def score(self, value):
    if not isinstance(value, int):
      raise ValueError('score must be an integer!')
    if value  0 or value > 100:
      raise ValueError('score must between 0 ~ 100!')
    self._score = value

@property的實(shí)現(xiàn)比較復(fù)雜，我們先考察如何使用。把一個(gè)getter方法變成屬性，只需要加上@property就可以了，此時(shí)，@property本身又創(chuàng)建了另一個(gè)裝飾器@score.setter，負(fù)責(zé)把一個(gè)setter方法變成屬性賦值，于是，我們就擁有一個(gè)可控的屬性操作：

>>> s = Student()
>>> s.score = 60 # OK，實(shí)際轉(zhuǎn)化為s.set_score(60)
>>> s.score # OK，實(shí)際轉(zhuǎn)化為s.get_score()
60
>>> s.score = 9999
Traceback (most recent call last):
 ...
ValueError: score must between 0 ~ 100!

注意到這個(gè)神奇的@property，我們在對實(shí)例屬性操作的時(shí)候，就知道該屬性很可能不是直接暴露的，而是通過getter和setter方法來實(shí)現(xiàn)的。

@staticmethod，@classmethod：@staticmethod返回的是一個(gè)staticmethod類對象，而@classmethod返回的是一個(gè)classmethod類對象。他們都是調(diào)用的是各自的__init__()構(gòu)造函數(shù)。

當(dāng)然應(yīng)用裝飾器不當(dāng)也會(huì)帶來一些問題:

1、位置錯(cuò)誤的代碼

​ 讓我們直接看示例代碼。

def html_tags(tag_name):
  print 'begin outer function.'
  def wrapper_(func):
    print "begin of inner wrapper function."
    def wrapper(*args, **kwargs):
      content = func(*args, **kwargs)
      print "{tag}>{content}/{tag}>".format(tag=tag_name, content=content)
    print 'end of inner wrapper function.'
    return wrapper
  print 'end of outer function'
  return wrapper_ 
@html_tags('b')
def hello(name='Toby'):
  return 'Hello {}!'.format(name)
 
hello()
hello()

在裝飾器中我在各個(gè)可能的位置都加上了print語句，用于記錄被調(diào)用的情況。你知道他們最后打印出來的順序嗎？如果你心里沒底，那么最好不要在裝飾器函數(shù)之外添加邏輯功能，否則這個(gè)裝飾器就不受你控制了。以下是輸出結(jié)果：

begin outer function.
end of outer function
begin of inner wrapper function.
end of inner wrapper function.
b>Hello Toby!/b>
b>Hello Toby!/b>

2、錯(cuò)誤的函數(shù)簽名和文檔

裝飾器裝飾過的函數(shù)看上去名字沒變，其實(shí)已經(jīng)變了。

def logging(func):
  def wrapper(*args, **kwargs):
    """print log before a function."""
    print "[DEBUG] {}: enter {}()".format(datetime.now(), func.__name__)
    return func(*args, **kwargs)
  return wrapper
@logging
def say(something):
  """say something"""
  print "say {}!".format(something) 
print say.__name__ # wrapper

為什么會(huì)這樣呢？想想裝飾器的語法@代替的東西就明白了。@等同于這樣的寫法。

say = logging(say)

logging其實(shí)返回的函數(shù)名字剛好是wrapper，那么上面的這個(gè)語句剛好就是把這個(gè)結(jié)果賦值給say，say的__name__自然也就是wrapper了，不僅僅是name，其他屬性也都是來自wrapper，比如doc，source等等。

使用標(biāo)準(zhǔn)庫里的functools.wraps，可以基本解決這個(gè)問題。

from functools import wraps
 
def logging(func):
  @wraps(func)
  def wrapper(*args, **kwargs):
    """print log before a function."""
    print "[DEBUG] {}: enter {}()".format(datetime.now(), func.__name__)
    return func(*args, **kwargs)
  return wrapper
 
@logging
def say(something):
  """say something"""
  print "say {}!".format(something)
 
print say.__name__ # say
print say.__doc__ # say something

看上去不錯(cuò)！主要問題解決了，但其實(shí)還不太完美。因?yàn)楹瘮?shù)的簽名和源碼還是拿不到的。

import inspect
print inspect.getargspec(say) # failed
print inspect.getsource(say) # failed

如果要徹底解決這個(gè)問題可以借用第三方包，比如wrapt。

3、不能裝飾@staticmethod或者 @classmethod

當(dāng)你想把裝飾器用在一個(gè)靜態(tài)方法或者類方法時(shí)，不好意思，報(bào)錯(cuò)了。

class Car(object):
  def __init__(self, model):
    self.model = model
 
  @logging # 裝飾實(shí)例方法，OK
  def run(self):
    print "{} is running!".format(self.model)
 
  @logging # 裝飾靜態(tài)方法，F(xiàn)ailed
  @staticmethod
  def check_model_for(obj):
    if isinstance(obj, Car):
      print "The model of your car is {}".format(obj.model)
    else:
      print "{} is not a car!".format(obj) 
"""
Traceback (most recent call last):
...
 File "example_4.py", line 10, in logging
  @wraps(func)
 File "C:\Python27\lib\functools.py", line 33, in update_wrapper
  setattr(wrapper, attr, getattr(wrapped, attr))
AttributeError: 'staticmethod' object has no attribute '__module__'
"""

前面已經(jīng)解釋了@staticmethod這個(gè)裝飾器，其實(shí)它返回的并不是一個(gè)callable對象，而是一個(gè)staticmethod對象，那么它是不符合裝飾器要求的（比如傳入一個(gè)callable對象），你自然不能在它之上再加別的裝飾器。要解決這個(gè)問題很簡單，只要把你的裝飾器放在@staticmethod之前就好了，因?yàn)槟愕难b飾器返回的還是一個(gè)正常的函數(shù)，然后再加上一個(gè)@staticmethod是不會(huì)出問題的。

class Car(object):
  def __init__(self, model):
    self.model = model 
  @staticmethod
  @logging # 在@staticmethod之前裝飾，OK
  def check_model_for(obj):
    pass

如何優(yōu)化你的裝飾器：

嵌套的裝飾函數(shù)不太直觀，我們可以使用第三方包類改進(jìn)這樣的情況，讓裝飾器函數(shù)可讀性更好。

decorator.py

decorator.py是一個(gè)非常簡單的裝飾器加強(qiáng)包。你可以很直觀的先定義包裝函數(shù)wrapper()，再使用decorate(func, wrapper)方法就可以完成一個(gè)裝飾器。

from decorator import decorate 
def wrapper(func, *args, **kwargs):
  """print log before a function."""
  print "[DEBUG] {}: enter {}()".format(datetime.now(), func.__name__)
  return func(*args, **kwargs) 
def logging(func):
  return decorate(func, wrapper) # 用wrapper裝飾func

你也可以使用它自帶的@decorator裝飾器來完成你的裝飾器。

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

decorator.py實(shí)現(xiàn)的裝飾器能完整保留原函數(shù)的name，doc和args，唯一有問題的就是inspect.getsource(func)返回的還是裝飾器的源代碼，你需要改成inspect.getsource(func.__wrapped__)。

wrapt

wrapt是一個(gè)功能非常完善的包，用于實(shí)現(xiàn)各種你想到或者你沒想到的裝飾器。使用wrapt實(shí)現(xiàn)的裝飾器你不需要擔(dān)心之前inspect中遇到的所有問題，因?yàn)樗紟湍闾幚砹耍踔羒nspect.getsource(func)也準(zhǔn)確無誤。

import wrapt
# without argument in decorator
@wrapt.decorator
def logging(wrapped, instance, args, kwargs): # instance is must
  print "[DEBUG]: enter {}()".format(wrapped.__name__)
  return wrapped(*args, **kwargs) 
@logging
def say(something): pass

使用wrapt你只需要定義一個(gè)裝飾器函數(shù)，但是函數(shù)簽名是固定的，必須是(wrapped, instance, args, kwargs)，注意第二個(gè)參數(shù)instance是必須的，就算你不用它。當(dāng)裝飾器裝飾在不同位置時(shí)它將得到不同的值，比如裝飾在類實(shí)例方法時(shí)你可以拿到這個(gè)類實(shí)例。根據(jù)instance的值你能夠更加靈活的調(diào)整你的裝飾器。另外，args和kwargs也是固定的，注意前面沒有星號(hào)。在裝飾器內(nèi)部調(diào)用原函數(shù)時(shí)才帶星號(hào)。

如果你需要使用wrapt寫一個(gè)帶參數(shù)的裝飾器，可以這樣寫。

def logging(level):
  @wrapt.decorator
  def wrapper(wrapped, instance, args, kwargs):
    print "[{}]: enter {}()".format(level, wrapped.__name__)
    return wrapped(*args, **kwargs)
  return wrapper 
@logging(level="INFO")
def do(work): pass

Tensorflow中的@:

tensorflow就巧妙應(yīng)用的python的裝飾器，提高了代碼的動(dòng)態(tài)性，也使代碼變得精簡。

@tf_export 的作用是：Provides ways to export symbols to the TensorFlow API.

@tf_contextlib的作用是：A tf_decorator-aware wrapper for `contextlib.contextmanager`.

還有@tf_inspect、@tf_should_use等。

以上為個(gè)人經(jīng)驗(yàn)，希望能給大家一個(gè)參考，也希望大家多多支持腳本之家。如有錯(cuò)誤或未考慮完全的地方，望不吝賜教。