在函数装饰器中调用 Python 实例方法

Question

是否有一种简洁的方法让装饰器仅在实例化类的实例时调用类的实例方法？

class C:
    def instance_method(self):
      print('Method called')

    def decorator(f):
        print('Locals in decorator %s  ' % locals())
        def wrap(f):
            print('Locals in wrapper   %s' % locals())
            self.instance_method()
            return f
        return wrap

    @decorator
    def function(self):
      pass

c = C()
c.function()

我知道这不起作用，因为 self 在调用 decorator 时未定义（因为它没有作为实例方法调用，因为没有对该类的可用引用）。然后我想出了这个解决方案：

class C:
    def instance_method(self):
      print('Method called')

    def decorator():
        print('Locals in decorator %s  ' % locals())
        def wrap(f):
            def wrapped_f(*args):
                print('Locals in wrapper   %s' % locals())
                args[0].instance_method()
                return f
            return wrapped_f
        return wrap

    @decorator()
    def function(self):
      pass

c = C()
c.function()

这使用了这样一个事实，即我知道任何实例方法的第一个参数都是self。这个包装器定义方式的问题是每次执行函数时都会调用实例方法，这是我不想要的。然后我想出了以下有效的细微修改：

class C:
    def instance_method(self):
      print('Method called')
def decorator(called=[]):
    print('Locals in decorator %s  ' % locals())
    def wrap(f):
        def wrapped_f(*args):
            print('Locals in wrapper   %s' % locals())
            if f.__name__ not in called:
                called.append(f.__name__)
                args[0].instance_method()
            return f
        return wrapped_f
    return wrap

@decorator()
def function(self):
  pass

c = C()
c.function()
c.function()

现在该函数只被调用一次，但我不喜欢每次调用该函数时都必须进行此检查的事实。我猜没有办法解决它，但如果有人有任何建议，我很想听听他们的意见！谢谢:)

Answer 1

我想出了一个可能的替代解决方案。我喜欢它，因为在定义函数时只发生一次调用，而在实例化类时只发生一次调用。唯一的缺点是函数属性有一点额外的内存消耗。

from types import FunctionType

class C:
    def __init__(self):
        for name,f in C.__dict__.iteritems():
            if type(f) == FunctionType and hasattr(f, 'setup'):
                  self.instance_method()

    def instance_method(self):
      print('Method called')

    def decorator(f):
        setattr(f, 'setup', True)
        return f

    @decorator
    def function(self):
      pass

c = C()
c.function()
c.function()

Answer 2

我认为你在问一些根本不可能的事情。装饰器将与类同时创建，但实例方法在实例创建之前不存在，即稍后。所以装饰器无法处理特定于实例的功能。

另一种思考方式是装饰器是一个函子：它将函数转换为其他函数。但它没有说明这些函数的参数；它的工作水平比这更高。所以在function 的参数上调用实例方法不是装饰器应该做的事情；这是function应该做的事情。

解决这个问题的方法必然是骇人听闻的。你的方法看起来不错，就像黑客一样。

Answer 3

这可以通过使用可调用对象作为装饰器来实现。

class ADecorator(object):
    func = None
    def __new__(cls, func):
        dec = object.__new__(cls)
        dec.__init__(func)
        def wrapper(*args, **kw):
            return dec(*args, **kw)
        return wrapper

    def __init__(self, func, *args, **kw):
        self.func = func
        self.act  = self.do_first

    def do_rest(self, *args, **kw):
        pass

    def do_first(self, *args, **kw):
        args[0].a()
        self.act = self.do_rest

    def __call__(self, *args, **kw):
        return self.act(*args, **kw)

class A(object):
    def a(self):
        print "Original A.a()"

    @ADecorator
    def function(self):
        pass


a = A()
a.function()
a.function()

Answer 4

C 类的多个实例应该如何表现？无论哪个实例调用function，是否应该只调用一次instance_method？还是每个实例都应该调用一次instance_method？

您的called=[] 默认参数使装饰器记住已调用了字符串名称为function 的内容。如果decorator 用于两个不同的类，它们都有一个名为function 的方法怎么办？那么

c=C()
d=D()
c.function()
d.function()

只会调用c.instance_method 并防止d.instance_method 被调用。奇怪，可能不是你想要的。

下面，我用self._instance_method_called记录self.instance_method是否被调用。这使得C 的每个实例最多调用instance_method 一次。

如果您希望instance_method 最多被调用一次，而不管C 的哪个实例调用function，那么只需将_instance_method_called 定义为类属性而不是实例属性。

def decorator():
    print('Locals in decorator %s  ' % locals())
    def wrap(f):
        def wrapped(self,*args):
            print('Locals in wrapper   %s' % locals())            
            if not self._instance_method_called:
                self.instance_method()
                self._instance_method_called=True
            return f
        return wrapped
    return wrap

class C:
    def __init__(self):
        self._instance_method_called=False
    def instance_method(self): print('Method called')
    @decorator()
    def function(self):
      pass

c = C()
# Locals in decorator {}  
c.function()
# Locals in wrapper   {'self': <__main__.C instance at 0xb76f1aec>, 'args': (), 'f': <function function at 0xb76eed14>}
# Method called
c.function()
# Locals in wrapper   {'self': <__main__.C instance at 0xb76f1aec>, 'args': (), 'f': <function function at 0xb76eed14>}

d = C()
d.function()
# Locals in wrapper   {'self': <__main__.C instance at 0xb76f1bcc>, 'args': (), 'f': <function function at 0xb76eed14>}
# Method called
d.function()
# Locals in wrapper   {'self': <__main__.C instance at 0xb76f1bcc>, 'args': (), 'f': <function function at 0xb76eed14>}

编辑：摆脱if声明：

def decorator():
    print('Locals in decorator %s  ' % locals())
    def wrap(f):
        def rest(self,*args):
            print('Locals in wrapper   %s' % locals())
            return f
        def first(self,*args):
            print('Locals in wrapper   %s' % locals())            
            self.instance_method()
            setattr(self.__class__,f.func_name,rest)
            return f
        return first
    return wrap

class C:
    def instance_method(self): print('Method called')
    @decorator()
    def function(self):
      pass