实例详解Python装饰器与闭包

2023-08-18 11:21:04 67

闭包是Python装饰器的基础。要理解闭包，先要了解Python中的变量作用域规则。

变量作用域规则

首先，在函数中是能访问全局变量的：

>>>a='globalvar'
>>>deffoo():
print(a)
>>>foo()
globalvar

然后，在一个嵌套函数中，内层函数能够访问在外层函数中定义的局部变量：

>>>deffoo():
a='freevar'
defbar():
print(a)
returnbar

>>>foo()()
freevar

闭包

上面的嵌套函数就是闭包。闭包是指延伸了作用域的函数，在其中能够访问未在函数定义体中定义的非全局变量。未在函数定义体中定义的非全局变量一般都是在嵌套函数中出现的。

上述示例中的变量a就是一个并未在函数bar中定义的非全局变量。对于bar来说，它有个专业名字，叫做自由变量。

自由变量的名称可以在字节码对象中查看：

>>>bar=foo()
>>>bar.__code__.co_freevars
('a',)

自由变量的值绑定在函数的__closure__属性中：

>>>bar.__closure__
(,)

其中保存了对应自由变量的cell对象的序列，cell对象的cell_contents属性保存了变量的值：

>>>bar.__closure__[0].cell_contents
'freevar'

这与JavaScript中闭包的行为是类似的，JavaScript中嵌套函数会将外层函数的活动对象添加到它的作用域链中。但与JavaScript不同的是，当Python函数中的全局变量或者自由变量是不可变对象(数字、字符串、元组等)时，是只能读取，无法更新的：

>>>a=1
>>>deffoo():
print(a)
a+=1

>>>foo()
UnboundLocalError:localvariable'a'referencedbeforeassignment

>>>deffoo():
a=1
defbar():
print(a)
a+=1
returnbar

>>>foo()()
UnboundLocalError:localvariable'a'referencedbeforeassignment

两种情况下，都会报错。这并不是缺陷，而是Python的设计选择。Python不要求声明变量，但是会假定在函数定义体中赋值的变量是局部变量，以避免在不知情的情况下修改全局变量。

a+=1与a=a+1相同，编译函数的定义体时，会将a当做局部变量，不会当做自由变量保存。然后尝试获取a的值时，发现a并没有绑定值，于是报错。

解决这个问题的办法，一是将变量置于一些可变对象，如列表、字典中：

deffoo():
ns={}
ns['a']=1
defbar():
ns['a']+=1
print(ns['a'])
returnbar

另外的方法就是使用global或者nonlocal将变量声明为全局变量或者自由变量：

>>>deffoo():
a=1
defbar():
nonlocala
a+=1
print(a)
returnbar

>>>foo()()
2

当自由变量本身是可变对象时，是可以直接进行操作的：

defmake_avg():
ls=[]
defavg(x):
ls.append(x)
print(sum(ls)/len(ls))
returnavg

装饰器

装饰器是可调用对象，参数一般是另一个函数。装饰器可以以某种方式增强被装饰函数的行为，然后返回被装饰的函数或者将其替换成一个新的函数。

一个最简单的不做任何额外行为的装饰器：

defdecorate(func):
returnfunc

decorate函数就是一个最简单的装饰器，使用方法：

deftarget():
pass
target=decorate(target)

Python为装饰器的使用提供了语法糖，可以简便的写为：

@decorate
deftarget():
pass

导入时运行

装饰器一个很重要的特性是它是导入时(加载模块时)运行的：

defdecorate(func):
print('runningdecoratorwhenimport')
returnfunc
@decorate
deffoo():
print('runningfoo')
pass
if__name__=='__main__':
print('startfoo')
foo()

结果：

runningdecoratorwhenimportstartfoorunningfoo

可以看到，装饰器是导入时运行的，而被装饰的函数是明确调用时运行的。

装饰器可以返回被装饰的函数本身，和运行时导入的特性结合起来，可以实现简单的注册器功能：

view_registry=[]
defregister(func):
view_registry.append(func)
returnfunc
@register
defview1():
pass
@register
defview2():
pass
defmain():
print(view_registry)
if__name__=='__main__':
main()

返回新函数

上述装饰器的例子都返回了被装饰的原函数，但装饰器的典型行为还是返回一个新函数：把被装饰的函数替换成新函数，新函数接受与原函数相同的参数，并且返回原函数本该返回的值。写法类似于：

defdeco(func):
defnew_func(*args,**kwargs):
returnfunc(*args,**kwargs)
returnnew_func

这种情况下装饰器就使用到了闭包。JavaScript中的防抖与节流函数就是这种典型的装饰器行为。新函数一般会使用外部装饰器函数中的变量当做自由变量，对函数作出某种增强行为。

举个例子，我们知道，当Python函数的参数是个可变对象时，会产生意料之外的行为：

deffoo(x,y=[]):
y.append(x)
print(y)

foo(1)
foo(2)
foo(3)

输出：

[1][1,2][1,2,3]

这是因为，函数的参数默认值保存在__defaults__属性中，指向了同一个列表：

>>>foo.__defaults__
([1,2,3],)

我们就可以用一个装饰器在函数执行前取出默认值做深复制，然后覆盖函数原先的参数默认值：

importcopy
deffresh_defaults(func):
defaults=func.__defaults__
defdeco(*args,**kwargs):
func.__defaults__=copy.deepcopy(defaults)
returnfunc(*args,**kwargs)
returndeco
@fresh_defaults
deffoo(x,y=[]):
y.append(x)
print(y)
foo(1)
foo(2)
foo(3)

输出：

[1][2][3]

接收参数的装饰器

装饰器除了可以接受函数作为参数外，还可以接受其他参数。使用方法是：创建一个装饰器工厂，接受参数，返回一个装饰器，再把它应用到被装饰的函数上，语法如下：

defdeco_factory(*args,**kwargs):
defdeco(func):
print(args)
returnfunc
returndeco
@deco_factory('factory')
deffoo():
pass

在Web框架中，通常要将URL模式映射到生成响应的view函数，并将view函数注册到某些中央注册处。之前我们曾经实现过一个简单的注册装饰器，只是注册了view函数，却没有URL映射，是远远不够的。

在Flask中，注册view函数需要一个装饰器：

@app.route('/hello')
defhello():
return'Hello,World'

原理就是使用了装饰器工厂，可以简单的模拟一下实现：

classApp:
def__init__(self):
self.view_functions={}
defroute(self,rule):
defdeco(view_func):
self.view_functions[rule]=view_func
returnview_func
returndeco
app=App()
@app.route('/')
defindex():
pass
@app.route('/hello')
defhello():
pass
forrule,viewinapp.view_functions.items():
print(rule,':',view.__name__)

输出：

/:index/hello:hello

还可以使用装饰器工厂来确定view函数可以允许哪些HTTP请求方法：

defaction(methods):
defdeco(view):
view.allow_methods=[method.lower()formethodinmethods]
returnview
returndeco
@action(['GET','POST'])
defview(request):
ifrequest.method.lower()inview.allow_methods:
...

重叠的装饰器

装饰器也是可以重叠使用的：

@d1
@d2
deffoo():
pass

等同于：

foo=d1(d2(foo))

类装饰器

装饰器的参数也可以是一个类，也就是说，装饰器可以装饰类：

importtypes
defdeco(cls):
forkey,methodincls.__dict__.items():
ifisinstance(method,types.FunctionType):
print(key,':',method.__name__)
returncls
@deco
classTest:
def__init__(self):
pass
deffoo(self):
pass

总结

以上所述是小编给大家介绍的实例详解Python装饰器与闭包,希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对毛票票网站的支持！
如果你觉得本文对你有帮助，欢迎转载，烦请注明出处，谢谢！

声明：本文内容来源于网络，版权归原作者所有，内容由互联网用户自发贡献自行上传，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任。如果您发现有涉嫌版权的内容，欢迎发送邮件至：czq8825#qq.com（发邮件时，请将#更换为@）进行举报，并提供相关证据，一经查实，本站将立刻删除涉嫌侵权内容。

实例详解Python装饰器与闭包

热门推荐

随机推荐