#coding:utf8 #斐波那契数列，第三项起，每一项都等于前两项之和 def memo(func):
cache = {}#闭包
def wrap(*args):
if args not in cache:
cache[args] = func(*args)
return cache[args]
return wrap @memo
def fibonacci(n):
if n<=1:
return 1
return fibonacci(n-1)+fibonacci(n-2) #上楼梯算法，总过n个台阶，一次只能迈a-b个台阶，不能后退，问有几种走法
@memo
def climb(n,steps):
count = 0
if n==0:
count = 1
elif n>0:
for step in steps:
count += climb(n-step,steps)
return count
装饰器的简单应用还是明白的，但是要理解这两个递归算法。
关于函数的元数据，如：f.__name__,指的是def时指定的名字；f.__doc__,指的是函数文档字符串；f.__moudle__,指的是函数所属模块;f.__default__,指的是函数默认值；f.__dict__,指的是属性字典；f.__closure__,指的是函数的闭包。。。这些元数据都是func的属性。
使用装饰器可能会改变func的元数据。
#coding:utf8
from functools import update_wrapper,wraps,WRAPPER_ASSIGNMENTS,WRAPPER_UPDATES def mydecorator(func):
@wraps(func)#第一种
def wrapper(*args,**kw):
'''wrapper function'''
print 'In wrapper'
func(*args,**kw)
#wrapper.__name__ = func.__name__ 第二种
#update_wrapper(wrapper,func,('__name__','__doc__'),('__dict__',))#第四个参数是将func的属性更新到wrap
#第三种：update_wrapper后两个的默认参数分别是('__module__', '__name__', '__doc__')；('__dict__',)
return wrapper @mydecorator
def example():
'''example function'''
print 'In example'
其实就是对处理后的func的属性进行重新赋回原来的值。
定义带参数的装饰器，就是用去判断参数的类型，因为要用过python3的库，所以先略过。
修改装饰器的属性。这样的好处是能够在运行中动态修改，而不是每次都要去装饰器处修改。
给包裹函数增加一个函数，作为包裹函数的属性，使其可以修改闭包中的*变量。
import time
from functools import wraps
import logging def warn(timeout):
timeout = [timeout]#将参数设为只有一个数的list
def decorator(func):
@wraps(func)
def wrapper(*args,**kw):
start = time.time()
res = func(*args,**kw)
used = time.time()-start
if used > timeout[0]:
msg = '%s : %s >%s' %(func.__name__,used,timeout[0])
logging.warn(msg)
return res
def setTimeout(k):#注意这里
timeout[0] = k
wrapper.setTimeout = setTimeout
return wrapper
return decorator from random import randint
@warn(0.5)
def test():
print 'In test'
while randint(0,1):
print 'I am sleep'
time.sleep(1) for _ in range(10):
test() test.setTimeout(1)
for _ in range(10):
test()
使用类来定制装饰器。
#coding:utf8
import logging
from time import localtime,time,strftime,sleep class CallingInfo(object):
def __init__(self,name):
log = logging.getLogger(name)
log.setLevel(logging.INFO)#设置等级
fh = logging.FileHandler(name+'.log')#设置文件处理方法
log.addHandler(fh)#绑定方法到log上
log.info('Start'.center(50,'-'))#添加log文本的头部
self.log= log#绑定到类的属性上
self.formatter = '%(func)s ->[%(time)s - %(used)s -%(ncalls)s]'#定义了输出模板 def info(self,func):#这个就是平常的装饰器
def wrapper(*args,**kw):
wrapper.ncalls +=1
lt = localtime()#返回当地时间
start = time()
res = func(*args,**kw)
used = time() - start info = {}#建立info的字典
info['func'] = func.__name__
info['time'] = strftime('%x %X',lt)
info['used'] = used
info['ncalls'] = wrapper.ncalls msg = self.formatter % info#将字典映射到输入模板上
self.log.info(msg)#输出字符串
return res
wrapper.ncalls = 0#这个语句需要在这个位置的解释有待完善
return wrapper def setFromatter(self,formatter):
self.formatter = formatter def turnOn(self):
self.log.setLevel(logging.INFO) def turnOff(self):
self.log.setLevel(logging.WARN)#级别提高就不在那里输出了 cinfo1 = CallingInfo('mylog1')
cinfo2 = CallingInfo('mylog2') cinfo1.setFromatter('%(func)s ->[%(time)s -%(ncalls)s]')
cinfo2.turnOff()#这里可以看到是很方便地修改装饰器 @cinfo1.info
def f():
print 'in f' @cinfo1.info
def h():
print 'in h' @cinfo2.info
def g():
print 'in g' from random import choice
for _ in xrange(10):
choice([f,g,h])()
sleep(choice([0.5,1,1.5]))