Python函数的递归 (用递归求1到n的和 用递归求第n个斐波那契数 求嵌套列表中的数字之和 快速排序)

递归函数

简单来说就是自己调自己；递归最重要的就是找到出口（也就是停止的条件）

cou = 5
def say_love():
    print('我爱你',end=' ')# 把这五个我爱你打在一行
    global cou
    cou = cou-1
    if cou>0:
        say_love()
say_love()# '我爱你 ''我爱你 ''我爱你 ''我爱你 ''我爱你 '

一个简单的演示，但这个需要调用全局标量进行判断，我们也可以直接通过传参，用return返回函数请看下面演示：

def say_love2(n):
    if n > 0:
        print('我爱你',end=' ')
        return say_love2(n-1)

say_love2(5)# '我爱你 ''我爱你 ''我爱你 ''我爱你 ''我爱你 '

还有其他写法，我这就不一一例举了
我们来做几个简单的练习：

1.用递归求1到n的和

def mysum(n):
    if n == 1:# 停止条件 当n等于1的时候返回1
        return 1
    return n + mysum(n-1)
    #要是实在还是没理解，可以把这个式子在草稿纸上写出来就很容易看懂了

s = mysum(100)
print(s)# 5050

2.用递归求第n个斐波那契数

# 斐波那契数列：1,1,2,3,5,8,13,21,34,55....
def feibo(n):
    if n == 1 or n == 2:# 停止条件
    # 后面的数是不是都是由最前面两个数'相加'得来的
    # 这里的相加是指以它两为基数相加得来的
        return 1
    return feibo(n-1)+feibo(n-2)# 第n个数是由前两个数相加得来的

f = feibo(10)
print(f) # 55

3.求嵌套列表中的数字之和

可以在列表嵌套列表、元组、字符串、整数、浮点数，这里就要先循环判断是否是数字，是就直接相加，是列表元组就要再对其循环判断，字符串就不做判断，嵌套不限2层
isinstance() 与 type() 区别：
type() 不会认为子类是一种父类类型，不考虑继承关系；
isinstance() 会认为子类是一种父类类型，考虑继承关系。

lists = [1,2,5,[1,7,3,'a'],(1,2),'abc',3]
def sum_num(n):
    s = 0
    for i in n:
        if isinstance(i,(int,float)):
        # if type(i) == int or type(i) == float:
            s += i
        if isinstance(i,(tuple,list)):
        # if type(i) == tuple or type(i) == list:
            s += sum_num(i)
    return s
print(sum_num(lists))# 25

4.快速排序

去列表中的的一个数，并将其删除，再遍历一遍列表，比取的那个数大的就放在右边列表，比取的那个小的就放到左边列表，最后函数返回这几个相加，可以看下面实操，我讲不清楚可能，害 QAQ

'''
             [4, 2, 6, 7, 5, 1, 3, 8, 9]
             
             [4, 2, 1, 3]          [5]    [6, 7, 8, 9]
             [] [1] [4,2,3]        [5]    [6,7]    [8] [9]
             [] [1] [][2][4,3]     [5]    [6][7][] [8] [9]
             [] [1] [][2][][3][4]  [5]    [6][7][] [8] [9]
'''
def quick_sort(l):
    # 结束条件
    if len(l) <= 1:
        return l
    # 1.取一个元素
    middle = l.pop(len(l)//2)
    # 2.定义2个列表:left,right,分别存放小于middle,和大于middle的元素
    left = []
    right = []
    for n in l:
        if n < middle:
            left.append(n)
        else:
            right.append(n)

    print(left, [middle], right)# 可以用来查看排序的实现
    # 函数递归
    return quick_sort(left) + [middle] + quick_sort(right)
l = [4, 2, 6, 7, 5, 1, 3, 8, 9]
print(quick_sort(l))

注意：能不用递归尽量不要用递归

递归的运行效率较低，而且递归的深度是有限的，如果超过这个深度就会抛出一个异常
这里就需要改一下递归的深度，需要用到sys模块

import sys
sys.setrecursionlimit(1000000)

简单总结不喜勿喷 还有就是如果条件允许的话可以点赞评论加关注哦 QAQ