递归 在函数内部，可以调用其他函数; 如果一个函数在内部调用自身本身，这个函数就是递归函数。 例如，我们来计算阶乘： n! = 1 x 2 x 3 x ... 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)用递归的方式写出来就是： def f1(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 ... 实现代码如下： def func(arg1,arg2): if arg1 == 0: print arg1, arg2 arg3 = arg1 + arg2 print arg3 func(arg2, arg3) func(0,1) 执行结果如下：(“....”代表省略) ..... 26863810024485359386146727202142923967616609318986952340123175997617981700247881689338369654483356564191827856161443356312976673642210350324634850410377680367334151172899169723197082763985615764450078474174626 Traceback (most recent call last): ..... 334151172899169723197082763985615764450078474174626 Traceback (most recent call last): File "<stdin>", line 1, in <module> #有报错 ...... 为什么上面有报错，难道是程序错了？其实不是，程序没错，因为“斐波那契数” 规律是前两个数相加 等于后面一个数，而程序一直不断这样执行下去，最终达到系统默认临界值，当然程序也就出错了 接下来，我们把程序再改改，我们让“不断循环的第三个值”（即arg3）大于1000的时候 返回一个值， 看看这个时候的效果，直接看下面代码： def func1(arg1,arg2): if arg1 == 0: #print arg1,arg2 pass arg3 = arg1 + arg2 if arg3 > 1000: return arg3 func1(arg2,arg3) result = func1(0,1) print result 你们觉得上面打印的结果是什么？ 看下面执行结果： >>> print result None 这是为什么，苦苦熬了这么多年，终于等到你，>~< ...(哈哈，开个玩笑) 上面代码分解如下： def func1(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次时符合条件，那么就会执行下面的代码，即 return arg3 会被执行！！！ return arg3 #第一次循环不执行，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），print result， 接着往下看： 大家都知道，如果要将一个函数赋值给一个变量，假设这么赋值：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)
三、高阶函数
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) # 输出：(<built-in function abs>, 3,-5)，一个元组
print(res[0](res[1]+res[2])) #输出：2