1. Recursion基础
函数不仅可以嵌套，互相调用，而且可以自我调用，这种自我调用可以理解为recursion。为了实现这个目的，recursion的写法有两个重要部分，一个是在函数body中应该出现自我调用，另一个是给出退出和返回机制(base condition)，保证recursion可以终止。
recursion的机制是从上到下的寻找base condition，再从下到上的返回每一层recursion，例如：
def f(n):
if n < 0:
return
print(n, end = ' ')
f(n - 1)
print(n, end = ' ')
f(4)
>>>
4 3 2 1 0 0 1 2 3 4
上例说明了recursion的机制，从f(4)进入函数body，进入第二层找f(3)，再进入第三层找f(2)，继续第四层找f(1)，然后来到第五层找f(0)，再往下第六层f(-1)，触发base condition，于是执行这种情况的代码return，回到第五层f(0)并完成第五层所有代码，这时会再打印一个0，后续依次向上返回，直到完成初始命令f(4)。
2. Recursion练习
写出一段程序，输入一个list，list中的元素都是integer，函数返回这个list所有integer的sum。
def the_sum(L):
running_sum = 0
for e in L:
running_sum += e
return running_sum
这是iterative的写法，和之前的文章说的方式一致，不多赘述。
def the_sum_recursive_first(L):
if not L:
return 0
return L[0] + the_sum_recursive(L[1: ])
接下来这段代码是recursion的写法。recursion的问题分析方法和iterative 不同，recursion不从case入手分析，而是找base condition和recursion进入下一层的机制。
求一个list的sum，一定是一个一个元素加和起来的，一般情况是从list中找到一个元素，把它和当下的和加总。上面代码是找到list中的第一个元素，所以这个想法的实现代码如下，既完成了求和的目的，又完成自身调用进入了下一层。
return L[0] + the_sum_recursive(L[1: ])
接下来分析base condition，什么时候返回？当list中所有元素都加和过就可以结束，所以实现这个目的的代码如下，不仅结束向下一层的机制，而且要返回求和的base值0。
if not L:
return 0
既然可以找第一个元素，就可以找最后一个元素，所以同等复杂度的代码如下：
def the_sum_recursive_last(L):
if not L:
return 0
return L[-1] + the_sum_recursive(L[ :-1])
上述的两种recursion的方法层数都很多，效率会低下，一般机制可以继续改善。从一次只加和一个值，到同时加和两个：
def the_sum_two_recursive(L):
if len(L) == 1:
return L[0]
return the_sum_two_recursive(L[: len(L) // 2]) + the_sum_two_recursive(L[len(L) // 2: ])
上述部分Eric的课上代码由冗余，上面写的更加简练。
3. Fibonacci Number
斐波那契数列的每个数等于前两个数字的加和，有初始条件f(0) = 0, f(1) = 1。写成recursion的表达方法：
def fibo(n):
if n < 2:
return n
return fibo(n - 1) + fibo(n - 2)
fibo(5)
接下来会发现效率问题，因为计算f(3)的时候需要f(2)和f(1)，而计算f(4)的时候需要一个新的f(3)又要一个计算过的f(2)，上述的recursion方法做了大量重复运算。解决方法是记录每一个算出的值，用查询返回值的方法替代重复recursion计算。
def fibo_memorisation(n, results = {0: 0, 1: 1}):
if n not in results:
results[n] = fibo_memorisation(n - 1, results) + fibo_memorisation(n - 2, results)
return results[n]
fibo_memorisation(40)
--因为函数的第二个input有defalut值，所以调用的时候可以只给出一个input
大部分的recursion都可以用迭代方式解决：
def fibo_iterative(n):
if n < 2:
return n
i = 2
previous, current = 0, 1
while i <= n:
previous, current = current, previous + current
i += 1
return current
fibo_iterative(40)
4. Hanoi Question
汉诺塔问题是经典的recursion问题，base条件是一个碟子，general的情况是把其他碟子看做一个整体移动。
def Hanoi_recursive(n, start, spare, finish):
if n == 1:
print(f'Move disk from position {start} to position {finish}')
else:
Hanoi_recursive(n - 1, start, finish, spare)
print(f'Move disk from position {start} to position {finish}')
Hanoi_recursive(n - 1, spare, start, finish)
Hanoi_recursive(4, 'A', 'B', 'C')
汉诺塔的iterative的写法比较难懂，Eric给出了PDF解释和相应代码，这里不做讨论。
5. Yield
yield机制非常的python，过去常用的range()就是一个例子。
def f():
print('Hi')
yield 0
print('Hi again')
yield 1
print('Hi always')
yield 2
print('Bye')
F = f()
while True:
try:
print(next(F))
except StopIteration:
break
>>>
Hi
0
Hi again
1
Hi always
2
Bye
执行函数f()的时候先输出‘Hi'，然后给出generate的值0。重复这个过程1和2。最后超出了yield的值的范围，不再输出值。
6. Yield练习
输出所有小于n的质数
from math import sqrt
def primes(n):
for p in range(2, n + 1):
for d in range(2, round(sqrt(p)) + 1):
if p % d == 0:
break
else:
yield p
P = primes(100)
while True:
try:
print(next(P), end = ' ')
except StopIteration:
break
7. Permutation
输入一个数组，给出所有数的全排列：
def permute(L):
if len(L) <= 1:
yield L
#base condition：当只剩下一个元素的时候generate这个元素
else:
for i in range(len(L)):
L1 = list(L)
#复制list L
L1[0], L1[i] = L1[i], L1[0]
#把list中第一个元素和每一个元素都互换，实现全排列
for e in permute(L1[1: ]):
yield [L1[0]] + e
#确定第一个数字后，把剩下的list当成一个新的list，做recursion，yield第一个元素和后面元素的全排列结果
P = permute(list(range(4)))
while True:
try:
print(next(P))
except StopIteration:
break
自己写的排列可能会有使用问题，python自带了排列函数：
from itertools import permutations
P = permutations(list(range(5)))
for p in P:
print(p)
