函数式编程虽然也可以归结到面向过程的程序设计，但其思想更接近数学计算
函数式编程的一个特点就是，允许把函数本身作为参数传入另一个函数，还允许返回一个函数
高阶函数 Higher-order function
一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数
一个最简单的高阶函数：
def add(x, y, f):
return f(x) + f(y)
add(-5, 6, abs)
map/reduce
Python内建了 map() 和 reduce() 函数
-
map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回
def f(x):
return x * x
r = map(f, list(range(0,10)))
# 结果r是一个Iterator，Iterator是惰性序列，因此通过list()函数让它把整个序列都计算出来并返回一个list
list(r)
for n in r:
print(n)
# 把这个list所有数字转为字符串
# 函数 str() 依次作用到序列的每个元素
list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9])) ==> ['1', '2', '3', '4', '5', '6', '7', '8', '9']
-
reduce()把一个函数作用在一个序列[x1, x2, x3, ...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算，效果如下：
reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
from functools import reduce
def g(x, y):
return x + y
reduce(g, list(range(0,10))) ==> 45
# 把list 转换为整数
from functools import reduce
def fn(x, y):
return x * 10 + y
reduce(fn, [1, 3, 5, 7, 9])
# 把str转换为int
from functools import reduce
def fn(x, y):
return x * 10 + y
def char2num(s):
return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]
reduce(fn, map(char2num, '13579'))
# 整理成一个str2int的函数就是：
from functools import reduce
def str2int(s):
def fn(x, y):
return x * 10 + y
def char2num(s):
return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]
return reduce(fn, map(char2num, s))
# 用lambda函数进一步简化成：
from functools import reduce
def char2num(s):
return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]
def str2int(s):
return reduce(lambda x, y: x * 10 + y, map(char2num, s))
def normalize(name):
a = ''
for i, value in enumerate(name):
if i == 0:
a += value.upper()
else:
a += value.lower()
return a
L1 = ['adam', 'LISA', 'barT']
L2 = list(map(normalize, L1))
print(L2)
from functools import reduce
def prod(L):
def fn(x, y):
return x * y
return reduce(fn, L)
print('3 * 5 * 7 * 9 =', prod([3, 5, 7, 9]))
def str2float(s):
def fn(x, y):
return x * 10 + y
def fx(x, y):
return x / 10 + y
def char2num(s):
return {'0':0, '1':1, '2':2, '3':3, '4':4, '5':5, '6':6, '7':7, '8':8, '9':9}[s]
L = s.split('.', 1)
print(L)
return reduce(fn, map(char2num, L[0])) + reduce(fx, map(char2num, L[1][-1::-1]))/10
print('str2float(\'123.456\')=', str2float('123.456'))
filter
filter()函数用于过滤序列
filter()也接收一个函数和一个序列，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素
def is_odd(n):
return n % 2 == 1
list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15])) ==> [1, 5, 9, 15]
def not_empty(s):
return s and s.strip()
list(filter(not_empty, ['A', '', 'B', None, 'C', ' '])) ==> ['A', 'B', 'C']
# 求素数
def _odd_iter():
n = 1
while True:
n = n + 2
yield n
def _not_divisible(n):
return lambda x: x % n > 0
def primes():
yield 2
it = _odd_iter() # 初始序列
while True:
n = next(it) # 返回序列的第一个数
yield n
# 这里相当于 it = filter(lambda x: x % n > 0, it)
it = filter(_not_divisible(n), it) # 构造新序列
for n in primes():
if n < 1000:
print(n)
else:
break
sorted
sorted([36, 5, -12, 9, -21]) ==> [-21, -12, 5, 9, 36]
sorted() 函数也是一个高阶函数，它还可以接收一个key函数来实现自定义的排序。key指定的函数将作用于list的每一个元素上，并根据key函数返回的结果进行排序
sorted([36, 5, -12, 9, -21], key=abs) => [5, 9, -12, -21, 36]
对字符串排序，是按照ASCII的大小比较的
# 忽略大小写来比较两个字符串
sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower) ==> ['about', 'bob', 'Credit', 'Zoo']
反向排序
sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True) ==> ['Zoo', 'Credit', 'bob', 'about']
L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]
def by_name(t):
return t[0].lower()
def by_score(t):
return t[1]
L1 = sorted(L, key=by_name)
print(L1)
L2 = sorted(L, key=by_score)
print(L2)
返回函数
高阶函数除了可以接受函数作为参数外，还可以把函数作为结果值返回
def lazy_sum(*args):
# 内部函数sum可以引用外部函数lazy_sum的参数和局部变量
def sum():
ax = 0
for n in args:
ax = ax + n
return ax
# 当lazy_sum返回函数sum时，相关参数和变量都保存在返回的函数中，这种称为“闭包（Closure）”
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
返回闭包时牢记的一点就是：返回函数不要引用任何循环变量，或者后续会发生变化的变量。
如果一定要引用循环变量怎么办？方法是再创建一个函数，用该函数的参数绑定循环变量当前的值
def count():
def f(j):
def g():
return j*j
return g
fs = []
for i in range(1, 4):
# f(i)立刻被执行，因此i的当前值被传入f()
fs.append(f(i))
return fs
匿名函数
匿名函数类似如下：
lambda x: x * x
关键字lambda表示匿名函数，冒号前面的x表示函数参数
匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果
装饰器 Decorator
假设我们要增强函数的功能，但又不希望修改函数的定义，这种在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）
本质上，decorator 就是一个返回函数的高阶函数
# 接受一个函数作为参数，并返回一个函数
def log(func):
# wrapper()函数的参数定义是(*args, **kw)，因此，wrapper()函数可以接受任意参数的调用
def wrapper(*args, **kw):
print('call %s():' % func.__name__)
return func(*args, **kw)
return wrapper
借助Python的@语法，把decorator置于函数的定义处：
# 把@log放到now()函数的定义处，相当于执行了语句：now = log(now)
@log
def now():
print('2015-3-25')
now()
如果decorator本身需要传入参数，那就需要编写一个返回decorator的高阶函数
def log(text):
def decorator(func):
def wrapper(*args, **kw):
print('%s %s():' % (text, func.__name__))
return func(*args, **kw)
return wrapper
return decorator
这个3层嵌套的decorator用法如下：
# 和两层嵌套的decorator相比，3层嵌套的效果是这样的：now = log('execute')(now)
# 区别：log 是函数名，log('execute') 是函数执行后的返回结果
@log('execute')
def now():
print('2015-3-25')
now()
按以上两种 decorator 装饰之后的函数，它们的 __name__ 已经从原来的'now'变成了'wrapper'：
now.__name__ ==> 'wrapper'
Python内置的 functools.wraps 原始函数的 __name__ 等属性复制到 decorator 替换的函数中，则前面两个 decorator 的完整写法为：
import functools
def log(func):
@functools.wraps(func)
def wrapper(*args, **kw):
print('call %s():' % func.__name__)
return func(*args, **kw)
return wrapper
def log(text):
def decorator(func):
@functools.wraps(func)
def wrapper(*args, **kw):
print('%s %s():' % (text, func.__name__))
return func(*args, **kw)
return wrapper
return decorator
import functools
# 支持带和不带参数的 decorator
def log(text):
def decorator(func):
@functools.wraps(func)
def wrapper(*arg,**kw):
# 能在函数调用的前后打印出的日志
try:
print('begin call')
if isinstance(text, str):
print('param :', text)
return func(*arg,**kw)
finally:
print('end call')
return wrapper
if hasattr(text,'__call__'):
return decorator(text)
else:
return decorator
@log
def f():
print('execute f()')
@log('with param')
def g():
print('execute g()')
f()
g()
偏函数 Partial function
Python 的 functools 模块提供了很多有用的功能，其中一个就是偏函数
Python 的偏函数和数学意义上的偏函数不一样
functools.partial 的作用就是，把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数
import functools
int2 = functools.partial(int, base=2)
int2('1000000') ==> 64
# 这里仅仅是把base参数重新设定默认值为2，但也可以在函数调用时传入其他值
int2('1000000', base=10) ==> 1000000
# 创建偏函数时，实际上可以接收函数对象、*args和**kw这3个参数
int2 = functools.partial(int, base=2)
# 相当于
kw = { 'base': 2 }
int('10010', **kw)
# 因此，当传入
max2 = functools.partial(max, 10)
# 实际上会把10作为*args的一部分自动加到左边，也就是
max2(5, 6, 7)
# 相当于
args = (10, 5, 6, 7)
max(*args) ==> 10