一、高阶函数
变量可以指向函数
>>> abs(-10) 10
>>> abs <built-in function abs>
只写函数名，说明abs指向了一个地址
>>> x = abs(-10) >>> x 10
把结果赋值给变量
>>> f = abs >>> f <built-in function abs>
试一试函数能否赋值
>>> f = abs >>> f(-10) 10
结论：变量可以指向函数
函数名也是变量
>>> abs = 10 >>> abs(-10) Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: 'int' object is not callable
结论：abs这个变量已经不指向求绝对值函数了，函数名也是变量
传入函数
既然变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。
一个最简单的高阶函数：
1 def add(x, y, f): 2 return f(x) + f(y) 3 4 print(add(-5, 6, abs))
虽然可以这么做，但是在实践当中，不会这么采用，以免造成冲突
map/reduce
map()函数的底层实现
1 def map_test(func,li): 2 L = [] 3 for x in li: 4 L.append(func(x)) 5 return L 6 7 def Add(data): 8 return data + 1 9 10 rest = list(map_test(Add,[1,2,3])) 11 print(rest)
map()函数接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回
1 >>> def f(x): 2 ... return x * x 3 ... 4 >>> map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9]) 5 [1, 4, 9, 16, 25, 36, 49, 64, 81]
reduce()函数的第层实现
1 def reduce_test(func,li): 2 total = 0 3 # total = 1 4 for i in li: 5 total = func(total,i) 6 return total 7 8 def Add(x, y): 9 return x + y 10 11 def Multi(x, y): 12 return x * y 13 14 # rest = reduce_test(Add,[1,2,4,5]) 15 # rest = reduce_test(Multi,[1,2,4,5]) 16 rest = reduce_test(lambda x,y:x+y,[1,2,4,5]) 17 print(rest)
再看reduce的用法。reduce把一个函数作用在一个序列[x1, x2, x3...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算，其效果就是：
reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
比方说对一个序列求和，就可以用reduce实现：
1 >>> def add(x, y): 2 ... return x + y 3 ... 4 >>> reduce(add, [1, 3, 5, 7, 9]) 5 25
str转换int
1 def str2int(s):
2 def fn(x, y):
3 return x * 10 + y
4 def char2num(s):
5 return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]
6 return reduce(fn, map(char2num, s))
fitter
fitter函数用于过滤序列
和map()类似，filter()也接收一个函数和一个序列。和map()不同的时，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。
例如，在一个list中，删掉偶数，只保留奇数，可以这么写：
1 def is_odd(n): 2 return n % 2 == 1 3 4 filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]) 5 # 结果: [1, 5, 9, 15]
sorted
Python内置的sorted()函数就可以对list进行排序：
1 >>> sorted([36, 5, 12, 9, 21]) 2 [5, 9, 12, 21, 36]
此外，sorted()函数也是一个高阶函数，它还可以接收一个比较函数来实现自定义的排序。比如，如果要倒序排序，我们就可以自定义一个reversed_cmp函数：
1 def reversed_cmp(x, y): 2 if x > y: 3 return -1 4 if x < y: 5 return 1 6 return 0
7 >>> sorted([36, 5, 12, 9, 21], reversed_cmp) 8 [36, 21, 12, 9, 5]
二、返回函数
函数作为返回值
1 def lazy_sum(*args): 2 def sum(): 3 ax = 0 4 for n in args: 5 ax = ax + n 6 return ax 7 return sum 8 9 >>> f = lazy_sum(1, 3, 5, 7, 9) 10 >>> f 11 <function sum at 0x10452f668> 12 13 >>> f() 14 25
嵌套函数，返回嵌套函数名，最后调用时，用函数名().
闭包函数
返回闭包时牢记的一点就是：返回函数不要引用任何循环变量，或者后续会发生变化的变量。
1 def count(): 2 fs = [] 3 for i in range(1, 4): 4 def f(): 5 return i*i 6 fs.append(f) #没有立即执行 7 return fs #因为i为局部变量，执行到i=3时，由于没有取值，导致覆盖 8 9 f1, f2, f3 = count() 10 11 >>> f1() 12 9 13 >>> f2() 14 9 15 >>> f3() 16 9
如果一定要引用循环变量怎么办？方法是再创建一个函数，用该函数的参数绑定循环变量当前的值，无论该循环变量后续如何更改，已绑定到函数参数的值不变：
1 >>> def count(): 2 ... fs = [] 3 ... for i in range(1, 4): 4 ... def f(j): 5 ... def g(): 6 ... return j*j 7 ... return g 8 ... fs.append(f(i)) 9 ... return fs 10 ... 11 >>> f1, f2, f3 = count() 12 >>> f1() 13 1 14 >>> f2() 15 4 16 >>> f3() 17 9
三、匿名函数
当我们在传入函数时，有些时候，不需要显式地定义函数，直接传入匿名函数更方便。
1 >>> list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9])) 2 [1, 4, 9, 16, 25, 36, 49, 64, 81]
此外，匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数
同样，也可以把匿名函数作为返回值返回
四、装饰器
在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。
装饰器的两个必须满足的要求：
1、不改变被修饰函数的调用方式（test()）
2、不改变被修饰函数的源代码
1 import time
2 def log(func):
3 def wrapper(*args, **kw): #为了解决不同函数传入的参数不同
4 start_time = time.time()
5 return func(*args, **kw) #实际上是传给了func->now return,接受返回值，
6 stop_time = time.time() #下面的内容无法实现
7 print("执行了%.3fs"%(stop_time-start_time))
8 return wrapper
9
10 @log #now = log(now)
11 def now():
12 time.sleep(3)
13 print("程序执行完毕!")
14
15 now()