函数式编程的只要特点是：允许把函数作为参数传入另一个函数，同时还允许返回一个函数。
python对函数式编程提供支持，这里做个简单的整理。
一、高阶函数：允许把函数作为参数传入
（1）map() 函数
② map() 函数的主要功能：将传入的函数依此作用到每个元素上，并将结果以 Iterator 返回。
比如下面这个例子：
利用map()函数，把用户输入的不规范的英文名字，变为首字母大写，其他小写的规范名字。输入：['adam', 'LISA', 'barT']，输出：['Adam', 'Lisa', 'Bart']
def normalize(name):
return name.capitalize()
L1 = ['adam', 'LISA', 'barT']
L2 = list(map(normalize, L1))
print(L2)（2）reduce() 函数
请编写一个prod()函数，可以接受一个list并利用reduce()求积
from functools import reduce
def prod(L):
def mul(x, y):
return x*y
return reduce(mul, L)
print('3 * 5 * 7 * 9 =', prod([3, 5, 7, 9]))
if prod([3, 5, 7, 9]) == 945:
print('测试成功!')
else:
print('测试失败!')通过map() 和 reduce() 函数的结合也可以实现很多功能，比如：
利用map和reduce编写一个str2float函数，把字符串'123.456'转换成浮点数123.456
from functools import reduce
def str2float(s):
flag = 0
def char2num(s):
digits = {'.': -1, '0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5':5 , '6': 6, '7':7, '8':8, '9':9}
if s in digits:
return digits[s]
def f1(a, b):
nonlocal flag
if b == -1:
flag = 1
return a
if flag == 0:
return a * 10 + b
else:
flag = flag * 10
return a + b / flag
return reduce(f1, map(char2num, s))
print('str2float(\'123.456\') =', str2float('123.456'))
if abs(str2float('123.456') - 123.456) < 0.00001:
print('测试成功!')
else:
print('测试失败!')（3）filter() 函数
12321
，
909
。请利用
filter()
筛选出回数
def is_palindrome(n): #先转为字符串，再利用切片取反
st = str(n)
return st == st[::-1]
output = filter(is_palindrome, range(1, 1000))
print('1~1000:', list(output))
if list(filter(is_palindrome, range(1, 200))) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44, 55, 66, 77, 88, 99, 101, 111, 121, 131, 141, 151, 161, 171, 181, 191]:
print('测试成功!')
else:
print('测试失败!')（4） sorted() 函数
比如：
students = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]
print(sorted(students, key = itemgetter(0)))就可以实现按名字排序。
（5）返回函数
前面提到过函数式编程可以将返回一个函数，需要注意的是每次调用时每次都会返回一个新的函数，即使传入的参数都是相同的。
>>> f1 = lazy_sum(1, 3, 5, 7, 9)
>>> f2 = lazy_sum(1, 3, 5, 7, 9)
>>> f1==f2
False这里有一个概念叫闭包（closure），它是一种程序结构，会将相关参数和变量都保存在返回的函数中，因此可以说返回的不只是一个函数，而是一个闭包，需要注意的是，返回函数中不要引用任何的循环变量，或者是后续会发生变化的变量，如果一定要引用，就再建一个函数，将循环变量绑定到函数上。
利用闭包返回一个计数器函数，每次调用它返回递增整数：
def createCounter():
i = 0
def counter():
nonlocal i
i = i + 1
return i
return counter
counterA = createCounter()
print(counterA(), counterA(), counterA(), counterA(), counterA()) # 1 2 3 4 5
counterB = createCounter()
if [counterB(), counterB(), counterB(), counterB()] == [1, 2, 3, 4]:
print('测试通过!')
else:
print('测试失败!')
（6） 匿名函数 lambda
匿名函数可以说是一个很有用的工具。
lambda x : x * x 实际上就是
def f(x):
return x * x (7) 装饰器 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还有很多时候是需要带参数的，那么一般写法是：
import functools
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再比如我们想要设计一个能够打印函数执行时间的 decorator
import functools, time
def metric(fn):
@functools.wraps(fn)
def wrapper(*args, **kw):
f = time.time()
fn(*args, **kw)
e = time.time()
print('%s executed in %s ms' %(fn.__name__, 1000*(e - f)))
return fn(*args, **kw)
return wrapper
@metric
def fast(x, y):
time.sleep(0.0012)
return x + y;
@metric
def slow(x, y, z):
time.sleep(0.1234)
return x * y * z;
f = fast(11, 22)
s = slow(11, 22, 33)
if f != 33:
print('测试失败!')
elif s != 7986:
print('测试失败!')（7） 偏函数
①偏函数实际就是能够设定参数的默认值，并且不需要再自己另外定义。
②偏函数可以接受三个参数：函数对象、 *args 、**kw
偏函数会根据用户的输入自动匹配到 args 和 kw 上，比如
int2 = functools.partial(int, base=2)那么当我 int2('10010') 时，就是将 base = 2 识别为 kw = { 'base' : 2 }，即为 int("10010', **kw)。