闭包不是函数式编程的全部，是函数式编程思维的一种体现。
除了闭包，还有 lambda 表达式，map ,reduce, filter 等。
lambda 表达式
定义匿名函数
# 有名字的函数
def add(x, y):
return x + y
# 匿名函数
lambda x, y: x + y
调用匿名函数
# 调用有名字的函数
result1 = add(1, 2)
print(result1)
# 调用匿名函数
f = lambda x, y: x + y
result2 = f(1, 2)
print(result2)
结果
3
3
三元表达式
x = 1
y = 2
# 返回 x , 如果 x > y 的话，否则返回 y
result = x if x > y else y
print(result)
结果
2
map
# 用列表中每个元素的平方组成一个新的列表
list_x = [1, 2, 3]
# 定义一个函数，返回传入参数的平方
def square(x):
return x * x
# map 接收一个函数和一个可迭代对象
result = map(square, list_x)
# map 的返回结果是 map 对象
print(result)
# 将 map 对象转换成 list
print(list(result))
结果
<map object at 0x7fd898c30fa0>
[1, 4, 9]
map 与 lambda
map 结合 lambda 使用
# 用列表中每个元素的平方组成一个新的列表
list_x = [1, 2, 3]
# map 接收一个函数和一个可迭代对象
result = map(lambda x: x * x, list_x)
# map 的返回结果是 map 对象
print(result)
# 将 map 对象转换成 list
print(list(result))
结果
<map object at 0x7ff5e6830fa0>
[1, 4, 9]
map 可以接收多个可迭代对象
两个列表的元素相加：
list_x = [1, 2, 3]
list_y = [5, 4, 3]
result = map(lambda x, y: x + y, list_x, list_y)
print(list(result))
结果
[6, 6, 6]
两个长度不同的列表，元素相加
list_x = [1, 2, 3]
list_y = [5]
result = map(lambda x, y: x + y, list_x, list_y)
print(list(result))
结果
[6]
reduce
from functools import reduce
list_x = [1, 2, 3, 4, 5, 6]
r = reduce(lambda x, y: x + y, list_x)
print(r)
结果
21
计算过程
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10 + 5 = 15
15 + 6 = 21
filter
去掉列表中的 3
list_x = [2, 3, 3, 2, 3, 2]
result = filter(lambda x: True if x == 2 else False, list_x)
print(result)
print(list(result))
结果
<filter object at 0x7fe946d30fa0>
[2, 2, 2]
装饰器
编程的开闭原则：对修改是封闭的，对扩展是开放的
定义一个函数
def f1():
print('This is a function')
给函数添加打印当前时间的功能
import time
def f1():
print('This is a function')
print(time.time())
如果给很多函数都添加一个打印当前时间的功能，那么需要给每个函数都添加一行代码。这不符合开闭原则中的：对修改是封闭的。
应该通过扩展的方式来添加新的功能。这符合开闭原则中的：对扩展是开放的。
定义一个打印时间的函数，在这个函数中调用需要增加打印时间功能的函数
import time
# func 参数接收一个函数名
def decorator(func):
# 打印时间
def wrapper():
# 调用传进来的函数
func()
# 打印时间
print(time.time())
# 返回打印时间函数的函数名
return wrapper
def f1():
print('This is a function')
# 调用 decorator 函数，传入 f1 函数的函数名，得到打印时间函数的函数名
f = decorator(f1)
# 执行打印时间函数
f()
这个 decorator 函数，就是装饰器。这样可以实现给 f1 函数扩展功能，但是这样调用的方式有问题，现在调用 f1 函数的时候，没有像原来 f1() 这样调用。如果代码中其他地方调用了 f1 函数，还需要修改调用的代码。
所以需要这样：
...
@decorator
def f1():
print('This is a function')
f1()
这样保持了原来的调用方式。
通过装饰器，没有改变 f1 函数的内部实现，也没有改变 f1 函数的调用方式，给 f1 函数拓展了打印时间的功能。
上面的 f1 函数是没有参数的，如果 f1 需要一个参数，f2 函数需要两个参数
import time
# func 参数接收一个函数名
def decorator(func):
# 打印时间，接收可变参数
def wrapper(*args):
# 调用传进来的函数
func(*args)
# 打印时间
print(time.time())
# 返回打印时间函数的函数名
return wrapper
@decorator
def f1(func_name):
print('This is a function' + func_name)
@decorator
def f2(func_name1, func_name2):
print('This is a function' + func_name1)
print('This is a function' + func_name2)
# 调用时传入参数
f1('test func')
f2('test func1', 'test func2')
如果 f3 函数需要三个参数
import time
# func 参数接收一个函数名
def decorator(func):
# 打印时间，接收可变参数和关键字参数
def wrapper(*args, **kw):
# 调用传进来的函数
func(*args, **kw)
# 打印时间
print(time.time())
# 返回打印时间函数的函数名
return wrapper
@decorator
def f1(func_name):
print('This is a function' + func_name)
@decorator
def f2(func_name1, func_name2):
print('This is a function' + func_name1)
print('This is a function' + func_name2)
@decorator
def f3(func_name1, func_name2, **kw):
print('This is a function' + func_name1)
print('This is a function' + func_name2)
print(kw)
f1('test func')
f2('test func1', 'test func2')
f3('test func1', 'test func2', a=1, b=2, c='123')
