python递归算法求n的阶乘 用递归函数求n的阶乘python

递归

在函数内部，可以调用其他函数;

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

例如，我们来计算阶乘：

n!= 1 x 2 x 3x ... x n，

用函数f1(n)表示，可以看出：

f1(n)= n! = 1 x 2 x 3 x ... x (n-1) x n= (n-1)! x n = f1(n-1) x n

所以，f1(n)可以表示为 n x f1(n-1)，只有n=1时需要特殊处理。

于是，f1(n)用递归的方式写出来就是：deff1(n):if n==1:return 1

return n * f1(n - 1)

上面就是一个递归函数。执行结果如下：>>> f1(1)1

>>> f1(3)6

>>> f1(10)3628800那么，利用函数编写如下数列：

斐波那契数列指的是这样一个数列

0,1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233，377，610，987，1597，2584，4181，6765，10946，17711，28657，46368...

实现代码如下：

deffunc(arg1,arg2):if arg1 ==0:printarg1, arg2
arg3= arg1 +arg2printarg3
func(arg2, arg3)
func(0,1)

执行结果如下：(“....”代表省略)

.....26863810024485359386146727202142923967616609318986952340123175997617981700247881689338369654483356564191827856161443356312976673642210350324634850410377680367334151172899169723197082763985615764450078474174626Traceback (most recent call last):

.....334151172899169723197082763985615764450078474174626Traceback (most recent call last):

File"", line 1, in #有报错

......

为什么上面有报错，难道是程序错了？其实不是，程序没错，因为“斐波那契数” 规律是前两个数相加

等于后面一个数，而程序一直不断这样执行下去，最终达到系统默认临界值，当然程序也就出错了

接下来，我们把程序再改改，我们让“不断循环的第三个值”(即arg3)大于1000的时候 返回一个值，

看看这个时候的效果，直接看下面代码

：deffunc1(arg1,arg2):if arg1 ==0:#print arg1,arg2
passarg3= arg1 +arg2if arg3 > 1000:returnarg3
func1(arg2,arg3)
result= func1(0,1)printresult

你们觉得上面打印的结果是什么？

看下面执行结果：>>> printresult

None

这是为什么，苦苦熬了这么多年，终于等到你，>~<...>

上面代码分解如下：

deffunc1(arg1,arg2):#arg1 = 0 ,arg2 = 1，第2次：arg1 = 1，arg2 = 1,第3次：arg1 = 1,arg2 = 2,
第4次：arg1 = 2,arg2 = 3,if arg1 == 0: #满足条件，开始执行
#print arg1,arg2
pass #不做任何处理
arg3= arg1 + arg2 #走到这一步，arg3 = 0 + 1 = 1,第2次：arg3 = 1 + 1 = 2，
第3次，arg3 = 1 + 2 = 3，第4次:arg3 = 2 + 3 = 5, .... 执行到第18次....if arg3 > 1000: #第一次循环不符合条件，绕开return arg3,而继续往下执行；....
假设执行到第18次时符合条件，那么就会执行下面的代码，即 returnarg3 会被执行！！！returnarg3#第一次循环不执行，2，3，4次都一样不执行；.....，假设第18次时符合条件，并且执行
了return arg3，重点来了！！！！，这个时候我们都知道，函数体中，一个值被return，
那么这个函数的生命周期也就结束，不再往下执行，也就意味着下面的func1(arg2,arg3)

没有被执行.

func1(arg2,arg3)#自身调用第2个和第3个的值，即第1次为：1 ，1 第2次为1，2，第3次：2，3 第4次：3，5 ....

假设执行到第18次，这个时候没有被执行，因为上面return的出现，函数生命周期已经结束

(重点！！：分析：既然18次时符合条件，并且return arg3，函数直接出去了,大家不妨想想，

那么在出去之前，它的上一次执行，也就是第17次并没有在func1(arg2,arg3)这一步，将这个

函数的值return(返回)给func1(arg1，arg2),也就意味着，17次没有返回，而18次时，

函数生命周期也已经结束！之后执行函数外面的操作，result= func1(arg1，arg2)，printresult，

接着往下看：

大家都知道，如果要将一个函数赋值给一个变量，假设这么赋值：result=func1(“值”，“值”)，

那么这个函数肯定会有一个返回值，同时赋值给这个变量，由于17次没有return func1(arg2，

arg3)给func1(arg1,arg2)，18次时函数结束，那么这个函数的默认返回值就是None(即空值)

那么赋值给这个变量和打印这个变量也就是None

同时大家记住一句话：python 函数默认是从上往下执行

result= func1(0,1) #第一次开始执行，赋值！第18次赋值，这个时候是None

print result #第1，2，3，4都不执行，因为这个是在函数外，只有函数结束后才行，....

第18次，这里打印了最终值"None"

===============================

递归1.什么是递归 recursion 递归　　　　　　递归的定义--------在个一个函数里再调用这函数本身　　　　　　在一个函数里再调用这个函数本身，这种魔性的使用函数的方式就叫做递归。　　　　　　递归的最大深度——997　　　　一个函数在内部调用自己 递归的层数在python里是有限制的 997/998层2.层数可以修改 sys模块

1 import sys #python限制在997/998
2 sys.setrecursionlimit(10000000) #可以修改
3 COUNT = 0
4 def func(): #recursion 递归
5 global COUNT
6 COUNT += 1
7 print(COUNT)
8 func()
9
10 func()

3.解耦要完成一个完整的功能，但这个功能的规模要尽量小，并且和这个功能无关的其他代码应该和这个函数分离

1.增强代码的重用性

2.减少代码变更的相互影响

4.实例一,求年龄 1 #写递归函数必须要有一个结束条件

2 #sj
3 #1 sj egon + 2 n=1 age(1) = age(2) + 2
4 #2 egon wusir + 2 n=2 age(2) = age(3) + 2
5 #3 wusir + 2 n=3 age(3) = age(4) + 2
6 #4 40 n=4 age(4) = 40
7
8 def age(n):
9 if n == 4:
10 return 40
11 return age(n+1)+2
12
13 # age(1) #46
14 # def age(1):
15 # return 46
16 # age(1)=age(2)+2=age(3)+2+2=age(4)+2+2+2
17 # def age(2):
18 # return 44
19 #
20 # def age(3):
21 # return 42
22 #
23 # def age(4):
24 # if 4 == 4:
25 # return 405.实例二,求阶乘1 #求阶乘 n = 7 7*6*5*4*3*2*1
2 def func(n):
3 if n == 1:
4 return 1
5 else:
6 return n*func(n-1)
7
8 ret = func(4)
9 print(ret)
10
11 # #n = 4
12 # def func(4):
13 # return 24
14 # 4*3*2*1
15 # #n = 3
16 # def func(3):
17 # return 6
18 #
19 # #n = 2
20 # def func(2):
21 # return 2
22 #
23 # #n = 1
24 # def func(n):
25 # if n == 1:
26 # return 16.实例三,递归遍历目录和文件#!/usr/bin/python #coding:utf8 import os def dirlist(path, allfile): filelist = os.listdir(path) 列出目录下的文件 for filename in filelist: filepath = os.path.join(path, filename) 为文件添加绝对路径 if os.path.isdir(filepath): 如果文件为目录 dirlist(filepath, allfile) 继续递归 else: allfile.append(filepath) 不是文件就将路径放置列表中 return allfile print dirlist("/home/yuan/testdir", []) 【完】

-------------------

一、嵌套函数

1、嵌套函数简单的理解可以看作是在函数的内部再定义函数，实现函数的“私有”。

2、特点：

<1> 函数内部可以再次定义函数。

<2> 只有被调用时才会执行(外部函数被调用后，被嵌套函数调用才有效)。

3、实例如下：

#！/usr/bin/env python3
#-*- coding:utf-8 -*-
def func1():
print('hello world!')
def func2():
print('everyone...')
func1() # 输出：hello world! ，此时func2未被调用并不执行

4、然而嵌套函数并一定就是长这样，不信，继续往下看...

为了更直观，我直接放出几种情形的案例，如下：

1 #！/usr/bin/env python3
2 #-*- coding:utf-8 -*-
3
4 #情形1
5 name = 'cc'
6 def func1():
7 name = 'sc'
8 print(name)
9 def func2():
10 #name = 'df'
11 print(name)
12 func2()
13 func1() #输出：sc df，当第10行被注释时，输出：sc sc，
14 #嵌套函数中的变量层层调用，当前函数中没有便向上一级函数查找
15
16 #情形2
17 age = 21
18 def func1():
19 def func2():
20 print(age) #输出：18，当前函数中并没有定义(‘第二层局部变量’)age，向第一层找
21 age = 18 #与func2位于同一层，‘第一层局部变量’
22 func2()
23 print(func1(),age) #输出：None ,21，此时，函数外输出的age只能是全局变量
24
25 #情形3
26 age = 21
27 def func1():
28 def func2():
29 print(age)
30 func2()
31 #age = 18
32 func1() #当31行不被注释时，运行会报错，打印age时会混淆全局age和局部age；
33 #当31行被注释时，输出： 21，此时func2调用全局age
34
35 #情形4
36 age = 21
37 def func1():
38 global age #声明全局变量
39 def func2():
40 print('func2中的：',age) #输出>>func2中的： 21, age此时引用的是36行的全局变量
41 func2()
42 age = 18 #由于已经声明age是全局变量，所以此处的重新赋值就是对全局修改
43 func1()
44 print('全局中的：',age) #输出>>全局中的： 18, 变量age在函数func1中被修改
45
46 #情形5
47 age = 21
48 def func1():
49 global age
50 def func2():
51 print('func4中的：',age) #输出>>func2中的： 18, age此时引用的是47行的全局变量
52 age = 18 #由于已经声明age是全局变量，所以此处的重新赋值就是对全局修改
53 func2()
54 func1()
55 print('全局中的：',age) #输出>>全局中的： 18， 变量age在函数func1中被修改
'''

情形4和情形5的区别在于age变量的修改在程序中的执行顺序，在func2调用前还是在func2调用之后，

如果是在func2调用前修改age,则func2中输出的则是修改后的；如果是在func2调用后修改age,则func2中

输出的就是未修改时的全局变量age,所以两者func2函数中输出的age值不同，但最后的全局输出相同。

'''

二、递归函数

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

2、实例：

def calc(n):
n = n // 2
print(n) # 输出：9 4 2 1 0 0 0 .... //到1000层结束调用
calc(n) # 重复调用自身
calc(19)

查看默认调用层次的方法:

# -*-coding:utf-8 -*-
import sys
print(sys.getrecursionlimit()) #查看递归默认限制层数，默认是1000

3、递归调用的过程

#递归的执行过程
def func_re(n):
n = n // 2 # 地板除，商保留整数
print(n)
if n > 0:
func_re(n)
print(n)
func_re(13)
'''

python中递归执行的逻辑是一层层调用，再一层层退出，可通过调试断点查看

6
3
1
0
0
1
3
6
'''

4、到这里，我们可以总结下递归的特性了：

<1> 必须要有明确的终止条件

<2> 每进入更深一层递归时，问题规模相比上次都应有所减少

<3> 递归效率不高，层次过多会导致栈溢出

5、了解了递归调用的过程，那么如果我不想它一直调用下去，而是满足某一条件就返回，不再执行了呢？该怎么做呢？

实例如下：

def calc(n,count):
'''
:param n: 需要进行递归的对象
:param count: 计数器
:return: 条件不成立时，返回最终值
'''
print(n,count)
if count < 5: #运行第五次时退出
return calc(n//2,count+1) #每一层接收它下一层的值，return必不可少，否则倒数第三层无法接收倒数第二层的返回值
else:
return n # 最终结果返回到倒数第二层(即上一个return)，只执行一次
func = calc(199,1)
print('res运算第五次时的结果：',func) # 输出>>res运算第五次时的结果： 12.4375

当然，递归的用处不止于此，二分查找就是递归很好的应用：

data1 = [1,23,43,54,654,4544,34523]
def search(data1,find_num):
print(data1)
if len(data1) > 1:
middle = len(data1)//2
if data1[middle] == find_num:
print('找到了',data1[middle])
elif data1[middle]>find_num:
print('要找的数在%s左边'%data1[middle])
return search(data1[middle],find_num)
else:
print('要找的数在%s右边'%data1[middle])
return search(data1[middle], find_num)
else:
if data1[0] == find_num:
print('找到了',data1[0])
else:
print('你要找的数不在列表中')
search(data1,54)

View Code

三、高阶函数

1、定义：变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，

这种函数称之为高阶函数。

2、满足高阶函数的条件(任意一个)：

<1> 接受一个或多个函数作为输入

<2> return 返回另外一个函数

3、实例如下:

#！/usr/bin/env python3
#-*- coding:utf-8 -*-
# 接受一个或多个函数作为输入
def func(a,b):
return a-b
def func2(x):
return x
f = func2(func)
print(f(5,2)) # 3
# reyurn 返回另外一个函数
def func3(a,b):
return abs,a,b # abs为内置方法
res = func3(3,-5)
print(res) # 输出：(, 3,-5)，一个元组
print(res[0](res[1]+res[2])) #输出：2

=======================