Python学习笔记（十）——匿名函数，函数的闭包和装饰器函数

匿名函数（lambda）

• 语法：lambda 变量名：表达式

lam = lambda x: x + 3
print(lam(2))  # 结果为5

lam1 = lambda x, y: x + y
print(lam1(2, 3))  # 结果为5

相应的普通函数为：

# 普通函数需要定义函数名
def add(x):
	x += 3
	return x

add(2)  # 结果为5
# 用函数名去调用相应的函数

• 匿名函数的优点：不定义函数名，避免函数重名时被覆盖；节省内存
• 匿名函数的缺点：不能被重复使用

匿名函数使用场景：结构简单，不常使用的函数

闭包

条件：

1. 外部函数中定义了内部函数（函数的嵌套）
2. 外部函数有返回值
3. 返回值是内部函数名（返回函数对象）
4. 内部函数引用了外部函数的变量（或传参）
5. 语法结构：

def 外部函数():
	......

	def 内部函数():
		......

	return 内部函数

def func():
	a = 100

	def inner_func():
		b = 99
		print(a, b)

	return inner_func    # 将内部函数作为返回值返回外部

x = func()
print(x)    # x就是内部函数
>>> <function func.<locals>.inner_func at 0x000001634BA49A60>
x()    # x() 就表示调用函数
>>> 100 99

闭包的作用：

1. 保存返回闭包时的状态，不会受到多次外部函数传值的影响
2. 读取其他元素的内部变量
3. 延长作用域

闭包总结

1. 闭包优化了变量，原来需要类对象完成的工作，闭包也可以完成
2. 由于闭包引用了外部函数的局部变量，则外部函数的局部变量没有及时释放，消耗内存
3. 闭包的好处是使代码变得简洁，便于阅读代码
4. 闭包是理解装饰器的基础

装饰器函数

• 我们可以直接通过修改函数中的代码来完成需求，但是会产生以下一些问题

1. 如果修改的函数多，修改起来会比较麻烦
2. 不方便后期的维护
3. 这样做会违反开闭原则(ocp)

• 程序的设计，要求开发对程序的扩展，要关闭对程序的修改

普通函数嵌套：

# 要执行的函数：
def func1(num):
    b = num
    print(f"中间函数b={b}")


# 作为装饰的函数：
def decorate(func, *args, **kwargs):
    a = 100
    print(f'外层函数a={a}')

    def wrapper():
        c = 300
        func(*args, **kwargs)
        print(f'内层函数c={c}')

    return wrapper


fun2 = decorate(func1, 6)   # 先调用外层函数，赋值后fun2 = wrapper
fun2()    # 调用内层函数并将函数func1和参数num传递进去

• 执行结果如下：
  

通过上面这个简单的例子可以看出几个特点：

1. 想要执行的函数要定义在作为装饰的函数的上方，因为装饰函数中需要调用要执行的函数
2. 需要先调用装饰函数的外层函数，并给返回的内层函数赋值，然后再调用内层函数
3. 执行时不是调用要执行的函数，而是通过调用装饰函数的方法来间接调用要执行的函数

装饰器的使用

1. 通过装饰器，可以在不修改原来函数的情况下来对函数进行扩展
2. 在开发中，我们都是通过装饰器来扩展函数的功能的
3. 装饰器函数需要满足闭包的条件

# 装饰器函数：
def decorate(func):  # 外层函数传递要装饰的函数为形参
    a = 100
    print(f'外层函数a={a}')

    def wrapper(*args, **kwargs):  # 内层函数传递要装饰的函数的参数为形参
        c = 300
        func(*args, **kwargs)
        print(f'内层函数c={c}')

    return wrapper


@decorate    # 用@+装饰函数名表示装饰器，放在需要装饰的函数上边
def func1(num):
    print(f"中间函数b={num}")


func1(6)    # 直接调用要执行的函数即可

• 执行结果同上

由此可见，利用装饰器函数来装饰执行函数的方法更加简洁和清晰

第十讲作业

请使用装饰器实现已存在的函数的执行所花费的时间。（time模块）

# 定义装饰器函数
def duration(fun):
    def time_difference(*args, **kwargs):
        print('开始运行程序......')
        start_time = time.time()    # 记录开始时间
        fun(*args, **kwargs)
        end_time = time.time()    # 记录结束时间
        print(f'程序结束，运行时间为：{end_time - start_time}秒')
        return fun(*args, **kwargs)
    return time_difference


@duration
def add(a, b):
    """
    计算从 a 到 b 一共有多少个回文数
    :param a: 起始值
    :param b: 终止值，应大于 a
    :return: 返回所有回文数的列表
    """
    list1 = []
    for i in range(a, b):
        if str(i)[::-1] == str(i):
            list1.append(i)
    return list1


result = add(100, 10000)
print(result)