python--装饰器
装饰器：对函数的包装
1--被装饰的函数不带参数
#"""无参数调用decorator声明时必须有一个参数，这个参数将接收要装饰的方法""" def deco(func):#deco对func进行包装 ... print 'start' ... func() ... print 'end' ... return func ... >>> @deco ... def my(): ... print 'is my' ... start is my end #注意：当使用上述方法定义一个decorator方法时，函数体内的额外操作只在被装饰的函数首次调用时执行, >>> my() is my #如果要保证额外操作在每次调用被装饰的函数时都执行，需要换成如下的写法： def deco(func): ... def wrapfunc(): ... print 'start' ... func() ... print 'end' ... return wrapfunc ... >>> @deco ... def myfunc(): ... print 'is myfunc' ... >>> myfunc() start is myfunc end
2--被装饰函数带参数
def deco(func): def newdeco(a, b):#被装饰函数的参数 print 'start' ret = func(a, b)#func被装饰函数 print 'end' return ret return newdeco >>> >>> @deco def myfunc(a, b): res = a + b print 'a + b = ',res >>> myfunc(10, 20) start a + b = 30 end
3--被装饰函数，所带参数不确定
def deco(func): def newdeco(*args, **kwargs): print 'start' print 'args = ',args print 'kwargs = ', kwargs res = func(*args, **kwargs) print 'end' return res return newdeco >>> @deco def myfunc(a, b):#被装饰函数有两个参数 res = a + b print "a + b = ", res >>> myfunc(1, 1) start args = (1, 1) kwargs = {} a + b = 2 end >>> @deco def myfunc(a, b, c ):#3个参数 res = a + b + c print "a + b +c = ", res >>> myfunc(1, 2, 3) start args = (1, 2, 3) kwargs = {} a + b +c = 6 end >>> @deco def myfunc(*args,**kwargs):#参数是列表与字典 sum = 0 i = 0 for eachnum in args: sum += eachnum print 'args[%d] = %d' %(i, eachnum) i += 1 print 'sum = ', sum for eachkey in kwargs.keys(): print '%s = %s' % (eachkey, kwargs[eachkey]) >>> myfunc(1, 2, 3,lady = 'gaga',shakira = 'isabel') start args = (1, 2, 3) kwargs = {'lady': 'gaga', 'shakira': 'isabel'} args[0] = 1 args[1] = 2 args[2] = 3 sum = 6 lady = gaga shakira = isabel end
4--装饰器带参数
这个装饰器参数是包在被装饰函数的外面的
def deco(args): def newdeco(func): def wrapfunc(): print 'in wrapfunc start,args =',args func() print 'end ****' return wrapfunc return newdeco >>> @deco("hello this is args of decorator") def myfunc():print 'is myfunc' >>> myfunc() in wrapfunc start,args = hello this is args of decorator is myfunc end ****
5--装饰器带参数（参数为类）
>>> class locker: def __init__(self): print 'locker.__init__()' @staticmethod#类的静态方法 def acquire(): print 'this is staticmethod method' @staticmethod def release(): print 'this is other staticmethod method' >>> def deco(cls)： """ 装饰器的参数是个类，通过这个类，调用他的静态方法，装饰func()""" def newdeco(func): def wrapfunc(): print 'in wrapfunc' cls.acquire() try: return func() finally: cls.release() return wrapfunc return newdeco >>> @deco(locker) def myfunc():print 'is myfunc' >>> myfunc() in wrapfunc this is staticmethod method is myfunc this is other staticmethod method
6--用两个装饰器装饰函数
#!/usr/bin/env python # -*- coding: cp936 -*- """ This is decorator.py""" class Father: def __init__(self): print 'is Father.__init__()' @staticmethod def acquire(): print 'is Father.acquire()' @staticmethod def unlock(): print 'is Father.unlock()' class Sun(Father):#locker继承了myclass def __init__(self):#如果不重写__init__()，locker会自动调用父类的init()方法 print 'is Sun.__init__()' @staticmethod def acquire(): print 'is Sun.acquire()' @staticmethod def unlock(): print 'is Sun.unlock()' def deco(cls):#装饰函数的工具 def newdeco(func):#被装饰函数 def wrapfunc(*args, **kwargs):#被装饰函数的参数 print 'in wrapfunc start decorate' cls.acquire() try: return func(*args, **kwargs) finally: cls.unlock() return wrapfunc return newdeco class example:#不从任何父类继承 -- 经典类 @deco(Father)#选择mycalss当做装饰器函数 def myfunc1(self): print 'in example is myfunc1()' @deco(Father) @deco(Sun)#用了两个装饰器 def myfunc2(self, a, b): print 'in example is myfunc2()' res = a + b print 'a + b = ',res def main(): a = example() a.myfunc1()#myfunc1()输出被装饰的结果 print '*'*20 print a.myfunc1() print '*'*20 a.myfunc2(1, 2) if __name__ == '__main__': main() 运行脚本 python decorator.py 输出如下 in wrapfunc start decorate is Father.acquire() in example is myfunc1() is Father.unlock() ******************** in wrapfunc start decorate is Father.acquire() in example is myfunc1() is Father.unlock() None# 这个None -- print 会打印函数的返回值，函数没有返回值，所以打印None ******************** in wrapfunc start decorate#可以看出，装饰器的作用，先用调用Father装饰，所以Father这个装饰工具在最外层，里面的一层是Sun的装饰作用。离函数最近的装饰函数最先起作用，然后逐渐向外一层层的装饰 is Father.acquire() in wrapfunc start decorate is Sun.acquire() in example is myfunc2() a + b = 3 is Sun.unlock() is Father.unlock()
7--装饰的函数有返回值
参考：http://www.cnblogs.com/Jerry-Chou/archive/2012/05/23/2515004.html
def deco(func): def wrapfunc(): now = time() func() times = time() - now return times return wrapfunc @deco def my(): sum = 0 for i in range(100): sum +=i print 'sum = ',sum return sum >>> my() sum = 4950 0.016000032424926758 >>> print my() sum = 4950 0.0309998989105 >>> m = my() sum = 4950 >>> m 0.015999794006347656
my()这个函数，是有返回值的，返回sum,但是由于没有在装饰器中返回这个sum,所以运行my()这个被装饰的函数后，找不到他本身的返回值了
可以在wrapfunc()中返回这个sum
>>> def deco(func): def wrapfunc(): list = []#创建一个列表，存放多个返回值,或者返回一个字典，可以通过key来索引值，或者将返回值放在全局变量中 now = time() res = func() list.append(res) times = time() - now list.append(times) return list return wrapfunc >>> @deco def my(): sum = 0 for i in range(100): sum +=i print 'sum = ',sum return sum >>> my() sum = 4950 [4950, 0.04699993133544922]
8--example--利用装饰器计算函数调用时间
有3个数学函数，比较用单线程运行这3个函数，用多线程运行这3个函数所用时间
#!/usr/bin/env python # -*- coding: cp936 -*- """ This is mtfacfib.py""" from time import ctime, sleep, time import threading class MyThread (threading.Thread ):#线程类的子类 def __init__(self, func, args, name = ''): threading.Thread.__init__(self) self.name = name self.func = func self.args = args def getResult(self): return self.res def run(self): print 'starting', self.func.__name__, 'at:',\ ctime() #sleep(1) self.res = apply(self.func, self.args)#func函数运行的结果 print self.func.__name__, 'finished at:',ctime() """ This is the decorator""" def deco(func): def wrapfunc(): now = time() func() dict[func.__name__ + '_time'] = time() - now #return dict return wrapfunc def fib(x): sleep(0.005) if x < 2: return 1 return (fib(x - 2) + fib(x - 1)) def fac(x): sleep(0.1) if x < 2:return 1 return (x*fac(x-1)) def sum(x): sleep(0.1) if x < 2:return 1 return (x + sum(x-1)) """ data """ n = 12 dict = {} ssum = 0 funcs = [fib, fac, sum]#list nfuncs = range(len(funcs)) threads = [] @deco def calculate_single():#统计单线程时间 for i in nfuncs: print 'starting',funcs[i].__name__,'at:',\ ctime() res = funcs[i](n) print funcs[i].__name__, '=', res print funcs[i].__name__,'finished at:',\ ctime() #return res @deco def calculate_multiple():#统计多线程时间 for i in nfuncs: threads[i].start()#启动线程 sleep(1) for i in nfuncs: threads[i].join()#等待线程结束 print funcs[i].__name__, '=', threads[i].getResult() def main(): print '*** SINGLE THREAD***' calculate_single() print '\n*** MULTIPLE THREADS***' for i in nfuncs:#创建线程，建立时挂起 t = MyThread(funcs[i], (n,), funcs[i]) threads.append(t) calculate_multiple() print '*'*10, 'all done', '*'*10 for i in dict.keys(): print i,'=', dict[i] if dict['calculate_single_time'] > dict['calculate_multiple_time']: print 'single time > multiple time' else: print 'single time < multiple time' if __name__ == '__main__': main() 运行结果 python mtfacfib.py *** SINGLE THREAD*** starting fib at: Tue Sep 11 11:45:10 2012 fib = 233 fib finished at: Tue Sep 11 11:45:18 2012 starting fac at: Tue Sep 11 11:45:18 2012 fac = 479001600 fac finished at: Tue Sep 11 11:45:19 2012 starting sum at: Tue Sep 11 11:45:19 2012 sum = 78 sum finished at: Tue Sep 11 11:45:21 2012 *** MULTIPLE THREADS*** starting fib at: Tue Sep 11 11:45:21 2012 starting fac at: Tue Sep 11 11:45:22 2012 starting sum at: Tue Sep 11 11:45:23 2012 fac finished at: Tue Sep 11 11:45:23 2012 sum finished at: Tue Sep 11 11:45:24 2012 fib finished at: Tue Sep 11 11:45:28 2012 fib = 233 fac = 479001600 sum = 78 ********** all done ********** calculate_single_time = 10.0780000687 calculate_multiple_time = 7.31299996376 single time > multiple time
