Question

我试图在课堂上装饰所有方法，但我在这段代码中取得了成功，但我也尝试将调用记录到像* + - /这样的运算符，有没有办法来装饰它们或者像getattr(self,"*")之类的东西来记录电话？

class Logger(object):
  def __init__(self, bool):
      self.bool = bool

  def __call__(self, cls):
      class DecoratedClass(cls):
          def __init__(cls, *args, **kwargs):
              super().__init__(*args, **kwargs)

              if not(self.bool):
                  return
              methods = [func for func in dir(cls)
                      if callable(getattr(cls, func))
                      and not func.startswith("__class")]
              for func in methods:
                  old_func = getattr(cls, func)
                  def decorated_function(fname, fn):
                      def loggedFunction(*args, **kwargs):
                          print("Calling {0} from {3} with params {1} and kwargs {2}".format(fname.upper(), args, kwargs, cls))
                          return fn(*args, **kwargs)
                      return loggedFunction
                  setattr(cls, func, decorated_function(func, old_func))

      return DecoratedClass

@Logger(True)
class DummyClass():
  def __init__(self,foo):
      self.foo = foo
  def bar(self):
      print(self.foo)
  def __mul__(self,other):
      print("Hello",other)
if __name__ == '__main__':
  a = DummyClass('hola')
  a.method()
  a.__mul__(a) #this is logged 
  print(a*a) #this is not logged by decorator

Answer 1

目前，您正在修补实例上的值。您在cls签名中对__init__的使用是假的朋友 - 在这种情况下，实际上它是旧的self。

如果要覆盖魔术方法，解释器会在类对象上查找，而不是在实例上。

最小例子：

class DummyClass: def __init__(self, foo): self.foo = foo def __mul__(self, other): return self.foo * other.foo def logged(method): def wrapper(*args, **kwargs): print (method.__name__, args, kwargs) return method(*args, **kwargs) return wrapper DummyClass.__mul__ = logged(DummyClass.__mul__) a = DummyClass(1) b = DummyClass(2) assert a * a == 1 assert a * b == 2 assert b * b == 4

记录每次通话。

>>> a = DummyClass(1) >>> b = DummyClass(2) >>> assert a * a == 1 __mul__ (<__main__.DummyClass object at 0x00000000011BFEB8>, <__main__.DummyClass object at 0x00000000011BFEB8>) {} >>> assert a * b == 2 __mul__ (<__main__.DummyClass object at 0x00000000011BFEB8>, <__main__.DummyClass object at 0x00000000011BF080>) {} >>> assert b * b == 4 __mul__ (<__main__.DummyClass object at 0x00000000011BF080>, <__main__.DummyClass object at 0x00000000011BF080>) {}

我会给你一个重写猴子修补方法的任务。

Answer 2

感谢Łukasz，这是一个有效的脚本。

我遇到的一个难点是处理多个实例并避免多次装饰相同的类方法。为了解决这个问题，我会跟踪修饰的类方法（cls.__logged）。

另一个难点是处理像__setattr__，__getattribute__，__repr__这样的神奇方法，...我的解决方案是忽略它们，除了你必须定义的列表开始（loggable_magic_methods）。

from functools import wraps


loggable_magic_methods = ['__mul__',]


def is_magic_method(method):
    return method.startswith('__')


class Logger(object):
    def __init__(self, bool):
      self.bool = bool

    def __call__(self, cls):

        class LoggedClass(cls):
            cls.__logged = []
            def __init__(instance, *args, **kwargs):
                super().__init__(*args, **kwargs)

                if not(self.bool):
                    return

                methods = [funcname for funcname in dir(instance)
                           if callable(getattr(instance, funcname))
                           and (funcname in loggable_magic_methods or not is_magic_method(funcname))]

                def logged(method):
                    @wraps(method)
                    def wrapper(*args, **kwargs):
                        print (method.__name__, args, kwargs, cls)
                        return method(*args, **kwargs)
                    return wrapper

                for funcname in methods:
                    if funcname in cls.__logged:
                        continue

                    if is_magic_method(funcname):
                        setattr(cls, funcname, logged(getattr(cls, funcname)))
                        cls.__logged.append(funcname)
                    else:
                        setattr(instance, funcname, logged(getattr(instance, funcname)))
        return LoggedClass

@Logger(True)
class DummyClass():
    def __init__(self, foo, coef):
        self.foo = foo
        self.coef = coef
    def bar(self):
        print(self.foo)
    def __mul__(self, other):
        print(self.foo)
        print(other.foo)
        return self.coef * other.coef

if __name__ == '__main__':
    a = DummyClass('hola', 1)
    a.bar()
    print()
    print(a.__mul__(a))
    print()
    print(a*a)
    print()
    b = DummyClass('gracias', 2)
    b.bar()
    print()
    print(b.__mul__(a))
    print()
    print(b*a)

装饰运算符python3.5

2 个答案: