Python装饰器详解

你是个笨猫

哈哈

闭包

想要理解Python中的装饰器，需要先理解闭包（closure）这一概念。

在计算机科学中，闭包是引用了自由变量的函数。这个被引用的自由变量将和这个函数一同存在，即使已经离开了创造它的环境也不例外。

概念比较抽象，举个例子来说明一下：

# print_msg是外围函数
def print_msg():
    msg = "I'm closure"
    # printer是嵌套函数
    def printer():
        print(msg)
    return printer
# 这里获得的就是一个闭包
closure = print_msg()
# 输出 I'm closure
closure()

msg是一个局部变量，在print_msg函数执行之后应该就不会存在了。但是嵌套函数引用了这个变量，将这个局部变量封闭在了嵌套函数中，这样就形成了一个闭包。

接下来看装饰器
一个普通的装饰器如下所示：

import functools
def log(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print('call %s():' % func.__name__)
        print('args = {}'.format(*args))
        return func(*args, **kwargs)
    return wrapper
def test(p):
    print(test.__name__ + " param: " + p)
test("I'm a param")

@语法只是将函数传入装饰器函数，并无神奇之处。

值得注意的是@functools.wraps(func)，这是python提供的装饰器。它能把原函数的元信息拷贝到装饰器里面的 func 函数中。函数的元信息包括docstring、name、参数列表等等。可以尝试去除@functools.wraps(func)，你会发现test.__name__的输出变成了wrapper。

带参数的装饰器
装饰器允许传入参数，一个携带了参数的装饰器将有三层函数，如下所示：

import functools
def log_with_param(text):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            print('call %s():' % func.__name__)
            print('args = {}'.format(*args))
            print('log_param = {}'.format(text))
            return func(*args, **kwargs)
        return wrapper
    return decorator
@log_with_param("param")
def test_with_param(p):
    print(test_with_param.__name__)

上面的log_with_param是允许带参数的装饰器。它实际上是对原有装饰器的一个函数封装，并返回一个装饰器。我们可以将它理解为一个含有参数的闭包。当我们使用@log_with_param(text="xxx")调用的时候，Python能够发现这一层的封装，并把参数传递到装饰器的环境中。

类装饰器

类装饰器本质上和函数装饰器原理、作用相同，都是为其它函数增加额外的功能。但是相比于函数装饰器，类装饰器具有灵活度大、高内聚、封装性等优点。使用类装饰器可以直接依靠类内部的__call__方法来实现，当使用 @ 形式将类装饰器附加到函数上时，就会调用类装饰器的__call__方法。而不需要向函数装饰器那样，在装饰器函数中定义嵌套函数，来实现装饰功能。

lass Foo(object):
    def __init__(self, func):
    self._func = func
def __call__(self):
    print ('class decorator runing')
    self._func()
    print ('class decorator ending')
def bar():
    print ('bar')
bar()

接下来看一下Python常用的内置装饰器吧

1。@property

@property 修饰，就是将方法，变成一个属性来使用。

class A():
  @property
  def pfunc(self):
    return self.value
  @pfunc.setter
  def pfunc(self,value):
    self.value = value
  @property
  def pfunc1(self):
    print('this is property')
if __name__=="__main__":
  A.pfunc = 9
  print A.pfunc
  A.pfunc1

2。@classmethod

带修饰类方法：cls做为方法的第一个参数，隐式的将类做为对象，传递给方法，调用时无须实例化。

普通函数方法：self做为第一个参数，隐式的将类实例传递给方法，调用方法时，类必须实例化。

class A():
  def func(self,x,y):
    return x * y
  @classmethod
  def cfunc(cls,x,y):
    return x * y
if __name__=="__main__":
  print A().func(5,5)
  print A.cfunc(4,5)

3。@staticmethod

@staticmethod 返回函数的静态方法。该方法不强制要求传递参数

1)是把函数嵌入到类中的一种方式，函数就属于类，同时表明函数不需要访问这个类

2)使用修饰服，修饰方法，不需要实例化

class A():
  def func(self,x,y):
    return x * y