python装饰器通俗易懂的解释！

一、python装饰器

刚刚接触python的装饰器，简直懵逼了，直接不懂什么意思啊有木有，本身都忘了走了多少遍Debug，查了多少遍资料，猜有点点开始明白了。总结了一下解释得比较好的，通俗易懂的来讲明一下：

 

小P闲来无事，随便翻看本身之前写的一些函数，突然对一个最最最基础的函数起了兴趣：

1 def sum1():
2      sum = 1 + 2
3      print(sum)
4 sum1()

此时小P想看看这个函数执行用了多长时间，因此写了几句代码插进去了：

 1 import time
 2 
 3 def sum1():
 4     start = time.clock()
 5     sum = 1+2
 6     print(sum)
 7     end = time.clock()
 8     print("time used:",end - start)
 9 
10 sum1()

运行以后，完美~~

但是随着继续翻看，小P对愈来愈多的函数感兴趣了，都想看下他们的运行时间如何，难道要一个一个的去改函数吗？固然不是！咱们能够考虑从新定义一个函数timeit，将sum1的引用传递给他，而后在timeit中调用sum1并进行计时，这样，咱们就达到了不改动sum1定义的目的，并且，不论小P看了多少个函数，咱们都不用去修改函数定义了！

import time

def sum1():
    sum = 1+ 2
    print (sum)

def timeit(func):
    start = time.clock()
    func()
    end =time.clock()
    print("time used:", end - start)

timeit(sum1)

咂一看，没啥问题，能够运行！可是仍是修改了一部分代码，把sum1() 改为了timeit(sum1)。这样的话，若是sum1在N处都被调用了，你就不得不去修改这N处的代码。因此，咱们就须要杨sum1()具备和timeit(sum1)同样的效果，因而将timeit赋值给sum1。但是timeit是有参数的，因此须要找个方法去统一参数，将timeit(sum1)的返回值（计算运行时间的函数）赋值给sum1。

 1 import time
 2 
 3 def sum1():
 4     sum = 1+ 2
 5     print (sum)
 6 
 7 def timeit(func):
 8     def test():
 9         start = time.clock()
10         func()
11         end =time.clock()
12         print("time used:", end - start)
13     return test
14 
15 sum1 = timeit(sum1)
16 sum1()

这样一个简易的装饰器就作好了，咱们只须要在定义sum1之后调用sum1以前，加上sum1= timeit(sum1)，就能够达到计时的目的，这也就是装饰器的概念，看起来像是sum1被timeit装饰了！Python因而提供了一个语法糖来下降字符输入量。

 1 import time
 2   
 3 def timeit(func):
 4      def test():
 5          start = time.clock()
 6          func()
 7          end =time.clock()
 8          print("time used:", end - start)
 9      return test
10  
11 @timeit
12 def sum1():
13      sum = 1+ 2
14      print (sum)
15 
16  sum1()

重点关注第11行的@timeit，在定义上加上这一行与另外写sum1 = timeit(sum1)彻底等价。

二、递归算法

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

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

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

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

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

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

 

举个栗子：对一个数字进行除2求值，直到小于等于1时退出并输出结果

 1 def divide(n,val):
 2     n += 1
 3     print(val)
 4     if val / 2 > 1:
 5         aa = divide(n,val/2)
 6         print('the num is %d,aa is %f' % (n,aa))
 7     print('the num is %d,val is %f' % (n,val))
 8     return(val)
 9 
10 divide(0,50.0)
11 
12 结果说明（不return时至关于嵌套循环，一层层进入在一层层退出）：
13 50.0
14 25.0
15 12.5
16 6.25
17 3.125
18 1.5625
19 the num is 6,val is 1.562500
20 the num is 5,aa is 1.562500
21 the num is 5,val is 3.125000
22 the num is 4,aa is 3.125000
23 the num is 4,val is 6.250000
24 the num is 3,aa is 6.250000
25 the num is 3,val is 12.500000
26 the num is 2,aa is 12.500000
27 the num is 2,val is 25.000000
28 the num is 1,aa is 25.000000
29 the num is 1,val is 50.000000
30 
31 
32 
33 2、递归时return：
34 def divide(n,val):
35     n += 1
36     print(val)
37     if val / 2 > 1:
38         aa = divide(n,val/2)
39         print('the num is %d,aa is %f' % (n,aa))
40         return(aa)
41     print('the num is %d,val is %f' % (n,val))
42     return(val)
43 
44 divide(0,50.0)
45 
46 结果说明（return时就直接结束本次操做）：
47 50.0
48 25.0
49 12.5
50 6.25
51 3.125
52 1.5625
53 the num is 6,val is 1.562500
54 the num is 5,aa is 1.562500
55 the num is 4,aa is 1.562500
56 the num is 3,aa is 1.562500
57 the num is 2,aa is 1.562500
58 the num is 1,aa is 1.562500

View Code

用递归实现斐波那契函数

 1 def feibo(first,second,stop,list):
 2 
 3     if first >= stop or second >= stop:
 4         return list
 5     else:
 6         sum = first + second
 7         list.append(sum)
 8         if sum <= stop:
 9             return feibo(second,sum,stop,list)
10 
11     return list
12 
13 
14 
15 if __name__ == '__main__':
16     first = int(raw_input('please input the first number:'))
17     second = int(raw_input('please input the second number:'))
18     stop = int(raw_input('please input the stop number:'))
19     l = [first,second]
20     a = feibo(first,second,stop,l)
21     print(a)

View Code

三、简易计算器

该计算器思路：
    一、递归寻找表达式中只含有 数字和运算符的表达式，并计算结果
    二、因为整数计算会忽略小数，全部的数字都认为是浮点型操做，以此来保留小数