Question

在几乎没有静态函数的类中，我通常会像这样记录：

class ClassA:

    def __init__(self):
        self._logger = logging.getLogger(self.__class__.__name__)

    def do_something(self):
        self._logger.info("Doing something")

    def do_something_else(self):
        self._logger.info("Doing something else.")

在使用静态方法的类中，我一直这样做：

class ClassB:

    _logger = logging.getLogger("ClassB")

    @staticmethod
    def do_something():
        ClassB._logger.info("Doing something")

    @staticmethod
    def do_something_else():
        ClassB._logger.info("Doing something else")

你可以这样做，但似乎很蹩脚：

class ClassB:

    @staticmethod
    def do_something():
        logger = logging.getLogger("ClassB")
        logger.info("Doing something")

    @staticmethod
    def do_something_else():
        logger = logging.getLogger("ClassB")
        logger.info("Doing something else")

是否有更好的静态方法记录模式？

Answer 1

您可以将它们转换为类方法。

class ClassB(object):
    _logger = logging.getLogger("ClassB")

    @classmethod
    def do_something(cls):
         cls._logger.info("Doing something")

但请注意，当您从ClassB派生并调用do_something时，它会获得一个不同的记录器，因为cls表示派生类而不是ClassB。

Answer 2

这几乎耗尽了你的选择。毕竟，静态方法只能访问三个范围：方法范围，类范围和模块范围。如果你想让记录器名称与类名相匹配，那么每个类至少需要一个记录器，所以当你将它们存储在类范围内时，将它们存储在模块范围内是没有意义的。（正如你的第二个例子那样）。

就个人而言，我通常每个模块使用一个记录器。但是如果我在做个别类记录器，我可能会使用你的模式＃2，每个类中都有一个_logger变量。这对我来说似乎是最干净的。

Answer 3

答案派对迟到了，但又想补充一点。

如果你有一个更复杂的记录器初始化（要记录的init文件路径等），那么你可以通过在类之外创建logger_init来实现。

def init_logger():
    logger = logging.getLogger('general_logger')
    # do other logger setup like
    # setup logger handlers,
    # set formatters,
    # set logging levels, etc
    return logger

然后，从静态类

初始化您的记录器

 class MyClass(object):
     _logger = init_logger()

     @classmethod
     def do_something(cls):
         cls._logger.info("doing something")

快乐的伐木！

从静态方法记录

3 个答案: