函数式编程
函数式编程的一个特点就是，允许把函数本身作为参数传入另一个函数，还允许返回一个函数！ Python对函数式编程提供部分支持。由于Python允许使用变量，因此，Python不是纯函数式编程语言
高阶函数（Higher-order function）
特点：
- 变量可以指向函数 即 函数本身也可以赋值给变量
x=abs x(-10) #10
- 函数名也是变量
abs = 10 abs(-10) # TypeError: 'int' object is not callable
注：由于abs函数实际上是定义在import builtins模块中的，所以要让修改abs变量的指向在其它模块也生效，要用import builtins; builtins.abs = 10
- 传入函数
既然变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数
def add(x, y, f): return f(x) + f(y) print(add(-5, 6, abs)) # 11 复制代码
map/reduce，filter,sorted
map/reduce的概念： Google论文“MapReduce: Simplified Data Processing on Large Clusters”
这四个用法同es6.
- map()函数接收两个参数，一个是函数，一个是Iterable 返回一个Iterator
def f(x): return x**2 a=map(f,[x for x in range(10)]) print(next(a)) # 0 print(list(a)) # [1, 4, 9, 16, 25, 36, 49, 64, 81] 复制代码
- 把这个list所有数字转为字符串：
print(list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))) # ['1', '2', '3', '4', '5', '6', '7', '8', '9'] 复制代码
- reduce() 把结果继续和序列的下一个元素做累积计算:
reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)序列[1, 3, 5, 7, 9]变换成整数13579：
from functools import reduce def fn(x,y): return x*10+y print(reduce(fn,[1,3,5,7,9])) #13579 复制代码
- str转换为int：
from functools import reduce DIGITS = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9} def char2num(s): return DIGITS[s] def str2int(s): return reduce(lambda x, y: x * 10 + y, map(char2num, s)) print(str2int('0123456789')) # 123456789 复制代码
- filter() 接收一个函数和一个序列 ，返回的是一个Iterator 过滤出符合条件的数
def is_odd(n): return n % 2 == 1 list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15])) 复制代码
- sorted() 接收一个序列和一个函数
sorted([36, 5, -12, 9, -21])按绝对值大小排序：
sorted([36, 5, -12, 9, -21], key=abs) # [5, 9, -12, -21, 36] 复制代码
- 要进行反向排序，不必改动key函数，可以传入第三个参数reverse=True：
L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)] def by_name(t): return t[0] L2 = sorted(L, key=by_name,reverse=True) print(L2) 复制代码
返回函数
函数作为返回值
高阶函数除了可以接受函数作为参数外，还可以把函数作为结果值返回。
可变参数的求和(立刻返回计算结果):
def calc_sum(*args): ax = 0 for n in args: ax = ax + n return ax 复制代码
返回求和的函数：
def lazy_sum(*args): def sum(): ax = 0 for n in args: ax = ax + n return ax return sum f = lazy_sum(1, 3, 5, 7, 9) f() #25 复制代码
闭包（注意！）
返回闭包时牢记一点：返回函数不要引用任何 循环变量，或者后续 会发生变化的变量。
def count(): fs = [] for i in range(1, 4): def f(): return i*i fs.append(f) return fs f1, f2, f3 = count() # f1() 9 # f2() 9 # f3() 9 # 全部都是9！原因就在于返回的函数引用了变量i，但它并非立刻执行。等到3个函数都返回时，它们所引用的变量i已经变成了3，因此最终结果为9。 复制代码
def count(): def f(j): def g(): return j*j return g fs = [] for i in range(1, 4): fs.append(f(i)) # f(i)立刻被执行，因此i的当前值被传入f() return fs for fn in count(): print(fn()) # 1 4 9 复制代码
匿名函数
关键字lambda表示匿名函数，冒号前面的x表示函数参数。 匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果
list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
lambda x: x * x #等于 def f(x): return x * x 复制代码
用匿名函数有个好处，因为函数没有名字，不必担心函数名冲突。此外，匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数：
# 把匿名函数赋值给一个变量，再利用变量来调用该函数 f = lambda x: x * x f(5) #25 # 匿名函数作为返回值返回 def build(x, y): return lambda: x * x + y * y 复制代码
装饰器
在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator） 本质上，decorator就是一个返回函数的高阶函数
看看下面的代码，瞬间明白这个不就是Spring 的 aop思想吗，感觉像java的注解
@log def now(a,b,*,age): print('2015-3-25') def log(func): def wrapper(*args, **kw): print('call %s():' % func.__name__) # __name__获取函数对象的名字 print( args) print( kw) return func(*args, **kw) return wrapper now('1','1',age=12) # call now(): # ('1', '1') # {'age': 12} # 2015-3-25 复制代码
把@log放到now()函数的定义处，相当于执行了语句：
now = log(now)wrapper()函数的参数定义是(*args, **kw)，因此，wrapper()函数可以接受任意参数的调用。在wrapper()函数内，首先打印日志，再紧接着调用原始函数。
def log(text): def decorator(func): def wrapper(*args, **kw): print('%s %s():' % (text, func.__name__)) return func(*args, **kw) return wrapper return decorator @log('execute') def now(): print('2015-3-25') now() # execute now(): # 2015-3-25 复制代码
剖析： now = log('execute')(now) 首先执行log('execute')，返回的是decorator函数，再调用返回的函数，参数是now函数，返回值最终是wrapper函数。函数也是对象，它有__name__等属性 所以最后会出现
now.__name__ #'wrapper'的情况 这样子会导致有些依赖函数签名的代码执行错误
但是Python内置的functools.wraps 就是用来 把原始函数的__name__等属性复制到对应的函数中 如：
@functools.wraps(func) def wrapper(*args, **kw): 复制代码
修改后运行now.__name__ 。结果为 #now
偏函数
偏函数是参数固定的函数，即有默认值的函数
Python的
functools模块提供了很多有用的功能，其中一个就是偏函数（Partial function）,
functools.partial就是帮助我们创建一个偏函数的， 它可以帮我们固定函数的参数，返回一个新的函数 可以接收函数对象、*args和**kw这3个参数
如 int 函数
import functools int2 = functools.partial(int, base=2) int2('1000000') # 64 复制代码
如 max函数
import functools # 实际上会把10作为*args的一部分自动加到左边 √ （廖老师的课程真给力 ☆(￣▽￣)/$:*） max2 = functools.partial(max, 10) max2(5, 6, 7) # 10
