[Python系列] Python函数及函数式编程(六)
第五节 递归函数
在前面的课程中，我们深入介绍了如何创建和调用函数。函数可以调用其他函数，但可能让你感到惊讶的是，函数还可以调用自己。
递归是怎么定义的呢？
递归：参见"递归”
这种解释挺蠢的，我们再来看一段代码，它是一个函数调用自身的实例
def recursion():
print(1)
recursion()
recursion()
# RecursionError: maximum recursion depth exceeded while calling a Python object
该函数没有任何意义，只是在自身调用自身。当我们运行它，一段时间之后，这个程序崩溃了。。。
理论上来说，这个函数会一直运行下去，但每次函数执行时都会消耗一些内存，创建一个新的命名空间，因此当函数的调用次数达到一定程度并且之前的函数没有返回（终止）时，就会导致程序终止并提示错误信息"超过最大递归层级"。
这个函数的递归可以称为无穷递归，因为它理论上永远不会停止，相比无限循环，对我们编程的帮助更少。。。那我们该如何写出一个能对我们有所帮助的递归呢？
递归和递推
递归和递推是计算机中解决问题时常用的方法，通过对比，我们探究一下递归的使用
先来看一个例子：
假设你要通过一个函数求出n的阶乘，也就是1*2*3*4…*(n-1)*n的值，你该怎么做呢？
按照一般的思路，我们可以这样思考：
- 在求阶乘的时候，从1开始往后乘
- 寻找规律乘法运算中的后一个乘数比前一个乘数大1
- 最大的乘数是n
因此我们不妨按照规律，从1一直乘到边界n
那么，函数就呼之欲出了
def get_res(n):
result = 1
for i in range(1,n+1):
result *= i
return result
get_res(3)
# 6
其实，这种思考问题的方法就是递推。
递推是人本能的正向思维，我们小时候学习数数，从1，2，3一直数到100，就是典型的递推。类似地，我们在学习过程中循序渐进，出发点都是这样正向，由易到难，由小到大，由局部到整体，从1乘到100，这在生活中这种做法不仅合情合理，而且是天然而成的，我们从来不觉得它有什么问题。
简单的总结，递推其实是在已知边界值的情况下按照规律进行推导
但是上面的问题要交给计算机，计算机是怎么算的呢？
它是倒着来的。比如要算5！，计算机就把它变成5x4！（五乘以四的阶乘）。当然，你会说，4！还不知道呢。没关系，计算机会说，采用同样的方法，把它变成4x3！。至于3！，则用同样的算法处理。最后做到1！时，计算机知道了它就等于自己，即1！＝1，从此不再往下扩展了。接下来，就是倒推回所有的结果，由于知道了1！，2！，然后3！，4！，5！就统统都知道了。
这种思路就是递归。相比于递推的"由小及大"，递归更像是"由大及小"。我们再来看一看这道题，由大及小的分析一下
- n的阶乘是n-1的阶乘乘以n
- 1的阶乘是1
只要有了最小问题的解（基线条件），和通解（递归条件）那么我们就可以动手写函数了
def get_res(n):
if n == 1:
return 1 # 如果求1的阶乘，直接给他
return n * get_res(n-1) # 如果求大于1的n的阶乘，给他n-1的阶乘乘以n
get_res(3)
# 6
是不是很惊喜？我们很清晰明了，并且方便快捷的解决了问题。
如果还原get_res(5)的运算过程，应该是这样的
===> get_res(5) # 返回值还不是终值，依次调用 依次入栈
===> 5 * get_res(4)
===> 5 * (4 * get_res(3))
===> 5 * (4 * (3 * get_res(2)))
===> 5 * (4 * (3 * (2 * get_res(1)))) # 到达基线条件 先入后出，依次出栈进行计算
===> 5 * (4 * (3 * (2 * 1)))
===> 5 * (4 * (3 * 2))
===> 5 * (4 * 6)
===> 5 * 24
===> 120
递归的过程其实也名如其意，递出去，再还回来。每一次的函数调用都要入栈，直到基线条件，依次出栈。
简单的总结,递归其实是知道终点（基线条件）的情况下，由大及小的对问题进行降解。
我们在上文中用到了栈的概念，也提到了先进后出，其实可以把栈看作一种存储数据的方式，类似我们吃饭的饭盒，先放进去的菜在最下面，最后才吃得到
使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。可以试试
get_res(1000)
其实理解了递归和递推，我们解决问题的思路就会宽阔很多。在来一个问题：
求 x 的 n 次幂 x非0，n为整数
递推的思路：
- x的0次方为1
- x的n次方是n个x相乘
代码：
def get_res(x,n):
result = 1
for i in range(0,n):
result *= x
return result
换做递归呢？思路同样也简单：
- 任非零整数的0次幂为1
- xn 是x * xn-1的积
代码：
def get_res(x,n):
if n == 0:
return 1
else:
return get_res(x,n-1)*x
在很多情况下，因为不需要重复的入栈，递推的效率会比递归高，然而很明显，递归的可读性更好一些。
二分查找
递归的一个经典案例就是二分查找。二分查找是程序中很常用的一种算法。
想象你对面的人心中有一个1～100的数字，你要猜出是哪个，当然，猜100次肯定对，但最少要猜多少次呢？其实我们没有必要每次都给一个准确的数字，只需要不断的缩小范围即可。
首先问：“这个数字大于50吗”，如果是肯定的，那么继续提问"这个数字大于75吗？"，不断的将区间减半，直到猜对为止。
对于列表也是一样，对于给定上下区间的列表，列表元素为递增的值,每次寻找某值，只需要不断的将范围减半，就能很快的查找到。如果使用递归，那么基线条件就已经确定了: “区间上限=区间下限”
思路：
- 如果上限和下限相同，就说明它们都指向数字所在的位置，因此将这个数字返回。
- 否则，找出区间的中间位置(上限和下限的平均值)，再确定数字在左半部分还是右半部分。然后在继续在数字所在的那部分中查找。
代码：
def search(mylist,number,lower=0,upper=None): # 给出默认值
if upper is None: # 如果没有上限，上限是最大索引值
upper = len(mylist)-1
if lower == upper: # 如果上下限相等，直接找到位置
return lower
else:
middle = (lower + upper) // 2 # 否则二分查找
if number > mylist[middle]:
return search(mylist,number,middle+1,upper)
else:
return search(mylist,number,lower,middle)
seq = [34, 67, 8, 123, 4, 100, 95]
seq.sort()
print(search(seq,100))
# 6
这样写的好处在哪里呢？
如果我们用递推去寻找，方法很简单，只需要使用for循环遍历每一个列表元素并比较即可
seq = [34, 67, 8, 123, 4, 100, 95]
def search(mylist,number):
for val in mylist:
if val == number:
return mylist.index(number)
print(search(seq,100))
# 5
虽然递推看上去更简单了一些，但是从查找次数上来说，如果寻找100个数，而恰巧找的是100，递推必须要推到100次才能找到，而递归，只需要7次。二分查找的效率非常高。
总结
- 使用递归函数的优点是逻辑简单清晰，缺点是过深的调用会导致栈溢出。
- 递归需要寻找基线条件，总结递归条件
- 递推需要总结规律，寻找边界值