@decorator 获取 @staticmethod 和 @classmethod 的 Class.__name__

Question

装饰器@wrapper 正在使用wrapt 库来访问包装函数的类以获取类的名称。在Animal.method() 和foo() 上使用它可以按预期工作。

问题： 但是，用@classmethod 装饰的方法Animal.classy 将type 作为其类名，而用@staticmethod 装饰的方法Animal.static 无法检索其类。

@wrapper装饰器函数是否可以获取Animal.classy()和Animal.static()的类名Animal？

预期输出

foo
Animal.method
Animal.classy
Animal.static

获得的输出

foo
Animal.method
type.classy
static

重现代码

import wrapt
import time

@wrapt.decorator
def wrapper(wrapped, instance, args, kw):
    if instance is not None:
        print(f'\n{instance.__class__.__name__}.{wrapped.__name__}')
    else:
        print('\n' + wrapped.__name__)
    result = wrapped(*args, **kw)
    return result

@wrapper
def foo():
    time.sleep(0.1)

class Animal:
    @wrapper
    def method(self):
        time.sleep(0.1)

    @wrapper
    @classmethod
    def classy(cls):
        time.sleep(0.1)

    @wrapper
    @staticmethod
    def static():
        time.sleep(0.1)

if __name__ == '__main__':
    foo()                   # foo
    Animal().method()       # Animal.method
    Animal.classy()         # type.classy
    Animal.static()         # static

Answer 1

您遇到的问题是 arg instance 是任何方法的第一个参数的值。因此，对于常规方法，这将是 self 值，对于类方法，它将是 cls 值。对于静态方法，您没有第一个/实例参数，因此它的行为就好像它是一个函数，instance 是None。

让我们来看看你的代码。你调用foo，你的包装器检查是否设置了instance，不是因为函数没有实例参数，所以它打印出函数的名称。

接下来，您在 Animal 的实例上调用 method。您的包装器检查是否设置了 instance，这是因为方法获取实例参数，因此它会打印出 instance 的类名称和方法名称。

接下来，您在 Animal 类上调用 classy。您的包装器检查是否设置了instance，这是因为类方法获取实例参数，因此它打印出instance 的类名称和类方法的名称。但是在这种情况下，instance 是定义该方法的类，因此当您执行instance.__class__ 时，它会检索您的Animal 类的元类type。所以在这种情况下你真正想要的是添加一个检查if isinstance(instance, type)，在这种情况下你想做print(f"{instance.__name__}.{wrapped.__name__}")，因为在这种情况下实例是你的类。

最后你在你的类Animal 上调用静态方法static。当您声明一个静态方法时，它的行为就像一个普通函数。因此，您的包装器检查是否设置了 instance 并发现它不是，因为函数没有获取实例参数，所以继续并打印函数的名称。我知道没有检测静态方法的标准方法。

所以总结一下，回答您的确切问题。是否可以获得classy 的类名？是的。是否可以获得static 的类名？我不知道。

有关实现可在不同上下文中应用的装饰器的更多信息，请参阅：

• https://wrapt.readthedocs.io/en/latest/decorators.html#universal-decorators

它特别提供了示例：

import inspect

@wrapt.decorator
def universal(wrapped, instance, args, kwargs):
    if instance is None:
        if inspect.isclass(wrapped):
            # Decorator was applied to a class.
            return wrapped(*args, **kwargs)
        else:
            # Decorator was applied to a function or staticmethod.
            return wrapped(*args, **kwargs)
    else:
        if inspect.isclass(instance):
            # Decorator was applied to a classmethod.
            return wrapped(*args, **kwargs)
        else:
            # Decorator was applied to an instancemethod.
            return wrapped(*args, **kwargs)

这可能有助于了解在每种情况下需要采取哪些步骤来计算名称。

希望这是有道理的。