如何使用给定的装饰器获取python类的所有方法
Posted
技术标签:
【中文标题】如何使用给定的装饰器获取python类的所有方法【英文标题】：How to get all methods of a python class with given decorator 【发布时间】：2011-08-20 02:56:33 【问题描述】：如何获取给定类 A 的所有用 @decorator2 修饰的方法？
class A():
def method_a(self):
pass
@decorator1
def method_b(self, b):
pass
@decorator2
def method_c(self, t=5):
pass
【问题讨论】：
你对“decorator2”源代码有控制权吗？ 让我们说不，只是为了保持有趣。但是当它使解决方案变得更加容易时，我也对这个解决方案感兴趣。 +1：“保持有趣”：通过这种方式了解更多信息 @S.Lott：你的意思是，通过搜索少学习。看看下面的最佳答案。这不是对 SO 的一个很好的贡献，增加了它作为程序员资源的价值吗？我认为为什么这个答案很好的主要原因是@kraiz 想要“让它保持有趣”。您的链接问题的答案不包含以下答案中包含的信息的 十分之一，除非您计算返回此处的两个链接。 【参考方案1】：方法一：基本注册装饰器
我已经在这里回答了这个问题：Calling functions by array index in Python =)
方法二：源码解析
如果您无法控制 类 定义，这是您想要假设的一种解释，这是不可能 （没有代码阅读反射），因为例如装饰器可以是一个无操作装饰器（就像在我的链接示例中一样），它只返回未修改的函数。 （尽管如此，如果您允许自己包装/重新定义装饰器，请参阅方法 3：将装饰器转换为“自我意识”，然后您会找到一个优雅的解决方案）
这是一个可怕的骇客，但您可以使用inspect 模块来读取源代码本身并对其进行解析。这在交互式解释器中不起作用，因为检查模块将拒绝在交互模式下提供源代码。然而，下面是一个概念证明。
#!/usr/bin/python3
import inspect
def deco(func):
return func
def deco2():
def wrapper(func):
pass
return wrapper
class Test(object):
@deco
def method(self):
pass
@deco2()
def method2(self):
pass
def methodsWithDecorator(cls, decoratorName):
sourcelines = inspect.getsourcelines(cls)[0]
for i,line in enumerate(sourcelines):
line = line.strip()
if line.split('(')[0].strip() == '@'+decoratorName: # leaving a bit out
nextLine = sourcelines[i+1]
name = nextLine.split('def')[1].split('(')[0].strip()
yield(name)
有效！：
>>> print(list( methodsWithDecorator(Test, 'deco') ))
['method']
请注意，必须注意解析和 python 语法，例如@deco 和 @deco(... 是有效结果，但如果我们只请求 'deco'，则不应返回 @deco2。我们注意到，根据http://docs.python.org/reference/compound_stmts.html 的官方python 语法，装饰器如下：
decorator ::= "@" dotted_name ["(" [argument_list [","]] ")"] NEWLINE
不必处理像@(deco) 这样的案件，我们松了一口气。但是请注意，如果您有非常复杂的装饰器，例如@getDecorator(...)，这仍然对您没有帮助，例如
def getDecorator():
return deco
因此，这种最好的代码解析策略无法检测到这样的情况。虽然如果你使用这个方法，你真正想要的是写在定义中方法之上的内容，在这种情况下是getDecorator。
根据规范，将@foo1.bar2.baz3(...) 作为装饰器也是有效的。您可以扩展此方法以使用它。您可能还可以扩展此方法以返回 <function object ...> 而不是函数的名称，但需要付出很多努力。然而，这种方法是骇人听闻和可怕的。
方法3：将装饰器转换为“自我意识”
如果您无法控制 decorator 定义（这是您想要的另一种解释），那么所有这些问题都会消失，因为您可以控制关于如何应用装饰器。因此，您可以通过 包装 来修改装饰器，创建自己的 装饰器，并使用 that 来装饰您的功能。让我再说一遍：你可以制作一个装饰器来装饰你无法控制的装饰器，“启发”它，在我们的例子中，它可以做它之前做的事情，但是也附加一个.decorator 元数据属性到它返回的可调用对象，允许您跟踪“此函数是否已装饰？让我们检查 function.decorator！”。 然后您可以遍历类的方法，并检查装饰器是否具有适当的.decorator 属性！ =) 如此处所示：
def makeRegisteringDecorator(foreignDecorator):
"""
Returns a copy of foreignDecorator, which is identical in every
way(*), except also appends a .decorator property to the callable it
spits out.
"""
def newDecorator(func):
# Call to newDecorator(method)
# Exactly like old decorator, but output keeps track of what decorated it
R = foreignDecorator(func) # apply foreignDecorator, like call to foreignDecorator(method) would have done
R.decorator = newDecorator # keep track of decorator
#R.original = func # might as well keep track of everything!
return R
newDecorator.__name__ = foreignDecorator.__name__
newDecorator.__doc__ = foreignDecorator.__doc__
# (*)We can be somewhat "hygienic", but newDecorator still isn't signature-preserving, i.e. you will not be able to get a runtime list of parameters. For that, you need hackish libraries...but in this case, the only argument is func, so it's not a big issue
return newDecorator
@decorator的演示：
deco = makeRegisteringDecorator(deco)
class Test2(object):
@deco
def method(self):
pass
@deco2()
def method2(self):
pass
def methodsWithDecorator(cls, decorator):
"""
Returns all methods in CLS with DECORATOR as the
outermost decorator.
DECORATOR must be a "registering decorator"; one
can make any decorator "registering" via the
makeRegisteringDecorator function.
"""
for maybeDecorated in cls.__dict__.values():
if hasattr(maybeDecorated, 'decorator'):
if maybeDecorated.decorator == decorator:
print(maybeDecorated)
yield maybeDecorated
有效！：
>>> print(list( methodsWithDecorator(Test2, deco) ))
[<function method at 0x7d62f8>]
但是，“注册的装饰器”必须是最外层的装饰器，否则.decorator属性注解会丢失。例如在一列火车上
@decoOutermost
@deco
@decoInnermost
def func(): ...
您只能看到 decoOutermost 公开的元数据，除非我们保留对“更多内部”包装器的引用。
旁注：上述方法还可以建立一个.decorator，它跟踪应用的装饰器和输入函数以及装饰器工厂参数的整个堆栈。 =) 例如，如果您考虑注释掉的行R.original = func，则可以使用这样的方法来跟踪所有包装层。如果我写了一个装饰器库，我个人会这样做，因为它允许进行深入的内省。
@foo 和 @bar(...) 之间也有区别。虽然它们都是规范中定义的“装饰器表达式”，但请注意foo 是一个装饰器，而bar(...) 返回一个动态创建的装饰器，然后应用它。因此，您需要一个单独的函数 makeRegisteringDecoratorFactory，这有点像 makeRegisteringDecorator，但甚至更多元：
def makeRegisteringDecoratorFactory(foreignDecoratorFactory):
def newDecoratorFactory(*args, **kw):
oldGeneratedDecorator = foreignDecoratorFactory(*args, **kw)
def newGeneratedDecorator(func):
modifiedFunc = oldGeneratedDecorator(func)
modifiedFunc.decorator = newDecoratorFactory # keep track of decorator
return modifiedFunc
return newGeneratedDecorator
newDecoratorFactory.__name__ = foreignDecoratorFactory.__name__
newDecoratorFactory.__doc__ = foreignDecoratorFactory.__doc__
return newDecoratorFactory
@decorator(...)的演示：
def deco2():
def simpleDeco(func):
return func
return simpleDeco
deco2 = makeRegisteringDecoratorFactory(deco2)
print(deco2.__name__)
# RESULT: 'deco2'
@deco2()
def f():
pass
这个生成器工厂包装器也可以工作：
>>> print(f.decorator)
<function deco2 at 0x6a6408>
奖励让我们甚至用方法 #3 尝试以下操作：
def getDecorator(): # let's do some dispatching!
return deco
class Test3(object):
@getDecorator()
def method(self):
pass
@deco2()
def method2(self):
pass
结果：
>>> print(list( methodsWithDecorator(Test3, deco) ))
[<function method at 0x7d62f8>]
如您所见，与方法 2 不同，@deco 被正确识别，即使它从未明确写入类中。与 method2 不同，如果该方法是在运行时添加（手动、通过元类等）或继承的，这也将起作用。
请注意，你也可以装饰一个类，所以如果你“启发”一个既用于装饰方法又用于装饰类的装饰器，然后在你要分析的类的主体内编写一个类 /em>，然后methodsWithDecorator 将返回修饰类以及修饰方法。可以将其视为一项功能，但您可以通过检查装饰器的参数（即.original）轻松编写逻辑来忽略这些功能，以实现所需的语义。
【讨论】：
对于一个非显而易见的解决方案的问题，这是一个很好的答案，我已经为这个答案开了一个赏金。对不起，我没有足够的代表给你更多！ @NiallDouglas：谢谢。 =) （我不知道经过大量编辑后，答案如何自动转换为“community-wiki”，所以我没有得到大多数支持的代表......所以谢谢！） 嗯，当原始装饰器是一个属性（或一个的修改形式）时，这似乎不起作用？有什么想法吗？ 这真是一个很好的答案！真棒@ninjagecko【参考方案2】：为了扩展 @ninjagecko 在方法 2：源代码解析中的出色答案，只要检查模块可以访问源代码，您就可以使用 Python 2.6 中引入的 ast 模块执行自检。
def findDecorators(target):
import ast, inspect
res =
def visit_FunctionDef(node):
res[node.name] = [ast.dump(e) for e in node.decorator_list]
V = ast.NodeVisitor()
V.visit_FunctionDef = visit_FunctionDef
V.visit(compile(inspect.getsource(target), '?', 'exec', ast.PyCF_ONLY_AST))
return res
我添加了一个稍微复杂的装饰方法：
@x.y.decorator2
def method_d(self, t=5): pass
结果：
> findDecorators(A)
'method_a': [],
'method_b': ["Name(id='decorator1', ctx=Load())"],
'method_c': ["Name(id='decorator2', ctx=Load())"],
'method_d': ["Attribute(value=Attribute(value=Name(id='x', ctx=Load()), attr='y', ctx=Load()), attr='decorator2', ctx=Load())"]
【讨论】：
很好，源解析正确，并带有适当的警告。 =) 如果他们决定改进或更正 python 语法，这将是向前兼容的（例如，通过删除对装饰器表达式的表达式限制，这似乎是一种疏忽）。 @ninjagecko 很高兴我不是唯一遇到装饰器表达式限制的人！大多数情况下，我在方法中绑定装饰函数闭包时会遇到它。将其绑定到变量变成了愚蠢的两步... 另见***.com/questions/4930414/…【参考方案3】：如果您确实可以控制装饰器，则可以使用装饰器类而不是函数：
class awesome(object):
def __init__(self, method):
self._method = method
def __call__(self, obj, *args, **kwargs):
return self._method(obj, *args, **kwargs)
@classmethod
def methods(cls, subject):
def g():
for name in dir(subject):
method = getattr(subject, name)
if isinstance(method, awesome):
yield name, method
return name: method for name,method in g()
class Robot(object):
@awesome
def think(self):
return 0
@awesome
def walk(self):
return 0
def irritate(self, other):
return 0
如果我打电话给awesome.methods(Robot)，它会返回
'think': <mymodule.awesome object at 0x000000000782EAC8>, 'walk': <mymodulel.awesome object at 0x000000000782EB00>
【讨论】：
这正是我想要的 非常感谢【参考方案4】：对于我们这些只想要最简单的情况的人 - 即，我们可以完全控制我们正在使用的类和我们试图跟踪的装饰器的单文件解决方案，我已经得到了答案。 ninjagecko 链接到一个解决方案，当您可以控制要跟踪的装饰器时，但我个人发现它很复杂并且很难理解，可能是因为我之前从未使用过装饰器。因此，我创建了以下示例，目标是尽可能简单明了。它是一个装饰器，一个具有多个装饰方法的类，以及用于检索和运行应用了特定装饰器的所有方法的代码。
# our decorator
def cool(func, *args, **kwargs):
def decorated_func(*args, **kwargs):
print("cool pre-function decorator tasks here.")
return_value = func(*args, **kwargs)
print("cool post-function decorator tasks here.")
return return_value
# add is_cool property to function so that we can check for its existence later
decorated_func.is_cool = True
return decorated_func
# our class, in which we will use the decorator
class MyClass:
def __init__(self, name):
self.name = name
# this method isn't decorated with the cool decorator, so it won't show up
# when we retrieve all the cool methods
def do_something_boring(self, task):
print(f"self.name does task")
@cool
# thanks to *args and **kwargs, the decorator properly passes method parameters
def say_catchphrase(self, *args, catchphrase="I'm so cool you could cook an egg on me.", **kwargs):
print(f"self.name says \"catchphrase\"")
@cool
# the decorator also properly handles methods with return values
def explode(self, *args, **kwargs):
print(f"self.name explodes.")
return 4
def get_all_cool_methods(self):
"""Get all methods decorated with the "cool" decorator.
"""
cool_methods = name: getattr(self, name)
# get all attributes, including methods, properties, and builtins
for name in dir(self)
# but we only want methods
if callable(getattr(self, name))
# and we don't need builtins
and not name.startswith("__")
# and we only want the cool methods
and hasattr(getattr(self, name), "is_cool")
return cool_methods
if __name__ == "__main__":
jeff = MyClass(name="Jeff")
cool_methods = jeff.get_all_cool_methods()
for method_name, cool_method in cool_methods.items():
print(f"method_name: cool_method ...")
# you can call the decorated methods you retrieved, just like normal,
# but you don't need to reference the actual instance to do so
return_value = cool_method()
print(f"return value = return_value\n")
运行上面的例子会给我们以下输出：
explode: <bound method cool.<locals>.decorated_func of <__main__.MyClass object at 0x00000220B3ACD430>> ...
cool pre-function decorator tasks here.
Jeff explodes.
cool post-function decorator tasks here.
return value = 4
say_catchphrase: <bound method cool.<locals>.decorated_func of <__main__.MyClass object at 0x00000220B3ACD430>> ...
cool pre-function decorator tasks here.
Jeff says "I'm so cool you could cook an egg on me."
cool post-function decorator tasks here.
return value = None
请注意，此示例中的修饰方法具有不同类型的返回值和不同的签名，因此能够全部检索和运行它们的实用价值有点可疑。但是，在有许多类似方法的情况下，所有方法都具有相同的签名和/或返回值类型（例如，如果您正在编写连接器以从一个数据库中检索未规范化的数据，对其进行规范化并将其插入第二个数据库，标准化数据库，并且您有一堆类似的方法，例如 15 个 read_and_normalize_table_X 方法），能够即时检索（并运行）它们可能会更有用。
【讨论】：
我看到这不是公认的解决方案，但对我来说它看起来是最简单的。我没有看到这种方法有什么缺点吗？【参考方案5】：也许，如果装饰器不太复杂（但我不知道是否有不那么 hacky 的方式）。
def decorator1(f):
def new_f():
print "Entering decorator1", f.__name__
f()
new_f.__name__ = f.__name__
return new_f
def decorator2(f):
def new_f():
print "Entering decorator2", f.__name__
f()
new_f.__name__ = f.__name__
return new_f
class A():
def method_a(self):
pass
@decorator1
def method_b(self, b):
pass
@decorator2
def method_c(self, t=5):
pass
print A.method_a.im_func.func_code.co_firstlineno
print A.method_b.im_func.func_code.co_firstlineno
print A.method_c.im_func.func_code.co_firstlineno
【讨论】：
不幸的是，这只返回以下行的行号：def new_f():（第一个，第 4 行）、def new_f():（第二个，第 11 行）和def method_a(self):。你将很难找到你想要的真正的行，除非你有一个约定总是通过定义一个新函数作为第一行来编写你的装饰器，而且你不能写任何文档字符串......虽然你可以避免不必不通过使用一种方法来编写文档字符串，该方法检查缩进，因为它逐行向上移动以查找真正的装饰器的名称。
即使有修改，如果定义的函数不在装饰器中，这也不起作用。装饰器也可以是可调用对象，因此该方法甚至可能抛出异常。
"...如果装饰器不太复杂..." - 如果两个装饰方法的行号相同，则它们的装饰可能相同。大概。 （好吧，也应该检查 co_filename）。【参考方案6】：
解决此问题的一种简单方法是将代码放入装饰器中，将传入的每个函数/方法添加到数据集（例如列表）中。
例如
def deco(foo):
functions.append(foo)
return foo
现在每个带有 deco 装饰器的函数都将被添加到 functions。
【讨论】：
【参考方案7】：我不想添加太多，只是忍者方法 2 的一个简单变体。它可以创造奇迹。
相同的代码，但使用列表推导而不是生成器，这正是我所需要的。
def methodsWithDecorator(cls, decoratorName):
sourcelines = inspect.getsourcelines(cls)[0]
return [ sourcelines[i+1].split('def')[1].split('(')[0].strip()
for i, line in enumerate(sourcelines)
if line.split('(')[0].strip() == '@'+decoratorName]
【讨论】：
以上是关于如何使用给定的装饰器获取python类的所有方法的主要内容，如果未能解决你的问题，请参考以下文章
python9-类的装饰器（property, classmethod, staticmethod）