我问,给定一个装饰器的函数,是否可以在不调用装饰器调用的情况下运行该函数?
给定一个函数foo
,是否可以选择打开或关闭装饰器?
给出
@decorator
def foo():
//do_somthing
是否可以在foo
关闭时运行decorator
?
可能存在某些功能,您可能希望在有或没有装饰器的情况下运行它。例如(并且不是一个好的,因为它涉及有效的缓存)在factorial(n)
函数中关闭基于装饰器的缓存。
我的问题与此问题类似Optionally use decorators on class methods。它讨论了装饰器切换ON / OFF的良好应用(作为api暴露);
如果我必须使用一个函数,说goo
并给出选项以运行goo
有或没有装饰器,我尝试了一种原始的,hackish方式来实现这个可选的装饰器打开/关闭切换功能如下:
# this is the decorator class that executes the function `goo`
class deco(object):
def __init__(self, attr):
print "I am initialized"
self.fn = None
# some args you may wana pass
self.attr = attr
# lets say you want these attributes to persist
self.cid = self.attr['cid']
self.vid = 0
def __call__(self, f):
# the call executes and returns another inner wrapper
def wrap(*args):
# this executes main function - see closure
self.fn = f
self.vid = args[0]
self.closure(*args)
return wrap
def closure(self, *args):
n = args[0]
self.cid[n] = self.vid
#goo = deco(fn, attr)
print 'n',n
# executes function `goo`
self.fn(*args)
class gooClass(object):
class that instantias and wraps `goo`around
def __init__(self, attr, deco):
'''
@param:
- attr: some mutable data structure
- deco: True or False. Whether to run decorator or not
'''
self.attr = attr
self.deco = deco
def __call__(self, *args):
if self.deco:
# initiate deco class with passed args
foo = deco(self.attr)
# now pass the `goo` function to the wrapper inside foo.__class__.__call__
foo = foo(self.goo)
return foo(*args)
else:
# execute w/o decorator
return self.goo(*args)
def goo(self, n):
# recursive goo
if n>0:
print 'in goo',n
#print n
# to recurse, I recreate the whole scene starting with the class
# because of this the args in `deco` Class init never persist
too = gooClass(self.attr, self.deco)
return too(n-1)
else: return n
def Fn(n, decoBool):
# this function is where to start running from
attr = {}
cid = [0]*(n+1)
attr['cid'] = cid
#following wud work too but defeat the purpose - have to define again! foo is goo actually
#@deco(attr)
#def foo(n):
# if n>0:
# print 'in foo',n
# #print n
# return foo(n-1)
# else: return n
#return foo(n), attr
# create the gooClass and execute `goo` method instance
foo = gooClass(attr, decoBool)
print foo(n)
return foo
res = Fn(5, True)
print res.attr
print "="*10
res = Fn(5, False)
print res.attr
输出:
I am initialized
n 5
in goo 5
I am initialized
n 4
in goo 4
I am initialized
n 3
in goo 3
I am initialized
n 2
in goo 2
I am initialized
n 1
in goo 1
I am initialized
n 0
None
{'cid': [0, 1, 2, 3, 4, 5]}
==========
in goo 5
in goo 4
in goo 3
in goo 2
in goo 1
0
{'cid': [0, 0, 0, 0, 0, 0]}
技术上有效,但我认为这是一个自助式黑客攻击。不是pythonic。 每次以递归方式创建新类时。
问题代表,我在这里找不到一个相关的答案,所以我创建了这个,有没有办法可以选择打开/关闭装饰器?
答案 0 :(得分:4)
将未修饰的函数附加到装饰的函数,如unwrapped
所说,然后从装饰器返回。
例如
def add42(fn):
def wrap(i):
return fn(i) + 42
wrap.unwrapped = fn
return wrap
@add42
def mult3(i):
return i * 3
mult3(1) # 45
mult3.unwrapped(1) # 3
答案 1 :(得分:-1)
只需将foo装饰为另一个名称。然后,您可以选择使用任何一个,干净的foo或装饰的foo。
decorated_foo = decorator(foo)
如果您同时具有foo和decorator的参数:
decorated_foo = decorator(decorator_args)(foo)
#when using:
decorated_foo(foo_args)