第八篇递归装饰器

Posted 2020-09-02 pyrene

一、递归函数

概念：递归算法是一种直接或者间接的调用自身算法的过程。在计算机编写程序中，递归算法对解决一大类问题是十分有效的。

特点：

①递归就是在过程或者函数里调用自身。

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

③递归算法解题通常显得很简洁，但递归算法解题的效率较低。所以一般不倡导使用递归算法设计程序。

④在递归调用的过程当中系统的每一层的返回点、局部变量等开辟了栈来存储。递归函数次数过多容易造成栈溢出等。

   所以一般不倡导用递归算法设计程序。

递归的思想代码如下：
\'\'\'
"""
def f4(a1,a2):
    if a1>10000:
        return
    a3 = a1 + a2
    f4(a2,a3)
f4(0,1)

\'\'\'
斐波那契数列：每个数都是前两个数相加的和
要求找出第十次的数是多少
\'\'\'
def f5(depth,a1,a2):
    \'\'\'
    每次循环都进行判断次数是否为10，如果不满足，则继续循环，直到满足条件
    :param depth: 次数
    :param a1: 第一个数
    :param a2: 第二个数
    :return:  下面是打印出两个内容1、打印出斐波那契数列、2、打印出第十次的数
    \'\'\'
    if depth == 10:
        return a1
    a3 = a1 + a2
    print a3
    r = f5(depth +1,a2,a3)
    return r
r = f5(1,0,1)
print (r)

斐波那契数列

图解递归流程

二、装饰器

1、

 1 def outer(func):    #这里的参数是要装饰的值
 2     \'\'\'
 3     装饰器两大知识点：@outer的作用如下：
 4     1、执行outer函数，并且将其下面的函数名，当作参数传递
 5     2、将outer函数的返回值重新赋值给f1函数 f1 = outer的返回值
 6     函数名的内存地址是print，函数方法的结果是返回值return
 7     :param func:
 8     :return:
 9     \'\'\'
10     def inner():
11         print ("hello")
12         print ("hello")
13         print ("hello")
14         r = func()  #这里r=None也就是func()的返回值
15         print ("end")
16         print ("end")
17         return r
18     return inner
19 @outer
20 def f1():
21     \'\'\'
22     因为装饰器原因，下面的f1()=outer(f1)
23     :return:
24     \'\'\'
25     print ("f1")
26     return "000"
27 f1()
28 f2 = outer(f1)
29 result = f2()
30 print result

2、装饰器作用:

让一个函数附带自己功能的时候在不改变原函数的基础之上增加新的功能

如上，就是让f1增加hello和end的两个功能的同时，再保持自己的新功能

流程如下：

 

 1 下面的流程：首先执行@outher ,即outer函数的返回值就是index()的方法的值，所以执行inner（）
　　然后打印出123，执行func()即非常复杂，打印456

 2 \'\'\'
 3 def outer(func):
 4     def inner():
 5         print ("123")
 6         ret = func()
 7         print ("456")
 8         return ret
 9     return inner
10 @outer
11 def index():
12     print ("非常复杂")
13     return True
14 index()

总结：

只要函数应用上装饰器，那么函数就被重新定义，重新定义为：装饰器的内层函数

 

 1 def outer(func):
 2     \'\'\'
 3     装饰器装饰含n个参数的函数
 4 并且多个装饰器装饰同一个函数：
 5     相当于
 6     @outer_0
 7     def inner（*args,**kwargs）:
 8     ...
 9     也就相当于执行inner1函数，所以会先执行print(3.5)
10     :param func:
11     :return:
12     \'\'\'
13     def inner(*args,**kwargs):
14         print ("123")
15         ret = func(*args,**kwargs)
16         print ("456")
17         return ret  #这个是用来结束的
18     return inner
19 def outer_0(func):
20     def inner1(*args,**kwargs):
21         print ("3.5")
22         ret = func(*args,**kwargs)
23         return ret
24     return inner1
25 @outer_0
26 @outer
27 def index(a1,a2):
28     print ("非常复杂")
29     return a1 + a2
30 index(1,2)
31 @outer
32 def f1(a):
33     print "a"
34 f1(1)

装饰器的作用是改写原来的函数，那么多个装饰器就是改写多个函数的