python——闭包与装饰器

闭包

再学习闭包之前，我们要回顾一下两个概念

• 作用域：开始时（调用时），变量建立，结束时销毁。
• 高级函数：函数可以作为参数，函数也可以作为返回值。

闭包就是打破了以上概念的现象，也就是某个函数，在作用域结束的时候，仍然存在，不会被程序回收内存空间。

定义：如果在一个嵌套内部函数里面，对在外作用域（但是不是全局作用域）的变量进行引用，那么内部函数就被认为是闭包。

理解：闭包 = 嵌套函数的内部函数 + 此内部函数调用了外层函数的变量 ，满足这两个条件的现象称为闭包。

def f():
    x = 5
    def g():  # 内部函数g
        print(x)  # 调用了外部函数 f的变量 x
    return g

h = f()  # 此时 h = g
h()  # 5  #等同于g()

# 调用外部函数的传入的参数也是闭包
def f(x):
    def g():  # 内部函数g
        print(x)  # 调用了外部函数 f的变量 x
    return g

h = f(1)  # 此时 h = g
h()  # 5  # 等同于g()


# 验证一下，f的命名空间中有，g函数和x变量，所以内部函数g调用变量x也符合条件
def f(x):
    def g():
        print(x,end=',')
    print('f的命名空间:',locals().keys())  # f的命名空间: dict_keys(['g', 'x'])
    return g

h = f(1)
h()

装饰器

作用：在不修改源代码的基础上，实现给函数增加新功能。

实质上装饰器也是一个闭包函数，也就是说，它也是一个函数嵌套

举个例子：

假设收到需求，为某一个函数增加计时功能：

# 为add()函数增加函数计时功能
import time  # 导入时间模块


# 停顿 1秒 函数
def add():
    time.sleep(1)  # 等待 1秒
    print('停顿1秒')


# 增加一个计时功能
def show_time():  # 把函数当做参数传入
    start = time.time()
    add()
    end = time.time()
    print(f'运行了{end - start}秒')


show_time()

==========
停顿1秒
运行了:1.0099527835845947秒

此时，又收到的新需求，为所有函数增加计时功能

# 多个函数都能使用计时功能
import time


# 停顿 1秒 函数
def add():
    time.sleep(1)  # 等待 1秒
    print('停顿1秒')


# 停顿 2秒 函数
def sub():
    time.sleep(2)
    print('停顿2秒')


# 增加一个计时功能
def show_time(func):  # 把函数当做参数传入
    start = time.time()
    func()
    end = time.time()
    print(f'运行了{end - start}秒')


show_time(add)
show_time(sub)

=========
停顿1秒
运行了1.0007169246673584秒
停顿2秒
运行了2.000011444091797秒

但是，由于同事不知道定义了show_time函数，需要一个个去修改代码很困难

# 问题:因为使用计时函数,别的同事需要特地增加调用show_time
# 原本的代码也都要进行修改,所以需要再改进
import time


# 停顿 1秒 函数
def add():
    time.sleep(1)  # 等待 1秒
    print('停顿1秒')


# 停顿 2秒 函数
def sub():
    time.sleep(2)
    print('停顿2秒')


# 增加一个计时功能
def show_time(func):  # 把函数当做参数传入
    def inner():
        start = time.time()
        func()
        end = time.time()
        print(f'运行了:{end - start}秒')
    return inner

add = show_time(add)  # 定义同名变量add来接受show_time的返回值
sub = show_time(sub)  # 定义同名变量sub来接受show_time的返回值

add()  # add() --> inner()
sub()

==========
停顿1秒
运行了:1.0129413604736328秒
停顿2秒
运行了:2.0142152309417725秒

由此，顺利的实现，不修改原代码，也可以增加新功能的任务。

其实这里代码已经实现了任务效果，接下来我们来看看装饰器如何使用。

# 装饰器的语法和使用
# @ 称为语法糖
import time

# 增加一个计时功能
def show_time(func):  # 把函数当做参数传入
    def inner():
        start = time.time()
        func()
        end = time.time()
        print(f'运行了:{end - start}秒')
    return inner


@show_time  # 这里的 @show_time 就是告诉代码这里使用装饰器
# 停顿 1秒 函数
def add():
    time.sleep(1)  # 等待 1秒
    print('停顿1秒')


@show_time
# 停顿 2秒 函数
def sub():
    time.sleep(2)
    print('停顿2秒')


# add = show_time(add)  # 在特定函数定义前加入@show_time,其实就等价于这句代码
# sub = show_time(sub)  # 在特定函数定义前加入@show_time,其实就等价于这句代码
add()  # add() --> inner()
sub()

装饰器是python中简化代码的一种写法，只需要在定义函数之前加入 @装饰函数名 即可，一般在项目中会单独文件夹写装饰函数。

以上的代码，函数是无参，接下来我们就来学习一下，函数带参数的情况。

#求两个参数的和
import time

# 装饰器函数
def show_time(func):
    def inner(a,b):
        start = time.time()
        func(a,b)
        end = time.time()
        print(f'用时{end - start}秒')
    return inner


@show_time  # 语法糖 等价于 add = show_time(add) 这句代码
def add(a,b):
    time.sleep(1)
    print(a+b)


add(1,2)

再考虑参数数量不定的情况

# 求多个参数的和
import time


def show_time(func):
    def inner(*args, **kwargs):
        start = time.time()
        func(*args, **kwargs)
        end = time.time()
        print(f'用时{end - start}秒')

    return inner


@show_time
def add(*args, **kwargs):
    result = 0
    for i in args:
        result += i
    print(result)


add(1, 2, 3, 4, 5)

总结:

装饰器的形成条件：
1.不修改已有函数的源代码
2.不修改已有函数的调用方式
3.给已有函数增加额外的功能

注意装饰器与闭包的区别：装饰器实质上是一个闭包函数，但是装饰器这个闭包函数，他的参数有且只有一个并且是函数类型的话，他才是装饰器，否则他就是闭包函数 。