python之递归

一、解释

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

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

即递归不同于死循环，有最多次数限制999次，到达最多次数时报错

递归函数特性：

1. 必须有一个明确的结束条件；
2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少
3. 相邻两次重复之间有紧密的联系，前一次要为后一次做准备（通常前一次的输出就作为后一次的输入）。
4. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）
5. 递归函数的优点是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。

间接或直接调用自身的函数被称为递归函数。

间接：
def func():
    otherfunc()

def otherfunc():
    func()

直接：
def func():
    func()

count=0
def abc():
    global count
    count+=1
    print(count)
    print('abc')
    abc()
abc() 

# 当达到999次时，会报错
#RecursionError: maximum recursion depth exceeded while calling a Python object

二、常见的递归实现

#递归实现n个斐波那契数列：
def fibonacci(n):
    if n == 0:
        return 0
    elif n == 1:
        return 1
    else:
        return fibonacci(n-1) + fibonacci(n-2)
print([fibonacci(x) for x in range(10)])

#输出：
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

#返回n以内所有数的阶乘的和：
def fn(n):
    if n == 1:
        return 1
    else:
        return n * fn(n - 1)
print(sum(map(fn, range(1, 10))))

#输出：409113

#求一个数的质因数
def zhiyinshu(n):
    for x in range(2, int(n/2+1)):
        if n % x == 0:
            l.append(x)
            return zhiyinshu(n/x)
    l.append(int(n))
    print(l)
l = []
zhiyinshu(90)

#输出结果: [2, 3, 3, 5]

计算1到100之间相加之和；通过循环和递归两种方式实现
import sys
def sum_cycle(n):
    '''
    1 to n,The sum function
    '''
    sum = 0
    for i in range(1,n + 1):
        sum += i
    return sum

def sum_recu(n):
    '''
    1 to n,The sum function
    '''
    if n > 0:
        return n + sum_recu(n - 1) #调用函数自身
    else:
        return 0
print("循环求和：",sum_cycle(100))  
print("递归求和：",sum_recu(100))

#输出结果：
循环求和： 5050
递归求和： 5050