函数式编程是一种抽象程度很高的编程范式，它将一个问题分解成一系列函数。函数式编程语言编写的函数是没有变量的，在理想情况下，函数只接受输入并输出结果，即只要输入是确定的，输出结果就是确定的，在这种情况下就不会产生副作用，此时可以称之为纯函数。而允许使用变量的程序设计语言，由于函数内部变量状态的不确定性，造成同样的输入，可能得到不同的输出结果，因此，这种函数是有副作用的。
Python对函数式编程提供部分支持，但由于Python中的函数允许使用变量，因此，Python不是纯函数式编程语言。
函数式编程有一个很重要的特点，就是允许把函数本身作为参数传入另一个函数，以及其允许返回一个函数。
9.8.1 高阶函数
1.map()函数
该函数会根据提供的函数对指定的序列（关于序列的概念，请参考函数的高级特性）做映射，即将传入的函数依次作用到序列中的每个元素，并把结果作为新的迭代器（关于迭代器的概念，请参考函数的高级特性）返回。其语法格式如下：
map(function, iterable)其中，参数function表示函数；参数iterable表示可迭代对象（关于可迭代对象的概念，请参考函数的高级特性）。示例代码如下：
# 资源包\Code\chapter9\9.9\0932.py
def square(x):
return x ** 2
# 计算指定列表中的每个元素的平方
lt = map(square, [1, 2, 3, 4, 5])
print(lt)
# 使用list()函数将可迭代对象转换为列表
print(list(lt))2.reduce()函数
该函数会对指定序列中的元素进行累积，即该函数会将一个序列中的所有元素进行如下操作：用传给reduce()函数中的函数（需有2个参数）先对序列中的第1、2个元素进行操作，得到的结果再与第3个元素运算，以此类推，最后得到一个结果。
此外，在Python 3.x的版本中，reduce()函数已经被移到functools模块中，即需要通过引入functools模块来调用reduce()函数。其语法格式如下：
from functools import reduce
reduce(function, iterable[, initializer])其中，参数function 表示函数，该函数需要有2个参数；参数iterable表示可迭代对象；参数initializer为可选参数，表示初始值。
# 资源包\Code\chapter9\9.9\0933.py
from functools import reduce
def myfunc(x, y):
return x + y
# 求列表中元素的累加值
print(reduce(myfunc, [1, 2, 3, 4, 5]))
# 求列表中元素的累加值，给定初始值累加值为3
print(reduce(myfunc, [1, 2, 3, 4, 5], 3))3.filter()函数
该函数用于过滤序列，即将序列中不符合条件的元素过滤掉，并把符合条件的元素作为新的迭代器返回。其语法格式如下：
filter(function, iterable)其中，参数function表示函数；参数iterable表示可迭代对象。示例代码如下：
# 资源包\Code\chapter9\9.9\0934.py
def myFunc(num):
return num % 2 == 0
lt = [1, 2, 3, 4, 5, 6, 7, 8, 9]
# 将列表中的偶数保留
new_lt = filter(myFunc, lt)
print(new_lt)
# 使用list()函数将可迭代对象转换为列表
print(list(new_lt))9.8.2函数闭包
在Python中，闭包（Closure）是一个非常重要的编程概念，尤其是在函数式编程中。而函数闭包是一种特殊的函数架构，其通过函数嵌套和函数返回值实现，即内层函数引用了外层函数的变量，并且外层函数返回内层函数名。
函数闭包必须满足3个条件，一是内层函数的创建嵌套在外层函数中；二是内层函数引用外层函数的变量；三是外层函数返回内层函数名。
首先，我们来看一段示例代码：
# 资源包\Code\chapter9\9.9\0935.py
def func():
num = 100
# 报错，因为函数外部无法访问函数内部的变量num
print(num)上述代码中，函数func()的外部是无法获取到其内部的变量num的值。
此时，可以通过使用函数闭包，在函数外部获取到其内部的变量，即在函数func()内部创建一个内部函数，然后在内部函数中引用外部函数的变量，最后在外部函数中将内部函数名返回即可，示例代码如下：
# 资源包\Code\chapter9\9.9\0936.py
def func():
num = 100
def func1():
print(num)
return func1
res = func()
res()9.8.3 回调函数
回调函数是一种非常重要的概念和设计模式。其允许将一个函数作为参数传递给另一个函数，并在特定事件发生时由后者调用前者。这种机制极大地提高了代码的灵活性与可扩展性，尤其适用于异步编程、事件驱动编程以及GUI开发等场景。
示例代码如下：
# 资源包\Code\chapter9\9.8\0937.py
def myFunc(name, teach, other_teacher):
return other_teacher(name, teach)
def otherMyFunc(other_name, other_teach):
print(other_name, other_teach)
# 注意，一定是传递函数名，不带小括号
myFunc('Python全栈开发-基础入门', 'Data Analysis', otherMyFunc)9.8.4 lambda表达式
lambda 表达式，又称匿名函数，常用来表示内部仅包含1行表达式的函数，即如果一个函数的函数体仅有1行表达式，则该函数就可以用lambda表达式来代替。
定义lambda表达式，必须使用lambda关键字，其语法格式如下：
func = lambda [list]: expression其中，func表示函数名；list为可选项，表示函数的参数；expression为函数体内表达式。示例代码如下：
# 资源包\Code\chapter9\9.9\0938.py
# lambda表达式
mul = lambda x, y: x + y
print(mul(3, 4))
# 普通函数，等价于lambda表达式
def add(x, y):
return x + y
print(add(3, 4))lambda表达式有2点优势，一是相对于单行的函数，使用lambda表达式可以省去定义函数的过程，让代码更加简洁；二是对于不需要多次复用的函数，使用lambda表达式可以在使用完毕之后立即释放，从而提高程序的执行性能。但是，由于lambda表达式仅仅是一个表达式，而不是一个代码块，所以lambda表达式只能表达一些简单的逻辑。
9.8.5 偏函数
当函数的参数个数过多，需要简化时，就可以通过创建一个新函数来固定原函数的部分参数，从而使调用原函数时更加简便，这个新函数就是偏函数。
偏函数通过使用functools模块中的partial类进行创建。其语法格式如下：
import functools
new_function = functools.partial(function, parameter)其中，参数function表示原函数；参数parameter表示待固定的参数；参数new_function表示偏函数。
假设需要将二进制字符串转换为十进制整数，这时可以使用内置函数int()。示例代码如下：
# 资源包\Code\chapter9\9.9\0939.py
num = int('10', 2)
print(num)但是如果需要大批量进行转换，int()函数每次都需要传入两个参数就会显得非常麻烦，那么此时就可以自定义函数来完成该需求。示例代码如下：
# 资源包\Code\chapter9\9.9\0940.py
def int_2(num, base=2):
return int(num, base)
print(int_2('10'))
print(int_2('110'))上面的代码的基本思路就是使用默认参数来固定int()函数中参数base的值，而这正是偏函数的特性，所以可以通过使用偏函数来固定参数base的值。示例代码如下：
# 资源包\Code\chapter9\9.9\0941.py
from functools import partial
int2 = partial(int, base=2)
print(int2('10'))
print(int2('110'))9.8.6 函数装饰器
函数装饰器指的是修改其它函数功能的函数。其本质就是一个函数，只不过函数装饰器允许把其它函数作为其本身的参数传入，并经过处理之后返回一个新函数。
首先来了解一下函数装饰器的工作原理。
假设使用函数装饰器my_decorator()装饰函数funcA ()。示例代码如下：
# 资源包\Code\chapter9\9.9\0944.py
def my_decorator(func):
def wrapper():
print('扩充功能')
return func()
return wrapper
@my_decorator
def funcA():
return ('funcA自身功能')
print(funcA())上面的程序完全等价于下面的程序。示例代码如下：
# 资源包\Code\chapter9\9.9\0945.py
def my_decorator(func):
def wrapper():
print('扩充功能')
return func()
return wrapper
def funcA():
return ('funcA自身功能')
funcA = my_decorator(funcA)
print(funcA())通过比对以上2段程序不难发现，使用函数my_decorator()装饰另一个函数funcA()，其相当于将函数funcA()传递给函数my_decorator()，最后函数my_decorator()返回一个新的函数，即wrapper()函数。
综上所述，所谓函数装饰器，就是在不修改原函数的前提下，通过使用函数装饰器对原函数的功能进行合理的扩充。
上面的示例代码中，函数funcA()不带任何参数，那么，如何给带有参数的函数funcA()传值呢？其实解决方法比较简单，就是在函数装饰器中再嵌套一个函数，且该嵌套函数的参数个数与被装饰器装饰的函数相同即可。示例代码如下：
# 资源包\Code\chapter9\9.9\0946.py
def my_decorator(func):
def wrapper(parameter):
print('扩充功能')
return func(parameter)
return wrapper
@my_decorator
def funcA(parameter):
return (f'funcA自身功能，参数：{parameter}')
print(funcA('Python'))上面的程序完全等价于下面的程序。示例代码如下：
# 资源包\Code\chapter9\9.9\0947.py
def my_decorator(func):
def wrapper(parameter):
print('扩充功能')
return func(parameter)
return wrapper
def funcA(parameter):
return (f'funcA自身功能，参数：{parameter}')
funcA = my_decorator(funcA)
print(funcA('Python'))上面的示例代码中，同一个函数装饰器只装饰了一个函数，那么，当有多个函数被同一个函数装饰器装饰时，且这些函数的参数个数不相等的时候该如何处理呢？此时，使用可变参数作为函数装饰器内部嵌套函数的参数即可。示例代码如下：
# 资源包\Code\chapter9\9.9\0948.py
def my_decorator(func):
def wrapper(*args, **kwargs):
print('扩充功能')
return func(*args, **kwargs)
return wrapper
@my_decorator
def funcA(parameter1):
return (f'funcA自身功能，参数：{parameter1}')
@my_decorator
def funcB(parameter2, parameter3):
return (f'funcB自身功能：参数1：{parameter2}，参数2：{parameter3}')
print(funcA('Python'))
print('=============')
print(funcB('Java', 'C'))上面的程序完全等价于下面的程序。示例代码如下：
# 资源包\Code\chapter9\9.9\0949.py
def my_decorator(func):
def wrapper(*args, **kwargs):
print('扩充功能')
return func(*args, **kwargs)
return wrapper
def funcA(parameter1):
return (f'funcA自身功能，参数：{parameter1}')
def funcB(parameter2, parameter3):
return (f'funcB自身功能：参数1：{parameter2}，参数2：{parameter3}')
funcA = my_decorator(funcA)
print(funcA('Python'))
print('=============')
funcB = my_decorator(funcB)
print(funcB('Java', 'C'))上面的示例代码中，都是一个函数装饰器装饰一个函数，实际上，在Python中是支持多个函数装饰器装饰一个函数，即函数装饰器嵌套。示例代码如下：
# 资源包\Code\chapter9\9.9\0950.py
def my_decoratorA(func):
def wrapper(*args, **kwargs):
print('扩充功能A')
return func(*args, **kwargs)
return wrapper
def my_decoratorB(func):
def wrapper(*args, **kwargs):
print('扩充功能B')
return func(*args, **kwargs)
return wrapper
@my_decoratorA
@my_decoratorB
def funcA():
return ('funcA自身功能')
print(funcA())上面的程序完全等价于下面的程序。示例代码如下：
# 资源包\Code\chapter9\9.9\0951.py
def my_decoratorA(func):
def wrapper(*args, **kwargs):
print('扩充功能A')
return func(*args, **kwargs)
return wrapper
def my_decoratorB(func):
def wrapper(*args, **kwargs):
print('扩充功能B')
return func(*args, **kwargs)
return wrapper
def funcA():
return ('funcA自身功能')
funcA = my_decoratorA(my_decoratorB(funcA))
print(funcA())