Python 递归

Posted 2021-01-31 dongye95

锲子

　　先看一段函数

def story():
    s = """
    从前有个山，山里有座庙，庙里老和尚讲故事，
    讲的什么呢？
    """
    print(s)
    story()
    
story()

初识递归

递归的定义——在一个函数里再调用这个函数本身

现在我们已经大概知道刚刚讲的story函数做了什么，就是在一个函数里再调用这个函数本身，这种魔性的使用函数的方式就叫做递归。

递归的最大深度——997

正如你们刚刚看到的，递归函数如果不受到外力的阻止会一直执行下去。但是我们之前已经说过关于函数调用的问题，每一次函数调用都会产生一个属于它自己的名称空间，如果一直调用下去，就会造成名称空间占用太多内存的问题，于是python为了杜绝此类现象，强制的将递归层数控制在了997

拿什么来证明这个“997理论”呢？这里我们可以做一个实验：

def foo(n):
    print(n)
    n += 1
    foo(n)
foo(1)

　　由此我们可以看出，未报错之前能看到的最大数字就是997.当然了，997是python为了我们程序的内存优化所设定的一个默认值，我们当然还可以通过一些手段去修改它：

import sys
print(sys.setrecursionlimit(100000))

　　我们可以通过这种方式来修改递归的最大深度，刚刚我们将python允许的递归深度设置为了10w，至于实际可以达到的深度就取决于计算机的性能了。不过我们还是不推荐修改这个默认的递归深度，因为如果用997层递归都没有解决的问题要么是不适合使用递归来解决要么是你代码写的太烂了～～～

再谈递归

这里我们又要举个例子来说明递归能做的事情。

例一：

现在你们问我，alex老师多大了？我说我不告诉你，但alex比 egon 大两岁。

你想知道alex多大，你是不是还得去问egon？egon说，我也不告诉你，但我比武sir大两岁。

你又问武sir，武sir也不告诉你，他说他比金鑫大两岁。

那你问金鑫，金鑫告诉你，他40了。。。

这个时候你是不是就知道了？alex多大？

1	金鑫	40
2	武sir	42
3	egon	44
4	alex	46

你为什么能知道的？

首先，你是不是问alex的年龄，结果又找到egon、武sir、金鑫，你挨个儿问过去，一直到拿到一个确切的答案，然后顺着这条线再找回来，才得到最终alex的年龄。这个过程已经非常接近递归的思想。我们就来具体的我分析一下，这几个人之间的规律。

age(4) = age(3) + 2 
age(3) = age(2) + 2
age(2) = age(1) + 2
age(1) = 40

　　那这样的情况下，我们的函数应该怎么写呢？

def age(n):
    if n == 1:
        return 40
    else:
        return age(n-1)+2

print(age(4))

递归函数与三级菜单

menu = {
    \'北京\': {
        \'海淀\': {
            \'五道口\': {
                \'soho\': {},
                \'网易\': {},
                \'google\': {}
            },
            \'中关村\': {
                \'爱奇艺\': {},
                \'汽车之家\': {},
                \'youku\': {},
            },
            \'上地\': {
                \'百度\': {},
            },
        },
        \'昌平\': {
            \'沙河\': {
                \'老男孩\': {},
                \'北航\': {},
            },
            \'天通苑\': {},
            \'回龙观\': {},
        },
        \'朝阳\': {},
        \'东城\': {},
    },
    \'上海\': {
        \'闵行\': {
            "人民广场": {
                \'炸鸡店\': {}
            }
        },
        \'闸北\': {
            \'火车战\': {
                \'携程\': {}
            }
        },
        \'浦东\': {},
    },
    \'山东\': {},
}

menu

-

def threeLM(dic):
    while True:
        for k in dic:print(k)
        key = input(\'input>>\').strip()
        if key == \'b\' or key == \'q\':return key
        elif key in dic.keys() and dic[key]:
            ret = threeLM(dic[key])
            if ret == \'q\': return \'q\'

threeLM(menu)

还记得之前写过的三级菜单作业么？现在咱们用递归来写一下～（堆栈）

l = [menu]
while l:
    for key in l[-1]:print(key)
    k = input(\'input>>\').strip()   # 北京
    if k in l[-1].keys() and l[-1][k]:l.append(l[-1][k])
    elif k == \'b\':l.pop()
    elif k == \'q\':break

-

递归函数与二分查找算法

如果有这样一个列表，让你从这个列表中找到66的位置，你要怎么做？

l = [2,3,5,10,15,16,18,22,26,30,32,35,41,42,43,55,56,66,67,69,72,76,82,83,88]

l.index(66)...

我们之所以用index方法可以找到，是因为python帮我们实现了查找方法。如果，index方法不给你用了。。。你还能找到这个66么？

l = [2,3,5,10,15,16,18,22,26,30,32,35,41,42,43,55,56,66,67,69,72,76,82,83,88]

i = 0
for num in l:
    if num == 66:
        print(i)
    i+=1

　　上面这个方法就实现了从一个列表中找到66所在的位置了。

　　但我们现在是怎么找到这个数的呀？是不是循环这个列表，一个一个的找的呀？假如我们这个列表特别长，里面好好几十万个数，那我们找一个数如果运气不好的话是不是要对比十几万次？这样效率太低了，我们得想一个新办法。

二分查找算法

l = [2,3,5,10,15,16,18,22,26,30,32,35,41,42,43,55,56,66,67,69,72,76,82,83,88]

你观察这个列表，这是不是一个从小到大排序的有序列表呀？

如果这样，假如我要找的数比列表中间的数还大，是不是我直接在列表的后半边找就行了？

这就是二分查找算法！

那么落实到代码上我们应该怎么实现呢？ 

简单版二分法（有问题版，打印结果不正确）

lst = [2,3,5,10,15,16,18,22,26,30,32,35,41,42,43,55,56,66,67,69,72,76,82,83,88]   #25个元素


def func(lst,aim):
    mid = (len(lst)-1)//2
    if lst:
        if aim > lst[mid]:
            func(lst[mid + 1:],aim)
        elif aim < lst[mid]:
            func(lst[:mid],aim)
        elif aim == lst[mid]:
            print("bingo",mid)
    else:
        print(\'找不到\')
func(l,66)
func(l,6)

升级版

def find(l, aim, start = 0,end = len(lst)):
    mid_index = (end - start)//2 + start       #计算中间值
    if lst[mid_index] < aim:
        find(lst, aim, start=mid_index + 1, end = end)
    elif lst[mid_index] > aim:
        find(lst, aim, start = start, end = mid_index - 1)
    else:
        print(\'找到了\', mid_index, aim)

find(lst,66)

 三个问题：

1. 参数 end 时需要 列表l 已经存在，但是实际可以不存在。在定义函数时会报错。

2. 无返回值，结果是打印的。

3. 没有处理找不到的问题

二次改进

def find(l,aim,start=0,end=None):
    end = len(l) if end is None else end
    mid_index = (end - start)//2 + start       #计算中间值
    if start <= end:
        if l[mid_index] < aim:
            find(l,aim,start=mid_index + 1, end = end)
        elif l[mid_index] > aim:
            find(l,aim,start=start, end = mid_index-1)
        else:
            print(\'找到了\',mid_index,aim)
    else:
        print(\'找不到这个值\')
find(l,66)

　　此时还有问题，就是还是打印的 mid_index。而不是返回值，但是不能直接返回 mid_index，因为 递归的原因，最里层返回，但是外层还是 None

终极版二分法

def search(num,l,start=None,end=None):
    start = start if start else 0                     #不能直接start=0，这样start传进去没用，后续递归中，start不一定是0，需要传进去使用
    end = end if end is None else len(l) - 1
    mid = (end - start)//2 + start
    if start > end:
        return None
    elif l[mid] > num :
        return search(num,l,start,mid-1)
    elif l[mid] < num:
        return search(num,l,mid+1,end)
    elif l[mid] == num:
        return mid