python装饰器

myfunc=wrapper(myfunc)是一种很常见的修改其它函数的方法。从python2.4开始,可以在定义myfunc的def语句之前写@wrapper。

这些封装函数就被称为装饰器Decorator,其主要用途是包装另一个函数或类。这种包装的首要目的是透明的修改或增强被包装对象的行为。

1.基本语法

有一个很简单的函数:

def square(x):
    return x*x

如果想追踪函数的执行情况:

def square(x):
    debug_log=open(‘debug_log.txt‘,‘w‘)
    debug_log.write(‘Calling %s\n‘%square.__name__)
    debug_log.close()
    return x*x

功能上实现了追踪,但如果要追踪很多函数的执行情况,显然不可能为每个函数都添加追踪代码,可以将追踪代码提取出来:

def trace(func,*args,**kwargs):
    debug_log=open(‘debug_log.txt‘,‘w‘)
    debug_log.write(‘Calling %s\n‘%func.__name__)
    result=func(*args,**kwargs)
    debug_log.write(‘%s returned %s\n‘%(func.__name__,result))
    debug_log.close()
trace(square,2)

这样调用square()变成了调用trace(square),如果square()在N处被调用了,你要修改N次,显然不够简洁,我们可以使用闭包函数使square()发挥trace(square)的功能

def trace(func):
    def callfunc(*args,**kwargs):
        debug_log=open(‘debug_log.txt‘,‘w‘)
        debug_log.write(‘Calling %s: %s ,%s\n‘%(func.__name__,args,kwargs))
        result=func(*args,**kwargs)
        debug_log.write(‘%s returned %s\n‘%(func.__name__,result))
        debug_log.close()
    return callfunc

这样,可以写成:

square=trace(square)  
square()

或者

def trace(func):
    def callfunc(*args,**kwargs):
        debug_log=open(‘debug_log.txt‘,‘w‘)
        debug_log.write(‘Calling %s: %s ,%s\n‘%(func.__name__,args,kwargs))
        result=func(*args,**kwargs)
        debug_log.write(‘%s returned %s\n‘%(func.__name__,result))
        debug_log.close()
        return result
    return callfunc
@trace
def square(x):
    return x*x 

还可以根据自己的需求关闭或开启追踪功能:

enable_trace=False
def trace(func):
    if enable_trace:
        def callfunc(*args,**kwargs):
            debug_log=open(‘debug_log.txt‘,‘w‘)
            debug_log.write(‘Calling %s: %s ,%s\n‘%(func.__name__,args,kwargs))
            result=func(*args,**kwargs)
            debug_log.write(‘%s returned %s\n‘%(func.__name__,result))
            debug_log.close()
        return callfunc
    else:
        return func
@trace
def square(x):
    return x*x 

这样,利用enable_trace变量禁用追踪时,使用装饰器不会增加性能负担。

使用@时,装饰器必须出现在需要装饰的函数或类定义之前的单独行上。可以同时使用多个装饰器。

@foo
@bar
@spam
def func():
    pass

等同于

func=foo(bar(spam(func)))

2.接收参数的装饰器

装饰器也可以接收参数,比如一个注册函数:

event_handlers={}
def event_handler(event):
    def register_func(func):
        event_handlers[event]=func
        return func
    return register_func
@event_handler(‘BUTTON‘)
def func():
    pass

相当于

temp=event_handler(‘BUTTON‘)
func=temp(func)

这样的装饰器函数接受带有@描述符的参数,调用后返回接受被装饰函数作为参数的函数。

3.类装饰器

类装饰器接受类为参数并返回类作为输出。

registry={}
def register(cls):
    registry[cls.__clsid__]=cls
    return cls
@register
class Foo(object):
    __clsid__=‘1‘
    def bar(self):
        pass

4.python中一些应用

4.1 刷新函数中默认参数值:

def packitem(x,y=[]):    
    y.append(x)
    print y

当用列表作为函数参数的默认值时,会发生难以预料的事情。

>>> packitem(1)
[1]
>>> packitem(2)
[1, 2]
>>> packitem(3)
[1, 2, 3]

因为python会为函数的可选参数计算默认值,但只做一次,所以每次append元素都是向同一个列表中添加,显然不是我们的本意。

一般情况下,python推荐不使用可变的默认值,惯用解决方法是:

def packitem(x,y=None):
    if y is None:
        y=[]
    y.append(x)
    print y

还有一种解决方法,就是使用装饰器了:

def fresh(f):
    d=f.func_defaults
    def refresh(*args,**kwargs):
        f.func_defaults=copy.deepcopy(d)
        return f(*args,**kwargs)
    return refresh
@fresh
def packitem(x,y=[]):
    y.append(x)
    print y

用装饰器函数深拷贝被装饰函数的默认参数。

4.2 python有几个内置装饰器staticmethod,classmethod,property,作用分别是把类中定义的实例方法变成静态方法、类方法和类属性。

静态方法可以用来做为有别于__init__的方法来创建实例。

class Date(object):
    def __init__(self,year,month,day):
        self.year=year
        self.month=month
        self.day=day
    @staticmethod
    def now():
        t=time.localtime()
        return Date(t.year,t.mon,t.day)
    @staticmethod
    def tomorrow():
        t=time.localtime(time.time()+86400)
        return Date(t.year,t.mon,t.day)
now=Date.now()
tom=Date.tomorrow()

类方法可以把类本身作为对象进行操作:

如果创建一个Date的子类:

class EuroDate(Date):
    pass

EuroDate.now()产生是一个Date实例而不是EuroDate实例,为避免这种情况,可以:

class Date(object):
    @classmethod
    def now(cls):
        t=time.localtime()
        return cls(t.year,t.mon,t.day)

这样产生的就是子类对象了。

特性可以用函数来模拟属性。

class Rectangular(object):
    def __init__(self,width,height):
        self.width=width
        self.height=height
    @property
    def area(self):
        return self.width*self.height

r=Rectangular(2,3)
print r.area

4.3 functools模块中定义的@wraps(func)可以将函数func的名称,文档字符串等属性传递给要定义的包装器函数。

装饰器包装函数可能会破坏与文档字符串相关的帮助功能:

def wrap(func):
    def call(*args,**kwargs):
        return func(*args,**kwargs)
    return call
@wrap
def foo():
    ‘‘‘this is a func‘‘‘
    pass
print foo.__doc__
print foo.__name__

结果是

None
call

 解决办法是编写可以传递函数名称和文档字符串的装饰器函数:

def wrap(func):
    def call(*args,**kwargs):
        return func(*args,**kwargs)
    call.__doc__=func.__doc__
    call.__name__=func.__name__
    return call
@wrap
def foo():
    ‘‘‘this is a func‘‘‘
    pass
print foo.__doc__
print foo.__name__

结果正常:

this is a func
foo

functools的wraps就提供这个功能:

from functools import wraps
def wrap(func):
    @wraps(func)
    def call(*args,**kwargs):
        return func(*args,**kwargs)
    return call
@wrap
def foo():
    ‘‘‘this is a func‘‘‘
    pass
print foo.__doc__
print foo.__name__ 

4.4 contexlib模块中定义的contextmanager(func)可以根据func创建一个上下文管理器。

from contextlib import contextmanager
@contextmanager
def listchange(alist):
    listcopy=list(alist)
    yield listcopy
    alist[:]=listcopy
alist=[1,2,3]
with listchange(alist) as listcopy:
    listcopy.append(5)
    listcopy.append(4)
print alist

  

python装饰器,布布扣,bubuko.com

python装饰器

上一篇:http 各个状态码及对应的java 编程


下一篇:java 泛型学习