六. python进阶(递归)

一 .递归

在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

递归函数: 一个会调用自身的函数称为递归函数
凡是循环能干的事情 递归都能干
方式:
   写出临界条件
   我这一次和上一次的关系
   假设当前函数已经能用 调用自身计算上一次结果 在求出本次的结果

必须有一个明确的结束条件；
每次进入更深一层递归时，问题规模相比上次递归都应有所减少
相邻两次重复之间有紧密的联系，前一次要为后一次做准备（通常前一次的输出就作为后一次的输入）。
递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧
。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出

import sys
print(sys.setrecursionlimit(1000))   # sys.setrecursionlimit()  #设置最大递归层数

print(sys.getrecursionlimit())                                   #获取最大递归层数

# RecursionError: maximum recursion depth exceeded while calling a Python object  递归的错误 最大的深度
def aa():
    print("1111")
    aa()
    print("22222222")
aa()

1111
1111
1111

..................

# 测试递归调用最大的深度 998           997
n=0
def cc():
    global n
    n+=1
    print(n)
    print("11111111111")
    cc()
cc()

1.递归运行原理

def rec(i):   #定义函数
    print(i)
    if i/2 > 1:   #判断递归条件，退出
        re = rec(i/2)  #递归函数自身
        print('返回值:',re)
    print('上层递归值：',i)
    return i     #返回值

rec(10)
# """#运行原理：首先运行函数传参10给函数，打印10，判断条件满足，递归
# #函数参数值为（10/2）5，打印i的值5，等递归到1.25时，判断条件不满
# #足后，才打印上层递归的值，此时递归的值为1.25，return递归最后一
# #层的值1.25，退出最后一层递归，继续一层层退出递归，最后返回最上层
# #递归值结束函数。
# 5.0
# 2.5
# 1.25
# 上层递归值： 1.25
# 返回值: 1.25
# 上层递归值： 2.5
# 返回值: 2.5
# 上层递归值： 5.0
# 返回值: 5.0
# 上层递归值： 10"""

2. 递归案例

# # 输入一个数(大于等于1) 求 1+2+3.......的和
# # 简单的递归
def sum2(n):
    if n==1:
       return 1
    else:
       return n+sum2(n-1)
res=sum2(5)
print(res) #3
# 5+sum2(4)
# 5+4+sum2(3)
# 5+4+3+sum2(2)
# 5+4+3++2sum2(1)
# 5+4+3+2+1

#递归分解执行步骤
def sum2(5):
    if 5==1:
       return 1
    else:
       return 5+sum2(5-1)
                         4
def sum2(4):
    if 4==1:
       return 1
    else:
       return 4+sum2(4-1)
                   3

def sum2(3):
    if 4==1:
       return 1
    else:
       return 3+sum2(3-1)
                   2
def sum2(2):
    if 4==1:
       return 1
    else:
       return 2+sum2(2-1)
                    1

def sum2(1):
    if 1==1:
       return 1
    else:
       return n+sum2(n-1)

def foo(arg1,arg2,stop):
    if arg1 == 0:
        print(arg1,arg2,"第一次")
    arg3 = arg1 + arg2
    print(arg1,arg2,arg3,"第二次")
    if arg3 < stop:      #判断套件不满足时退出递归
        foo(arg2,arg3,stop)   #递归函数，传送参数arg2,arg3,stop给arg1,arg2,stop

foo(0,1,50)
# 1
# 1 1
# 1 2
# 2 3
# 3 5
# 5 8
# 8 13
# 13 21
# 21 34
# 34 55‘

def age(n):
    if n==4:
        return 40
    elif n>0 and n<4:
        return age(n+1)+2
print(age(1))


# 解析上面递归方法
def age(1):
    if 1==4:
        return 40
    elif 1>0 and 1<4:
        return age(1+1)+2
                 44

def age(2):
    if 2==4:
        return 40
    elif 2>0 and 2<4:
        return age(2+1)+2
                  42

def age(3):
    if 3==4:
        return 40
    elif 3>0 and 3<4:
        return age(3+1)+2
                   40

def age(4):
    if 4==4:
        return 40
    elif n>0 and  n<4:
        return age(n+1)+2

def sum2(n):
    if n==1:
       return 1
    else:
       aa= n + sum2(n - 1)

       return  aa
res=sum2(6)
print(res)


# 6+5+4+3+2+1

# 斐波拉契竖列
# 后一项与前一项之差是不变的，这种数列称为等差数列。
# 斐波那契数列数列从第3项开始，每一项都等于前两项之和。
# 例子：数列 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233，377，610，987，1597，2584，4181，6765，10946，17711，28657，46368......

def bb(n):
   if n==1or n==2:
     return 1
   return bb(n-1)+bb(n-2)
            # return 1+1     4  3
d=bb(4)
print(d)

# 1+1+1

# def bb(4):
#    if n==1or n==2:
#      return 1
#    return bb(4-1)+bb(4-2)

阶乘
# def bb(3):
#     if n == 1 or n == 2:
#         return 1
#     bb(2) + bb(1)
#
# def bb(2):
#     if n == 1 or n == 2:
#         return 1
#     bb(2) + bb(1)
#     print(1+1)"""

# 阶乘 1*2*3
def fac(n):
    if n==1:
        return 1
    return n*fac(n-1)
print(fac(5))
#
# 5*4*3*2*1

def b(aa):
    print(aa)
    if int(aa/2)==0:
       return aa
    res=b(int(aa/2))

    return res

b(10)

# 10
# 5
# 2
# 1

# 输入一个数(大于等于1) 求 1+2+3.......的和
def sum1(n):
   sum=0
   for x in range(1,n+1):

        print("x的值--------",x)

        sum+=x

        print("sum的值==",sum)

   return sum

res=sum1(4)

print(res)   #15

"""
x的值-------- 1
sum的值== 1
x的值-------- 2
sum的值== 3
x的值-------- 3
sum的值== 6
x的值-------- 4
sum的值== 10
10"""

# 读取 所有文件   递归
import  os
def fun(pathname,n):
   files=os.listdir(pathname)
   for i in files:
       cc=os.path.join(pathname,i)
       if os.path.isdir(cc):
         fun(cc,n+1)
         print("	"*n,i)
       else:
           print("	"*n,i)
fun("F:作业",0)

二分查找法  递归

# 二分查找法   必须数据有序
lise=[11,22,33,44,55,66,77,88,99]
n=99
left=0
right=len(lise)-1
while left<=right:
    mode=(right+left)//2
    if lise[mode] > n:
        right=mode-1
    if lise[left]<n:
        left=mode+1
    if lise[mode]==n:
        print("说明找到了")
        break
else:
    print("没有找到哈哈哈")

print("*******************************************************")

# 递归实现的二分法   递归只能用return   不能用braek来返回   必须数据有序
lise=[11,22,33,44,55,66,77,88,99]
def func(n,left,right):
    mode=(left+right)//2
    if left<=right:
        if lise[mode]>n:
            right=mode-1
            return  func(n, left, right)
        if  lise[mode]<n:
             left=mode+1
             return func(n,left,right)
        if lise[mode]==n:
            print("找到了哈哈哈")
            return  mode
    else:
        print("没有找到")
aa=func(888,0,len(lise)-1)
print(aa)

斐波拉去数列 和  阶乘# 斐波拉去数列

def fun(n):
    if n==1 or n==2:
        return 1
    return fun(n-1)+fun(n-2)
print(fun(10))



print("*****************************")

# 阶乘
def aa(n):
    if n==1:
        return 1
    return  n*aa(n-1)
print(aa(5))