Question

我试图弄清楚如何获取方法上所有装饰器的名称。我已经可以获取方法名称和docstring，但无法弄清楚如何获取装饰器列表。

Answer 1

我很惊讶这个问题太老了，没有人花时间添加实际内省的方法，所以这就是：

您要检查的代码......

def template(func):
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper

baz = template
che = template

class Foo(object):
    @baz
    @che
    def bar(self):
        pass

现在你可以用这样的东西来检查上面的Foo类......

import ast
import inspect

def get_decorators(cls):
    target = cls
    decorators = {}

    def visit_FunctionDef(node):
        decorators[node.name] = []
        for n in node.decorator_list:
            name = ''
            if isinstance(n, ast.Call):
                name = n.func.attr if isinstance(n.func, ast.Attribute) else n.func.id
            else:
                name = n.attr if isinstance(n, ast.Attribute) else n.id

            decorators[node.name].append(name)

    node_iter = ast.NodeVisitor()
    node_iter.visit_FunctionDef = visit_FunctionDef
    node_iter.visit(ast.parse(inspect.getsource(target)))
    return decorators

print get_decorators(Foo)

应该打印这样的东西......

{'bar': ['baz', 'che']}

或者至少它是在我用Python 2.7.9快速测试时做的：）

Answer 2

如果你可以改变你从

调用装饰器的方式

class Foo(object):
    @many
    @decorators
    @here
    def bar(self):
        pass

到

class Foo(object):
    @register(many,decos,here)
    def bar(self):
        pass

然后你可以这样注册装饰器：

def register(*decorators):
    def register_wrapper(func):
        for deco in decorators[::-1]:
            func=deco(func)
        func._decorators=decorators        
        return func
    return register_wrapper

例如：

def many(f):
    def wrapper(*args,**kwds):
        return f(*args,**kwds)
    return wrapper

decos = here = many

class Foo(object):
    @register(many,decos,here)
    def bar(self):
        pass

foo=Foo()

这里我们访问装饰器的元组：

print(foo.bar._decorators)
# (<function many at 0xb76d9d14>, <function decos at 0xb76d9d4c>, <function here at 0xb76d9d84>)

这里我们只打印装饰器的名称：

print([d.func_name for d in foo.bar._decorators])
# ['many', 'decos', 'here']

Answer 3

那是因为装饰者是“语法糖”。假设您有以下装饰者：

def MyDecorator(func):
    def transformed(*args):
        print "Calling func " + func.__name__
        func()
    return transformed

然后将其应用于函数：

@MyDecorator
def thisFunction():
    print "Hello!"

这相当于：

thisFunction = MyDecorator(thisFunction)

如果您控制装饰器，也可以将“历史”嵌入到函数对象中。我敢打赌还有其他一些聪明的方法可以做到这一点（也许是通过重写任务），但不幸的是，我并不精通Python。：（

Answer 4

我添加了相同的问题。在我的单元测试中，我只想确保给定的函数/方法使用了装饰器。

装饰器是分别测试的，因此我不需要测试每个装饰函数的通用逻辑，只需使用装饰器即可。

我终于想到了以下帮助函数：

import inspect

def get_decorators(function):
    """Returns list of decorators names

    Args:
        function (Callable): decorated method/function

    Return:
        List of decorators as strings

    Example:
        Given:

        @my_decorator
        @another_decorator
        def decorated_function():
            pass

        >>> get_decorators(decorated_function)
        ['@my_decorator', '@another_decorator']

    """
    source = inspect.getsource(function)
    index = source.find("def ")
    return [
        line.strip().split()[0]
        for line in source[:index].strip().splitlines()
        if line.strip()[0] == "@"
    ]

通过列表理解，它有点“密集”，但是可以解决问题，在我看来，这是一个测试助手功能。

仅当您对装饰器名称感兴趣，而不是潜在的装饰器参数时，它才起作用。如果要支持装饰器接受参数，可以使用line.strip().split()[0].split("(")[0]之类的技巧（未经测试）

最后，如果需要，可以将line.strip().split()[0]替换为line.strip().split()[0][1:]

来删除“ @”

Answer 5

作为Faisal notes，您可以让装饰者自己将元数据附加到函数中，但据我所知，它不会自动完成。

Answer 6

你可以，但更糟糕的是，有一些库可以帮助隐藏你已经装饰了一个函数的事实。有关详细信息，请参阅Functools或装饰器库（@decorator，如果可以找到的话）。

Answer 7

在我看来这是不可能的。装饰器不是某种方法的某种属性或元数据。装饰器是用函数调用结果替换函数的便捷语法。有关详细信息，请参阅http://docs.python.org/whatsnew/2.4.html?highlight=decorators#pep-318-decorators-for-functions-and-methods。

Answer 8

不可能以一般方式做，因为

@foo
def bar ...

与

完全相同

def bar ...
bar = foo (bar)

您可以在某些特殊情况下执行此操作，例如通过分析函数对象可能@staticmethod，但不是更好。

在方法上获取装饰器名称的内省？

8 个答案: