python 函数的递归

函数的递归（recursion）是编程语言里的重要组成部分，那么什么是函数的递归呢？函数的递归就是函数自己调用自己，直到找到一个返回值，再按照一定的规则返回函数的结果。递归的实现，是函数对本身的调用，每次调用时都会栈中进行操作，当没有返回时，程序出现bug

---

在Python语言中，设置了递归的层数，一般是100层，当超过这个层数的时候，Python会抛出一个错误，结束递归

>>> def recursion():
	return recursion()

>>> recursion()
Traceback (most recent call last):
  File "<pyshell#19>", line 1, in <module>
    recursion()
  File "<pyshell#18>", line 2, in recursion
    return recursion()
  File "<pyshell#18>", line 2, in recursion
    return recursion()
  File "<pyshell#18>", line 2, in recursion
    return recursion()
  [Previous line repeated 991 more times]
RecursionError: maximum recursion depth exceeded

但是我们可以设置递归函数递归的层数，这时需要引入sys库

import sys
sys.setrecursionlimit(所要设置的层数)

---

递归虽好，但是会占用大量内存资源，递归还具有一定的危险性，自己对自己的调用容易造成死循环

递归函数的常见例子：

递归求阶乘

def fact(n):
    if n == 1:
        return 1
    if n > 1:
        return n * fact(n-1)
N = input("请输入所求阶乘数:\n")
while True:
    try:
        print("%s的阶乘为:%d" % (N , fact(eval(N))))
        N = input("请输入所求阶乘数:\n")
    except:
        print("请输入数字!")
        break
请输入所求阶乘数:
5
5的阶乘为:120
请输入所求阶乘数:

递归求斐波那契数列

def FB(n):
    if n == 1:
        return 1
    if n == 2:
        return 1
    if n > 2:
        return FB(n-1) + FB(n-2)
while True:
    try:
        N = input('请输入入计算斐波那契数列的项数:\n')
        if not isinstance(eval(N),int):
            continue
        elif int(N) < 1:
            print("请输入大于1的整数")
            continue
        else:
            for i in range(1,int(N)+1):
                print("%d--->%d" %(i, FB(i)))
        #N = input('请输入入计算斐波那契数列的项数:\n') input()再循环体内不用再次输入
    except:
        break 

请输入入计算斐波那契数列的项数:
8
1--->1
2--->1
3--->2
4--->3
5--->5
6--->8
7--->13
8--->21

同样可以利用迭代实现斐波那契数列

x , y = 0 , 1
while True:
    n = eval(input("请输入需要计算的斐波那契数列的项数:\n"))
    for i in range(1,n+1):
        x , y = y , x + y
        print("%d ---> %d" %(i , y ))、

>>>请输入需要计算的斐波那契数列的项数:
8
1 ---> 1
2 ---> 2
3 ---> 3
4 ---> 5
5 ---> 8
6 ---> 13
7 ---> 21
8 ---> 34
请输入需要计算的斐波那契数列的项数:

汉诺塔问题：

汉诺塔问题是古代的一个问题，问题的大概是：给出三个木柱X,Y,Z，其中X堆叠着从低端到顶端由大到小的圆盘，要求把所有的圆盘借助Y移动到Z,要求每一次只能移动一个，并且小的圆盘永远在大的圆盘的上面

def hanoi(n,x,y,z):
    global count   #对于count需要声明全局变量，否则在函数结束后被释放
    if n == 1:
        print(x + "--->" + z)   # n 为1 时直接移动
        count += 1
    else:
        hanoi(n-1,x,z,y) #  n-1 个先由x  移动到 y
        print(x + "--->" + z)  #剩余的一个 x 移动到 z
        count += 1  #打印都要次数加一
        hanoi(n-1,y,x,z)  #   n-1 个由 y 移动到 z
while True:
    count = 0
    N = eval(input("请输入汉诺塔的层数:输入小于1的数结束循环\n"))
    if N < 1 :
        print("结束循环计算循环！")
        break
    else:
        hanoi(N,"X","Y","Z")
        print("移动次数为:%d" %count)

3
X--->Z
X--->Y
Z--->Y
X--->Z
Y--->X
Y--->Z
X--->Z
移动次数为:7
请输入汉诺塔的层数:输入小于1的数结束循环
4
X--->Y
X--->Z
Y--->Z
X--->Y
Z--->X
Z--->Y
X--->Y
X--->Z
Y--->Z
Y--->X
Z--->X
Y--->Z
X--->Y
X--->Z
Y--->Z
移动次数为:15

在移动时，往往借助另一个完成移动，因此就用到了递归，递归时，三个柱子作用发生互换