如何使用给定的装饰器获取Python类的所有方法？

Question

如何获取给定类 A 中用 @decorator2 装饰的所有方法？

class A():
    def method_a(self):
      pass

    @decorator1
    def method_b(self, b):
      pass

    @decorator2
    def method_c(self, t=5):
      pass

Answer 1

方法1：基本注册装饰器

我已经在这里回答了这个问题：调用Python 中按数组索引调用函数 =)

---

方法 2：源代码解析

如果您无法控制类定义，这是对您的内容的一种解释我想假设，这是不可能（没有代码读取反射），因为例如装饰器可能是一个无操作装饰器（就像在我的链接示例中），它仅返回未修改的函数。 （尽管如此，如果您允许自己包装/重新定义装饰器，请参阅方法 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 装饰器如下：

decorator      ::=  "@" dotted_name ["(" [argument_list [","]] ")"] NEWLINE

我们松了一口气，因为不必处理案例但请注意，如果您有非常复杂的装饰器，例如 @getDecorator(...)，例如

def getDecorator():
    return deco

因此，这种解析代码的最佳策略无法检测到这样的情况，但如果您使用此方法，您真正需要的是定义中方法之上编写的内容。在这种情况下是 getDecorator

根据规范，将 @foo1.bar2.baz3(...) 作为装饰器也是有效的。您可以扩展此方法来使用它。您还可以扩展此方法以返回 而不是函数名称，这需要花费大量精力。然而，这种方法是黑客且可怕的。

---

方法 3：将装饰器转换为“自我意识”

如果您无法控制装饰器定义（这是您想要的另一种解释），那么所有这些问题都会消失，因为您可以控制装饰器的应用方式。因此，您可以通过包装来修改装饰器，以创建您自己的装饰器，并使用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< /code> 属性注释将会丢失。例如，在一列中，

@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 不同，如果该方法是在运行时添加（手动、通过元类等）或继承的，这也将起作用。

请注意，您还可以装饰一个类，因此如果您“启发”一个用于装饰方法和类的装饰器，然后在要分析的类的主体中编写一个类 ，那么 methodsWithDecorator 将返回修饰类以及修饰方法。人们可以认为这是一项功能，但您可以通过检查装饰器的参数（即 .original）轻松编写逻辑来忽略这些功能，以实现所需的语义。

Answer 2

为了扩展@ninjagecko在方法2：源代码解析中的优秀答案，只要inspect模块可以访问源代码，您就可以使用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())"]}

Answer 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>}

Answer 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 方法），能够即时检索（并运行）它们可能会更有用。

Answer 5

也许，如果装饰器不太复杂（但我不知道是否有一种不那么麻烦的方法）。

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

Answer 6

我不想添加太多内容，只是 ninjagecko 方法 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]

Answer 7

解决此问题的一个简单方法是将代码放入装饰器中，将传入的每个函数/方法添加到数据集（例如列表）中。

例如

def deco(foo):
    functions.append(foo)
    return foo

，现在每个带有 deco 装饰器的函数都将被添加到 functions 中。