python递归必须要有_python递归

在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

(1)递归就是在过程或函数里调用自身；

(2)在使用递归策略时，必须有一个明确的递归结束条件，称为递归出口。

递归算法一般用于解决三类问题：

(1)数据的定义是按递归定义的。(比如Fibonacci函数)

(2)问题解法按递归算法实现。(回溯)

(3)数据的结构形式是按递归定义的。(比如树的遍历，图的搜索)

递归的缺点：递归算法解题的运行效率较低。在递归调用的过程当中系统为每一层的返回点、局部量等开辟了栈来存储。递归次数过多容易造成栈溢出等。

"""非递归方式呈现"""

sum = 0

for obj in range(1,101):

sum+=obj

print sum

""""1+2+3+...+100"""

def foo(n):

if n>0:return n+foo(n-1)

if n<=0:return 0

print foo(100)

"""阶乘"""

def fac(n):

if n==0 or n==1:

return 1

else:

return n*fac(n-1)

print fac(10)

def fact(n):

if n==1:

return 1

return n * fact(n - 1)

上面就是一个递归函数。可以试试：

如果我们计算fact(5)，可以根据函数定义看到计算过程如下：

===> fact(5)

===> 5 * fact(4)

===> 5 * (4 * fact(3))

===> 5 * (4 * (3 * fact(2)))

===> 5 * (4 * (3 * (2 * fact(1))))

===> 5 * (4 * (3 * (2 * 1)))

===> 5 * (4 * (3 * 2))

===> 5 * (4 * 6)

===> 5 * 24

===> 120

递归函数的优点是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。

使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈(stack)这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。可以试试fact(1000)：

def fact_iter(product,count,max):

if count > max: ####

return product ####

return fact_iter(product * count, count+1, max) ###

print(fact_iter(1,1,5)) #1*1*2*3*4*5

print(fact_iter(1,2,5))

print(fact_iter(2,3,5)) #2*3*4*5

print(fact_iter(6,4,5)) #6*4*5

print(fact_iter(24,5,5)) #24*5

print(fact_iter(120,6,5)) #120

使用递归函数的优点是逻辑简单清晰，缺点是过深的调用会导致栈溢出。

针对尾递归优化的语言可以通过尾递归防止栈溢出。尾递归事实上和循环是等价的，没有循环语句的编程语言只能通过尾递归实现循环。

Python标准的解释器没有针对尾递归做优化，任何递归函数都存在栈溢出的问题。