Python168的学习笔记8

#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]))