访问 python 类装饰器中的类属性

Question

编辑：我找到了this method decorator，并且能够使用它来单独包装ClassA 和ClassB 的方法（省略__init__）。但是，我不想手动包装单个方法，而是只包装类。

我创建了自己的日志记录类 MyLogger，它继承了 logging.Logger。在这个类中，（除其他外）我有一个 FileHandler，它在其输出中打印记录器名称：

import logging

class MyLogger(logging.Logger):
    def __init__(self, name, path="output.log"):
        logging.Logger.__init__(self, name, logging.DEBUG)
        logpath = path

        fh = logging.FileHandler(logpath)
        fh.setLevel(logging.DEBUG)
        fh.setFormatter(logging.Formatter("%(name)s - %(message)s"))

        # stream handler omitted

        self.addHandler(fh)

我也有 ClassA 和 ClassB，它们都获得相同的 MyLogger 实例：

class ClassA(object):
    def __init__(self, mylogger):
        self.log = mylogger

    def fn1(self):
        self.log.debug("message1 from ClassA fn1")
        self.fn2()
        b = ClassB(self.log)
        b.fn1()
        self.log.debug("message2 from ClassA fn1")

    def fn2(self):
        self.log.debug("message1 from ClassA fn2")

    # many more functions

class ClassB(object):
    def __init__(self, mylogger):
        self.log = mylogger

    def fn1(self):
        self.log.debug("message1 from ClassB fn1")

    # many more functions

这是一个简单的“主”函数：

print "inside main"
log = MyLogger("main")
a = ClassA(log)
a.fn1()

因为正在传递 MyLogger 实例，所以我想确保每个函数正确打印日志名称（我只是使用类名）。所以我试图装饰每个类的所有方法，以便记住以前的日志名称，然后将日志名称设置为类的名称，运行方法，最后将日志名称设置回什么以前是。我正在使用来自here 的装饰器/描述符。为简洁起见，我只会发布我的更改。我重命名了装饰器 setlogger，在 descript 类的每个方法中添加了打印语句，并将make_bound 更改如下：

def make_bound(self, instance):
   print "in __BOUND__"
   @functools.wraps(self.f)
   def wrapper(*args, **kwargs):
       '''This documentation will disapear :)'''
       prev = instance.log.name
       print "about to wrap %s.%s, prev = %s" % (instance.__class__.__name__, self.f.__name__, prev)
       ret = self.f(instance, *args, **kwargs)
       instance.log.name = prev
       print "done wrapping %s.%s, now = %s" % (instance.__class__.__name__, self.f.__name__, prev)
       return ret
   # This instance does not need the descriptor anymore,
   # let it find the wrapper directly next time:
   setattr(instance, self.f.__name__, wrapper)
   return wrapper

如果我使用 setlogger 装饰器/描述符将单个方法包装在 ClassA 和 ClassB 中，它可以正常工作。但是，我想只包装这两个类。所以这是我的班级装饰器：

def setloggerforallmethods(cls):
    def decorate(*args, **kwargs):
        for name, m in inspect.getmembers(cls, inspect.ismethod):
            if name != "__init__":
                print "calling setattr on %s.%s" % (cls.__name__, name)
                setattr(cls, name, setlogger(m))
        return cls

    return decorate

如果我用 @setloggerforallmethods 包装 ClassA 和 ClassB，并运行 main 函数，输出如下：

inside main
calling setattr on ClassA.fn1
in __INIT__: f = fn1
calling setattr on ClassA.fn2
in __INIT__: f = fn2
in __GET__
in __UNBOUND__
Traceback (most recent call last):
  File "/ws/maleva-rcd/yacht/classa.py", line 23, in <module>
    a.fn1()
  File "/ws/maleva-rcd/yacht/yachtlogger.py", line 34, in wrapper
    self.f.__name__)
ValueError: zero length field name in format

我不明白为什么此时 fn1 未绑定。不是像a.fn1()那样绑定到a吗？

Answer 1

我认为您试图以错误的方式解决错误的问题。但我可以解释为什么你的代码没有做你想做的事情。

---

首先，在你的装饰器中，你这样做：

for name, fn in inspect.getmembers(cls, inspect.ismethod):
    if name != "__init__":
        print "calling setlogger on %s" % cls.__name__ + "." + name
        fn = setlogger(fn)

那没有效果。对于每个绑定方法fn，您创建一个包装函数，然后将局部变量fn 重新绑定到该函数。这并没有比这样做更有效：

def foo(a):
    a = 3
i = 0
foo(i)

如果你想在类上设置一个属性，你必须在类上设置一个属性，像这样：

setattr(cls, name, setlogger(fn))

现在你的包装器将被调用。

---

接下来，cls.log 是一个名为 log 的类属性，即类本身的属性，由该类的所有实例共享。但是类中的所有代码都使用 instance 属性，其中每个实例都有自己的副本。这就是您在 __init__ 中分配 self.log 时得到的结果。所以，没有名为log 的类属性，这意味着你只会得到这个：

AttributeError: type object 'ClassA' has no attribute 'log'

你当然可以创建一个类属性……但这不会有任何好处。同名的实例属性只会隐藏它。

您需要访问inner 中的实例属性，这意味着您需要一个self 才能访问它。而且您显然在setlogger 中没有self。但是想想你在做什么：你正在用另一种方法包装一个方法。方法将self 作为它们的第一个参数。事实上，如果你修改inner 以打印出它的args，你会看到第一个总是类似于<__main__.ClassA object at 0x12345678>。所以：

def inner(self, *args, **kwargs):
    prevname = self.log.name
    self.log.name = cls.__name__
    ret = func(self, *args, **kwargs) # don't forget to forward self
    self.log.name = prevname
    return ret

---

但是，如果这些包装方法中的任何一个引发异常，它们就会使名称处于错误状态。所以真的，你需要创建一个上下文管理器来存储和恢复值，或者只是一个try/finally。这也恰好使包装器更容易编写：

def inner(self, *args, **kwargs):
    prevname = self.log.name
    self.log.name = cls.__name__
    try:
        return func(self, *args, **kwargs)
    finally:
        self.log.name = prevname

---

最后，您需要删除每个__init__ 方法中的self.log.name =。否则，当您在 A.fn1 的中间构造 B 实例时，您将更改记录器的名称，而无需通过恢复先前名称的包装器。

---

同样，我认为这不是一个好的解决方案。但它会做你想做的事。

Answer 2

我仍然不完全理解您要解决的问题，但我认为是这样的：

构造MyLogger 需要两条信息：名称和路径。您不希望每个班级都必须知道该路径。所以，您认为您需要共享MyLogger 实例，因为没有其他办法。然后，因为 MyLogger 将其名称存储为属性，所以您必须在每个方法的包装器中破解该属性。

但是有一个更简单的方法可以解决这个问题：让您的类采用“记录器工厂”——即为它们构造适当记录器的可调用对象——而不是记录器。 MyLogger 类本身已经是这样一个可调用的，因为它采用path 的默认值，而您只需使用它。但是让我们假设这不是真的，并且您想使用一些非默认的path。还是很容易的；你只需要把它包起来：

class ClassA(object):
    def __init__(self, log_factory):
        self.log_factory = log_factory
        self.log = log_factory("ClassA")
    def fn1(self):
        # ...
        b = ClassB(self.log_factory)
        # ...

class ClassB(object):
    def __init__(self, log_factory):
        self.log_factory = log_factory
        self.log = log_factory("ClassB")
    # ...

# or just log_factory = functools.partial(MyLogger, log="output.log")
def log_factory(name):
    return MyLogger(name, "output.log")
a = ClassA(log_factory)
a.fn1()

您可能会注意到两个类中的__init__ 方法的作用相同。那么，为什么不将其提取到 mixin 基类中呢？

class LogUserMixin(object):
    def __init__(self, log_factory):
        self.log_factory = log_factory
        self.log = log_factory(self.__class__.__name__)

现在：

class ClassA(LogUserMixin):
    def fn1(self):
        # ...

当 ClassA 被初始化时，self.__class__ 将是 "ClassA"，而不是 "LogUserMixin"，所以这正是你想要的。即使您的真实类已经有基类或子类的层次结构，或者如果它们在__init__ 中做了额外的事情，或者采用额外的参数，它也可以工作；在某些情况下，您只需要多做一点工作。