函数的作用域
name = "jack" # 全局作用域
def run():
name = "rose" # 局部作用域
def inner():
print(name)
return inner
v1 = run()
v1()
v2 = run()
v2()
当执行v1()
时,inner()
中的name
会在自己的作用域中查找,因此name
为rose
。
同理,执行v2()
时,也会在自己的作用域中查找,因此name
为rose
。
闭包
闭包,简而言之就是将数据封装在一个包(区域)中,使用时再去里面取。(本质上 闭包是基于函数嵌套搞出来一个中特殊嵌套)
闭包应用场景1:封装数据防止污染全局。
def func(age):
name = "jack"
def f1():
print(name, age)
def f2():
print(name, age)
def f3():
print(name, age)
f1()
f2()
f3()
func(20)
闭包应用场景2:封装数据封到一个包里,使用时在取。
def task(arg):
def inner():
print(arg)
return inner
v1 = task(11)
v2 = task(22)
v3 = task(33)
v1() # 自己的作用域中arg=11
v2() # 自己的作用域中arg=22
v3() # 自己的作用域中arg=33
装饰器
def outer(origin):
def inner(*args, **kwargs):
print("before 110")
res = origin(*args, **kwargs) # 调用原来的func函数
print("after")
return res
return inner
@outer # func1 = outer(func1)
def func1(a1):
print("我是func1函数")
value = (11, 22, 33, 44)
return value
@outer # func2 = outer(func2)
def func2(a1, a2):
print("我是func2函数")
value = (11, 22, 33, 44)
return value
@outer # func3 = outer(func3)
def func3(a1):
print("我是func3函数")
value = (11, 22, 33, 44)
return value
func1(1) # 每个函数可以有自己的对应的参数
func2(11, a2=22)
func3(999)
实现原理:基于@
语法和函数闭包,将原函数封装在闭包中,然后将函数赋值为一个新的函数(内层函数),执行函数时再在内层函数中执行闭包中的原函数。
可以在不改变原函数内部代码 和 调用方式的前提下,实现在函数执行和执行扩展功能。
适用场景:多个函数系统统一在执行前后自定义一些功能。
def outer(origin):
def inner(*args, **kwargs):
# 执行前
res = origin(*args, **kwargs) # 调用原来的func函数
# 执行后
return res
return inner
@outer
def func():
pass
func()
functools
上面的装饰器,一般情况下是没有问题的。
但是如果有下面的需求,就有可能出现问题:
def handler():
pass
handler()
print(handler.__name__) # handler
def auth(func):
def inner(*args, **kwargs):
return func(*args, **kwargs)
return inner
@auth
def handler():
pass
handler()
print(handler.__name__) # inner
可以发现装饰器实际上就是将原函数更改为其他的函数,然后再此函数中再去调用原函数。
如果我们想获取函数的函数名,可以使用functools
来实现。
import functools
def auth(func):
@functools.wraps(func)
def inner(*args, **kwargs):
"""这里是inner的注释"""
res = func(*args, **kwargs) # 执行原函数
return res
return inner