1、函数嵌套
多个函数嵌套在一起即为函数嵌套
在调用函数时，函数需在调用之前定义，如果函数在调用之后才定义，则不能被成功调用。
当定义多个函数时，函数名称不能相同，否则后定义的函数会将之前的函数覆盖，即之前的函数失效。
1 #定义一个函数，划一条横线 2 def printLine(): 3 print('-'*30) 4 5 #定义一个函数，调用上一个函数，并按用户输入的值划出指定条数的横线 6 def stringPrint(index): 7 i = 0 8 while i<index: 9 printLine() 10 i+=1 11 12 indexNum = int(input('请输入横线的行数：')) 13 stringPrint(indexNum)
注意：
最初需求为划一条横线，当需要变更为按用户需求划出n条横线时，不要直接更改原有的函数代码，因为原函数可能在其他地方也被调用，而应该重新定义一个函数来实现新的功能，当需要重复执行原函数的功能时，可以直接调用原函数，而不要重复编写原函数的代码。
求3个数的和、3个数的平均值
1 #定义一个函数，求3个数的和： 2 def sum3Num(a,b,c): 3 sum = a+b+c 4 return sum 5 6 #定义一个函数，求3个数的平均值 7 def ava3Num(a,b,c): 8 sum = sum3Num(a,b,c) 9 ava = sum/3 10 return ava 11 12 a = int(input('请输入第一个数：')) 13 b = int(input('请输入第二个数：')) 14 c = int(input('请输入第三个数：')) 15 16 result = sum3Num(a,b,c) 17 ava = ava3Num(a,b,c) 18 print('和为%d'%result) 19 print('平均值为%d'%ava)
2、高阶函数
既然变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。
一个最简单的高阶函数：
1 def add(x, y, f): 2 return f(x) + f(y)
当我们调用add(-5, 6, abs)时，参数x，y和f分别接收-5，6和abs
add(-5, 6, abs)
11
编写高阶函数，就是让函数的参数能够接收别的函数。
有两种情况属于高阶函数：
1、把一个函数的内存地址当作参数传给另外一个函数
2、一个函数把另外一个函数当作返回值返回
例子
编写一个函数calc_prod(lst)，它接收一个list，返回一个函数，返回函数可以计算参数的乘积。
1 def calc_prod(lst): 2 def lazy_prod(): 3 def f(x, y): 4 return x * y 5 return reduce(f, lst, 1) 6 return lazy_prod 7 f = calc_prod([1, 2, 3, 4]) 8 print f()
在函数calc_proc内部返回了内部函数的值，但是没有调用内部函数，所以在全局命名变量f时不会调用函数lazy_prod()
当f()时才会调用，可以选择在需要的时候通过f()进行调用，也称为延迟调用。
如果函数calc_proc内部返回了lazy_prod()的话就会在全局定义变量f时就会调用内部函数。
3、递归函数
在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。
python默认递归函数最多能有999层，也可以改默认值
import sys sys.setrecursionlimit(10000) def func(x): print(x) x +=1 func(x) func(1)
将递归函数默认限制层数改成10000，实际执行测试时可以执行8000多次，要看PC性能了。
举个例子，我们来计算阶乘n! = 1 x 2 x 3 x ... x n，用函数fact(n)表示，可以看出：
fact(n) = n! = 1 x 2 x 3 x ... x (n-1) x n = (n-1)! x n = fact(n-1) x n
所以，fact(n)可以表示为n x fact(n-1)，只有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
于是，fact(n)用递归的方式写出来就是：
1 def fact(num): 2 if num == 1: 3 return 1 4 return num*fact(num-1) 5 6 result = fact(5) 7 print('fact=%d'%result)
或者
1 def fact(num): 2 if num>1: 3 return num*fact(num-1) 4 return 1
计算10的阶乘也可以使用reduce
1 from functools import reduce 2 def fact(n): 3 return reduce(lambda x,y:x*y, range(1,n+1) ) 4 print(fact(10)) 5 6 或者直接输出： 7 print(reduce(lambad x,y:x*y, range(1,11)))
也可以使用for循环相乘
1 def cal(n): 2 result = 1 3 for i in range(1,n+1): 4 result *=i 5 print(result) 6 cal(4)
或倒序
1 def cal(n): 2 for i in range(n-1,0,-1): 3 n*=i 4 return n 5 print(cal(4))
或
1 def cal(n): 2 result = 1 3 for i in range(n,0,-1): 4 result*=i 5 return result 6 print(cal(4))
例子：生成一个斐波那契数列
def fib(max): a = 0 b = 1 n = 0 while n<max: print(b) a, b = b, a+b n+=1 fib(8)
结果：
1
1
2
3
5
8
13
21
输出斐波那契数列中指定下标的数字
def fib2(n): if n == 1 or n == 2: return 1 elif n > 2: return fib2(n-2) + fib2(n-1) print(fib2(5))
结果：5
例子：将列表中的3变成字符串‘101’
lis = [2, 3, "k", ["qwe", 20, ["k1", ["tt", 3, "1"]], 89], "ab", "adv"]
# 创建一个列表循环函数，如果元素还是列表，就再调用列表循环函数，直到元素不是列表类型了，再判断元素如果等于3就换成'101'
1 def change(li, old, new): 2 for i in range(len(li)): 3 if isinstance(li[i], list): 4 change(li[i],old,new) 5 if li[i] == old: 6 li[i] = new 7 change(lis, 3, '101') 8 print(lis)
4、二分查找
li = [1,2,3,5,6,8,10,12,15,16,17,18,20]
#li_1 = list(range(1,10000000))#试验了查了22次能查1000万，查1亿需要25次，电脑快死机了不知道为什么
1 def find(find_str, lst, count): 2 mid = len(lst) // 2 3 if len(lst) == 1: 4 if find_str == lst[0]: 5 count +=1 6 print('找了' + str(count) + '次就找到了') 7 elif mid > 0: 8 if lst[mid] == find_str: 9 count += 1 10 print('找了' + str(count) + '次就找到了') 11 elif lst[mid] > find_str: 12 find(find_str, lst[:mid], count + 1) 13 else: 14 find(find_str, lst[mid + 1:], count + 1) 15 else: 16 print('找了' + str(count) + '次也没找到') 17 find(200,li, 0)
5、函数返回值
Python的函数不但可以返回int、str、list、dict等数据类型，还可以返回函数！
例如，定义一个函数 f()，我们让它返回一个函数 g，可以这样写：
def f(): print 'call f()...' def g(): print 'call g()...' return g
仔细观察上面的函数定义，我们在函数f内部又定义了一个函数g。由于函数g也是一个对象，函数名g就是指向函数g的变量，所以，最外层函数f可以返回变量g，也就是函数g本身。
调用函数 f，我们会得到 f 返回的一个函数：
>>> x = f() #调用f()
call f()...
>>> x #变量x是f()返回的函数：
<function g at 0x1037bf320>
>>> x() #x指向函数，因此可以调用
call g()... #调用x()就是执行g()函数定义的代码
请注意区分返回函数和返回值：
def myabs(): return abs # 返回函数 def myabs2(x): return abs(x) # 返回函数调用的结果，返回值是一个数值
返回函数可以把一些计算延迟执行。例如，如果定义一个普通的求和函数：
def calc_sum(lst): return sum(lst)
调用calc_sum()函数时，将立刻计算并得到结果：
>>> calc_sum([1, 2, 3, 4])
10
但是，如果返回一个函数，就可以“延迟计算”：
def calc_sum(lst): def lazy_sum(): return sum(lst) return lazy_sum
# 调用calc_sum()并没有计算出结果，而是返回函数:
>>> f = calc_sum([1, 2, 3, 4])
>>> f
<function lazy_sum at 0x1037bfaa0>
# 对返回的函数进行调用时，才计算出结果:
>>> f()
10
由于可以返回函数，我们在后续代码里就可以决定到底要不要调用该函数。
例子：
编写一个函数calc_prod(lst)，它接收一个list，返回一个函数，返回函数可以计算参数的乘积。
from functools import reduce
def calc_prod(lst): def lazy_prod(): def f(x, y): return x * y return reduce(f, lst, 1) return lazy_prod a = calc_prod([1, 2, 3, 4]) print(a())
结果：24
6、闭包
在函数内部定义的函数和外部定义的函数是一样的，只是他们无法被外部访问：
def g(): print 'g()...' def f(): print 'f()...' return g
将 g 的定义移入函数 f 内部，防止其他代码调用 g：
def f(): print 'f()...' def g(): print 'g()...' return g
但是，例如下面定义的 calc_sum 函数：
def calc_sum(lst): def lazy_sum(): return sum(lst) return lazy_sum
注意: 发现没法把 lazy_sum 移到 calc_sum 的外部，因为它引用了 calc_sum 的参数 lst。
像这种内层函数引用了外层函数的变量（参数也算变量，并且是非全局变量），然后逐层返回内层函数的情况，称为闭包（Closure）。
闭包的特点是返回的函数还引用了外层函数的局部变量，所以，要正确使用闭包，就要确保引用的局部变量在函数返回后不能变。举例如下：
# 希望一次返回3个函数，分别计算1x1,2x2,3x3:
def count():
fs = []
for i in range(1, 4):
def f():
return i*i
fs.append(f)
return fs
f1, f2, f3 = count()
print(f1(),f2(),f3())
你可能认为调用f1()，f2()和f3()结果应该是1，4，9，但实际结果全部都是 9（可以验证）。
原因就是当count()函数返回了3个函数时，这3个函数所引用的变量 i 的值已经变成了3。由于f1、f2、f3并没有被调用，所以，此时他们并未计算 i*i，当 f1 被调用时：
>>> f1()
9 # 因为f1现在才计算i*i，但现在i的值已经变为3
因此，返回函数不要引用任何循环变量，或者后续会发生变化的变量。
返回闭包不能引用循环变量，请改写count()函数，让它正确返回能计算1x1、2x2、3x3的函数。
def f(j): def g(): return j*j return g
它可以正确地返回一个闭包g，g所引用的变量j不是循环变量，因此将正常执行。
在count函数的循环内部，如果借助f函数，就可以避免引用循环变量i。
def count(): fs = [] for i in range(1, 4): def f(j): def g(): return j*j return g r = f(i) fs.append(r) return fs f1, f2, f3 = count() print(f1(), f2(), f3())
或
def count(): fs = [] for i in range(1, 4): def f(j): return j*j fs.append(f(i)) return fs f1,f2,f3=count() print(f1,f2,f3)
结果为1，4，9
例子2
li = [] for i in range(10): def func(): return i li.append(func) for j in li: print(j())
结果全是9，因为在循环时添加到列表中的只是函数名或者叫函数内存地址，而并没有调用函数，因为i的值并没有添加到列表中 #而当循环列表中的函数，再挨个调用时才传入i的值，这时i为9
print(li)
可以看到列表中只是函数内存地址 [<function func at 0x02781A50>, <function func at 0x027818A0>, <function func at 0x02781A98>, <function func at 0x02781B28>,
<function func at 0x02781B70>, <function func at 0x02781BB8>, <function func at 0x02781C00>, <function func at 0x02781C48>,
<function func at 0x02781C90>, <function func at 0x02781CD8>]
li = [] for i in range(10): def func(): return i li.append(func()) print(li)
结果： [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
这次是在循环时就调用了函数func()，所以结果是将i的值循环加入了列表
l1 = [lambda x:x+i for i in range(10)] for j in l1: print(j(1))
#结果全是10，因为列表中是10个函数内存地址，在调用j()时才将最终的i=9传入函数
print(l1)
#[<function <listcomp>.<lambda> at 0x02151A98>, <function <listcomp>.<lambda> at 0x02151AE0>, <function <listcomp>.<lambda> at 0x02151A50>,
<function <listcomp>.<lambda> at 0x021518A0>, <function <listcomp>.<lambda> at 0x02151BB8>, <function <listcomp>.<lambda> at 0x02151C00>,
<function <listcomp>.<lambda> at 0x02151C48>, <function <listcomp>.<lambda> at 0x02151C90>, <function <listcomp>.<lambda> at 0x02151CD8>,
<function <listcomp>.<lambda> at 0x02151D20>]
l2 = (lambda x:x+i for i in range(10)) for j in l2: print(j(1))
#结果是1-10，因为用()时是生成了一个生成器表达式，只有被调用时才返回值
print(l2)
#<generator object <genexpr> at 0x0215EB70>
例子3
Python遇到闭包，空间不会随着函数的执行结束而消失，保存闭包数据不会销毁
def wrapper(x): n = 1 def inner(): nonlocal n n += x print(n) return inner ret = wrapper(5) ret() ret() ret() ret()
6
11
16
21
判断闭包函数的方法__closure__
#输出的__closure__有cell元素 ：是闭包函数 def func(): name = 'eva' def inner(): print(name) print(inner.__closure__) return inner f = func() f() #输出的__closure__为None ：不是闭包函数 name = 'egon' def func2(): def inner(): print(name) print(inner.__closure__) return inner f2 = func2() f2()
from urllib.request import urlopen def index(): url = "http://www.xiaohua100.cn/index.html" def get(): return urlopen(url).read() return get xiaohua = index() content = xiaohua() print(content)
3415
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
