函数式编程，简单理解，就是可以把函数当做参数传递。
如下图，我们可以把abs函数当做参数传递。
这种函数叫做高阶函数：参数中有函数或者返回值为函数。
匿名函数：lambda关键字表示匿名函数。格式：lambda 函数参数：函数返回值，比如：
def fun(x, y):
return x + y
等价于：
lambda x, y: x + y
map函数：map(func, iterable)，第一个参数为函数，第二个参数为iterable对象。
用map将数值转换为字符串，如下：
print(list(map(str, [1, -2]))) --> ['1', '-2']
reduce函数：reduce(function, sequence[, initial])，第一个参数为函数（该函数必须有2个参数），第二个参数为序列，第三个为初始值，可省略。reduce将序列前2个元素代入函数，所得结果继续与第三个元素代入函数，以此类推。如果第三个参数不缺省，那么第三个参数将放置在序列的最前面，再依次执行。
下面map和reduce一起使用，将字符串转换成浮点数：
def sp(s, index):
return s.split('.')[index]
digits = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
s = '3.141'
d_list = map(lambda x: digits[x], sp(s, 0) + sp(s, 1))
print(reduce(lambda x, y: x * 10 + y, d_list) / 10 ** len(sp(s, 1)))
当然写法有很多种，也可以先通过'3.141'.find('.')获取小数点索引等等。
filter函数：filter(func, iterable)，func依次作用于iterable对象的元素，根据返回值是True或False来过滤元素，filter返回的结果是Iterator。下面，我们运用filter来过滤list的非整数：
print(list(filter(lambda x: isinstance(x, int), [1, 2, 'a']))) -->结果：[1, 2]
sorted函数：sorted(iterable, key=函数名, reverse=True)，后面两个参数不是必写参数，可省略。
print(sorted([2, 5, 3, 1])) --> 结果：[1, 2, 3, 5]
按照绝对值排序，需要abs函数：
print(sorted([2, -5, 3, 1], key=abs)) --> 结果：[1, 2, 3, -5]
如果iterable对象中是tuple数据，比如L = [('Bob', 75), ('Adam', 92), ('bart', 66), ('Lisa', 88)]，我们按照字母顺序排列（忽略大小写）：
print(sorted([('Bob', 75), ('Adam', 92), ('bart', 66), ('Lisa', 88)], key=lambda x: str.lower(x[0]))) --> 结果：[('Adam', 92), ('bart', 66), ('Bob', 75), ('Lisa', 88)]
如果我们按照年龄从大到小排列呢？这时候需要第三个参数了：
print(sorted([('Bob', 75), ('Adam', 92), ('bart', 66), ('Lisa', 88)], key=lambda x: x[1], reverse=True)) --> 结果：[('Adam', 92), ('Lisa', 88), ('Bob', 75), ('bart', 66)]
返回函数：当我们求和的时候，我们经常for循环累加直接返回最终结果。那如果我们想获取求和函数，即返回值是个函数，又该如何定义？如下，我们在函数内部再定义一个函数。
def cal_sum(*args):
def sum():
total = 0
for i in args:
total = total + i
return total
return sum
调用该函数时，每次返回的都是一个新函数，而且函数不会立即执行。
f1 = cal_sum(1, 2, 4)
f2 = cal_sum(1, 2, 4)
print(f1 == f2) --> 结果：False
print(f1()) --> 结果：7
闭包：一个函数返回了其内部定义的函数，同时该内部函数持有外部函数局部变量的引用。先看个例子，如下图：
结果都是6，却不是2，4，6。是因为返回函数引用了变量i，但是没有立即执行。循环结束时，所有的变量i都等于3了。
所以，返回闭包时，一定不要引用会发生变化的变量。
那如果我们既要引用循环变量，又要返回2，4，6呢？新定义一个函数，如下图：
运用闭包写一个计数器：
首先，内部函数可以直接引用外部函数局部变量，但是无法直接修改它的值。如果要修改的话，需要在内部函数中声明nonlocal 变量名，然后才能修改。另外，global关键字适用于修改全局变量。
但是，如果外部函数中局部变量是个list，我们可以修改其中的元素。所以定时器有两种写法：
装饰器：函数运行期间动态增加功能。比如在函数执行前，要输出日志等。
import functools
import time
# decorator本质上就是一个返回函数的高阶函数
# 定义一个装饰器，打印函数执行时间
def log(func):
# 把func的__name__等属性复制给wrapper，否则有些依赖函数签名的代码会出错
@functools.wraps(func)
# *args, **kwargs匹配任意参数
def wrapper(*args, **kwargs):
start = time.time()
func(*args, **kwargs)
end = time.time()
print('%s() use %s s' % (func.__name__, end - start))
return wrapper
# 格式：@ + 定义好的装饰器
@log
def test(x):
time.sleep(0.5)
print(x)
test(1) -->结果： test() use 0.5 s
# 执行test(1)时，实际上先执行log(test)，返回一个wrapper函数，再执行wrapper()
# 加上@functools.wraps(func)之后，wrapper函数的__name__ == func.__name__，否则wrapper.__name__ == 'wrapper'，可以用下面两行代码测试
f = log(test)
print(f.__name__) -->结果： test
如果我们想传递参数到装饰器里呢？外面再包一层函数，看下面代码：
# 设置默认值，就可以不传递参数
def log(text=None):
def decorator(func):
@functools.wraps(func)
# 把func的__name__等属性复制给wrapper
def wrapper(*args, **kwargs):
start = time.time()
func(*args, **kwargs)
end = time.time()
print('%s %s() use %s s' % (text, func.__name__, end - start))
return wrapper
return decorator
@log('execute')
def test(x):
time.sleep(0.5)
print(x)
test(2) --> 结果： execute test() use 0.5 s
偏函数：functools.partial(..., ...)
import functools
# 偏函数主要用于重构代码，使函数调用更简单
# 创建偏函数时，可以接收函数对象、*args、**kwargs三个参数
# int的偏函数，默认使用二进制转换字符串，但同时也能自定义进制数
int2 = functools.partial(int, base=2)
print(int2('11')) --> 结果： 3
print(int2('11', base=10)) --> 结果： 11
# max的偏函数，参数10会自动添加到*args左边
# args = (10, 1, 2, 4)
# max(*args)
max2 = functools.partial(max, 10)
print(max2(1, 2, 4)) --> 结果： 10