python装饰器

其实总体说起来，装饰器其实也就是一个函数，一个用来包装函数的函数，返回一个修改之后的函数对象，将其重新赋值原来的标识符，并永久丧失对原始函数对象的访问。

2. 装饰器语法

(1)无参数装饰器

def deco(func):
    print func
    return func
@deco
def foo():pass
foo()

第一个函数deco是装饰函数，它的参数就是被装饰的函数对象。我们可以在deco函数内对传入的函数对象做一番“装饰”，然后返回这个对象（记住一定要返回 ，不然外面调用foo的地方将会无函数可用。实际上此时foo=deco(foo)）

我写了个小例子，检查函数有没有说明文档：

def deco_functionNeedDoc(func):
    if func.__doc__ == None :
        print func, "has no __doc__, it's a bad habit."
    else:
        print func, ':', func.__doc__, '.'
    return func
@deco_functionNeedDoc
def f():
    print 'f() Do something'
@deco_functionNeedDoc
def g():
    'I have a __doc__'
    print 'g() Do something'
f()
g()

(2)有参数装饰器

def decomaker(arg):
    '通常对arg会有一定的要求'
    """由于有参数的decorator函数在调用时只会使用应用时的参数
       而不接收被装饰的函数做为参数，所以必须在其内部再创建
       一个函数
    """
    def newDeco(func):    #定义一个新的decorator函数
        print func, arg
        return func
    return newDeco
@decomaker(deco_args)
def foo():pass
foo()

第一个函数decomaker是装饰函数，它的参数是用来加强“加强装饰”的。由于此函数并非被装饰的函数对象，所以在内部必须至少创建一个接受被装饰函数的函数，然后返回这个对象（实际上此时foo=decomaker(arg)(foo)）

这个我还真想不出什么好例子，还是见识少啊，只好借用同步锁的例子了：

def synchronized(lock):
    """锁同步装饰方法
    ！lock必须实现了acquire和release方法
    """
    def sync_with_lock(func):
        def new_func(*args, **kwargs):
            lock.acquire()
            try:
                return func(*args, **kwargs)
            finally:
                lock.release()
        new_func.func_name = func.func_name
        new_func.__doc__ = func.__doc__
        return new_func
    return sync_with_lock
@synchronized(__locker)
def update(data):
"""更新计划任务"""
    tasks = self.get_tasks()
    delete_task = None
    for task in tasks:
        if task[PLANTASK.ID] == data[PLANTASK.ID]:
            tasks.insert(tasks.index(task), data)
            tasks.remove(task)
            delete_task = task
    r, msg = self._refresh(tasks, delete_task)
    return r, msg, data[PLANTASK.ID]

调用时还是updae(data)。

同时还可以将多个装饰器组合 使用：

@synchronized(__locker)
@deco_functionNeedDoc
def f():
    print 'f() Do something'

学后的总是感觉就是：装饰器可以让函数轻装上阵，更重要的是将函数的约束放置于接口处，使意图更加明了，同时又不增加调用者的负担。