再学习闭包之前,我们要回顾一下两个概念
闭包就是打破了以上概念的现象,也就是某个函数,在作用域结束的时候,仍然存在,不会被程序回收内存空间。
定义:如果在一个嵌套内部函数里面,对在外作用域(但是不是全局作用域)的变量进行引用,那么内部函数就被认为是闭包。
理解:闭包 = 嵌套函数的内部函数 + 此内部函数调用了外层函数的变量 ,满足这两个条件的现象称为闭包。
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.给已有函数增加额外的功能
注意装饰器与闭包的区别:装饰器实质上是一个闭包函数,但是装饰器这个闭包函数,他的参数有且只有一个并且是函数类型的话,他才是装饰器,否则他就是闭包函数 。