递归

# 递归函数
#  设置递归深度值

import sys

print(sys.getrecursionlimit())

sys.setrecursionlimit(10*10)

def fun1():
    print('123')
    fun1()


fun1()
报错：RecursionError: maximum recursion depth exceeded while calling a Python object

sys.setrecursionlimit(100000)#往大设置

一、解释

递归:在调用一个函数的过程中，直接或间接地调用了函数本身这个就叫递归

注：Python在递归中没有像别的语言对递归进行优化，所以他的每一次调用都会基于上一次的调用进行，并且他设置了最大的递归数量防止递归外溢
二、实例

#直接调用自己：
def func():
    print('from func')
    func()

func()


#间接调用自己
def foo():
    print('from foo')
    bar()

def bar():
    print('from bar')
    foo()

foo()


#递归的实现：
def age(n):
    if n == 1:
        return 18
    return age(n-1)+2

print(age(5))

# age(5)=age(4)+2 第一次进入
# age(4)=age(3)+2 第二次进入
# age(3)=age(2)+2 第三次进入
# age(2)=age(1)+2 第四次进入
# age(1)=18 第五次进入，最后判断终止条件

# age(n)=age(n-1)+2 #n>1  递归终止条件
# age(1)=18 #n=1          等于终止条件



三、递归的回溯与递推

递推：像上边递归实现所拆解，递归每一次都是基于上一次进行下一次的执行，这叫递推

回溯：则是在遇到终止条件，则从最后往回返一级一级的把值返回来，这叫回溯

# 实例
l =[1, 2, [3, [4, 5, 6, [7, 8, [9, 10, [11, 12, 13, [14, 15,[16,[17,]],19]]]]]]]

def search(l):
    for item in l:
        if type(item) is list:
            search(item)
        else:
            print(item)

search(l)

总结：
python3 设置递归的最大执行次数1000，防止内存爆掉
本质限制的原因：函数的调用是通过栈这种数据结构来实现的，python中不存在栈，函数运行时函数的变量、代码都存在内存中的栈中，没执行一次函数都会把函数放内存中，函数运行的量多的时候，就会栈溢出。
每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧，由于栈的大小不是无限的，所以递归调用的次数过多，会导致栈溢出。

一层一层进入，最后一次函数（最里面函数）执行完之后，依次退出（从里到外）
示例：
10/2 5 2 1 0 1 2 5
def calc(n):
    v = int(n/2)
    print(v) # 5 2 1 0 
    if v == 0:
        return 'Done'
    calc(v)
    print(v)# 1 2 5 
    
calc(10)

递归特点：
1、必须有一个明确的结束条件，要不就会变成死循环了，最终撑爆系统
2、每次进入更深一层递归时，问题规模都比上次递归都应有所减少
3、递归执行效率不高，递归层次过多会导致栈溢出

尾递归：
第二层函数不需要使用第一次的结果，只需要保存 当前层 数据在栈中
c语言支持，python不支持（没有效果，还报错）
def normal_recursion(n):
    if n == 1:
        return 1
    else:
        return n + normal_recursion(n-1)


print(normal_recursion(10))