python 递归和装饰器

一：递归

特点

递归算法是一种直接或者间接地调用自身算法的过程。在计算机编写程序中，递归算法对解决一大类问题是十分有效的，它往往使算法的描述简洁而且易于理解。

递归算法解决问题的特点：

(1)    递归就是在过程或函数里调用自身。

(2)    在使用递归策略时，必须有一个明确的递归结束条件，称为递归出口。

(3)    递归算法解题通常显得很简洁，但递归算法解题的运行效率较低。所以一般不提倡用递归算法设计程序。

(4)    在递归调用的过程当中系统为每一层的返回点、局部量等开辟了栈来存储。递归次数过多容易造成栈溢出等。所以一般不提倡用递归算法设计程序。

要求

递归算法所体现的“重复”一般有三个要求：

(1)    每次调用在规模上都有所缩小(通常是减半)；

(2)    相邻两次重复之间有紧密的联系，前一次要为后一次做准备(通常前一次的输出就作为后一次的输入)；

(3)    在问题的规模极小时必须用直接给出解答而不再进行递归调用，因而每次递归调用都是有条件的(以规模未达到直接解答的大小为条件)，无条件递归调用将会成为死循环而不能正常结束。

 

实现

1. 通过递归实现2分查找

现有列表 primes = [2, 3, 5, 7, 11, 13,17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]，要求用最快的方式 找出23 。 请Low B, Low 2B ,Low 3B 三个同学来回答这个问题。 

a)       Low B: 这个很简单，直接用 if 41 inprimes:print("found it!") , 话音未落就被老师打了，让你自己实现，不是让你用现成提供的功能， Low B于是说，那只能从头开始一个个数了，然后Low B被 开除了。。。

b)       Low 2B: 因为这个列表是有序的， 我可以把列表从中截取一半，大概如下：

p1 = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31,37,41]

p2 = [ 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89,97]

然后看p1[-1]也就是41是否比23大， 如果比23大就代表23肯定在p1里面，否则那就肯定在p2里面。现在我们知道23比41小，所以23肯定在p1里，但p1里依然有很多元素， 怎么找到23呢？很简单，依然按上一次的方法，把p1分成2部分，如下：

p1_a = [2, 3, 5, 7, 11, 13,17]

p1_b = [19, 23, 29, 31, 37,41]

然后我们发现，23 比p1_a最后一个值 17 大，那代表23肯定在p1_b中， p1_b中依然有很多元素，那就再按之前的方法继续分半，最终用不了几次，肯定就把23找出来了！

说完，Low 2B满有成就感的甩了下头上的头皮屑。

　　老师：很好，确实较Low B的方案强很多。然后转头问Low 3B ，你有更好的想法 么？ 

Low 3B: 啊。。。噢 ，我。。。我跟Low 2B的想法一样，结果被他说了。

      老师：噢，那你帮我把代码写出来吧。 

      Low 3B此时冷汗直冒，因为他根本没思路，但还是硬着头皮去写了。。。。虽然自己没思路，但是会谷歌呀，三个小时过去了，终于憋出了以下代码：

defbinary_search(data_list,find_num):
    mid_pos =int(len(data_list)/2 )#find the middleposition of the list
    mid_val =data_list[mid_pos]#get the value by it's position
    print(data_list)
    if len(data_list)>1:
        if mid_val>find_num:# means thefind_num is in left hand of mid_val
            print("[%s] should be in left of [%s]"%(find_num,mid_val))
            binary_search(data_list[:mid_pos],find_num)
        elif mid_val<find_num:# means thefind_num is in the right hand of mid_val
            print("[%s] should be in right of [%s]"%(find_num,mid_val))
            binary_search(data_list[mid_pos:],find_num)
        else:# means the mid_val == find_num
            print("Find ",find_num)
 
    else:
        print("cannot find [%s] in data_list"%find_num)
 
if __name__== '__main__':
    primes =[2,3, 5,7, 11,13, 17, 19,23, 29, 31,37, 41, 43,47, 53, 59,61, 67, 71,73, 79, 83,89, 97]
    binary_search(primes,67)

 

 

二：装饰器：

装饰器是一个很著名的设计模式，经常被用于有切面需求的场景，较为经典的有插入日志、性能测试、事务处理等。装饰器是解决这类问题的绝佳设计，有了装饰器，我们就可以抽离出大量函数中与函数功能本身无关的雷同代码并继续重用。概括的讲，装饰器的作用就是为已经存在的对象添加额外的功能。

装饰器的定义很是抽象，我们来看一个小例子。 

def foo():    print（'in foo()'） foo()

这是一个很无聊的函数没错。但是突然有一个更无聊的人，我们称呼他为B君，说我想看看执行这个函数用了多长时间，好吧，那么我们可以这样做： 

import timedef foo():    start = time.clock()    print('in foo()')    end = time.clock()    print('used:',end -start)foo()

很好，功能看起来无懈可击。可是蛋疼的B君此刻突然不想看这个函数了，他对另一个叫foo2的函数产生了更浓厚的兴趣。  

怎么办呢？如果把以上新增加的代码复制到foo2里，这就犯了大忌了~复制什么的难道不是最讨厌了么！而且，如果B君继续看了其他的函数呢？ 

1.2. 以不变应万变，是变也  

还记得吗，函数在Python中是一等公民，那么我们可以考虑重新定义一个函数timeit，将foo的引用传递给他，然后在timeit中调用foo并进行计时，这样，我们就达到了不改动foo定义的目的，而且，不论B君看了多少个函数，我们都不用去修改函数定义了！ 

import timedef foo():    print('in foo()')def timeit(func):    start = time.clock()    func()    end =time.clock()    print('used:', end-start)timeit(foo)

看起来逻辑上并没有问题，一切都很美好并且运作正常！……等等，我们似乎修改了调用部分的代码。原本我们是这样调用的：foo()，修改以后变成了：timeit(foo)。这样的话，如果foo在N处都被调用了，你就不得不去修改这N处的代码。或者更极端的，考虑其中某处调用的代码无法修改这个情况，比如：这个函数是你交给别人使用的。  

1.3. 最大限度地少改动！  

既然如此，我们就来想想办法不修改调用的代码；如果不修改调用代码，也就意味着调用foo()需要产生调用timeit(foo)的效果。我们可以想到将timeit赋值给foo，但是timeit似乎带有一个参数……想办法把参数统一吧！如果timeit(foo)不是直接产生调用效果，而是返回一个与foo参数列表一致的函数的话……就很好办了，将timeit(foo)的返回值赋值给foo，然后，调用foo()的代码完全不用修改！ 

import timedef foo():    print('in foo()')# 定义一个计时器，传入一个，并返回另一个附加了计时功能的方法def timeit(func):    # 定义一个内嵌的包装函数，给传入的函数加上计时功能的包装    def wrapper():        start = time.clock()        func()        end =time.clock()        print('used:', end-start)    # 将包装后的函数返回    return wrapperfoo = timeit(foo)foo()

这样，一个简易的计时器就做好了！我们只需要在定义foo以后调用foo之前，加上foo = timeit(foo)，就可以达到计时的目的，这也就是装饰器的概念，看起来像是foo被timeit装饰了。在在这个例子中，函数进入和退出时需要计时，这被称为一个横切面(Aspect)，这种编程方式被称为面向切面的编程(Aspect-OrientedProgramming)。与传统编程习惯的从上往下执行方式相比较而言，像是在函数执行的流程中横向地插入了一段逻辑。在特定的业务领域里，能减少大量重复代码。面向切面编程还有相当多的术语，这里就不多做介绍，感兴趣的话可以去找找相关的资料。  
这个例子仅用于演示，并没有考虑foo带有参数和有返回值的情况，完善它的重任就交给你了：）  

上面这段代码看起来似乎已经不能再精简了，Python于是提供了一个语法糖来降低字符输入量。 

import timedef timeit(func):    def wrapper():        start = time.clock()        func()        end =time.clock()        print('used:', end  - start)    return wrapper@timeitdef foo():    print('in foo()')foo()

重点关注第11行的@timeit，在定义上加上这一行与另外写foo = timeit(foo)完全等价，千万不要以为@有另外的魔力。除了字符输入少了一些，还有一个额外的好处：这样看上去更有装饰器的感觉。 

1.4 最后回答前面提到的问题： 

# 装饰器makebold用于转换为粗体def makebold(fn):    # 结果返回该函数    def wrapper():        # 插入一些执行前后的代码        return "<b>" + fn() + "</b>"    return wrapper# 装饰器makeitalic用于转换为斜体def makeitalic(fn):    # 结果返回该函数    def wrapper():        # 插入一些执行前后的代码        return "<i>" + fn() + "</i>"    return wrapper# 注意顺序@makebold@makeitalicdef say():    return "hello"print(say())#输出: <b><i>hello</i></b># 等同于def say():    return "hello"say = makebold(makeitalic(say))print(say())#输出: <b><i>hello</i></b>

2、装饰器的种类

2.1 无参数装饰器

def deco(func):    print(func)    return func@decodef foo():    passfoo()

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

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

#-*- coding: UTF-8 -*-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_functionNeedDocdef f():    print('f() Do something')@deco_functionNeedDocdef g():    'I have a __doc__'     print('g() Do something')f()g()

2.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')

2.3 内置的装饰器

内置的装饰器有三个，分别是staticmethod、classmethod和property，作用分别是把类中定义的实例方法变成静态方法、类方法和类属性。由于模块里可以定义函数，所以静态方法和类方法的用处并不是太多，除非你想要完全的面向对象编程。而属性也不是不可或缺的，Java没有属性也一样活得很滋润。从我个人的Python经验来看，我没有使用过property，使用staticmethod和classmethod的频率也非常低。

装饰器可参考： http://www.cnblogs.com/huxi/archive/2011/03/01/1967600.html