在Python中，如何将公共对象传递给不同的模块文件

Question

我有各种各样的模块文件，并希望与每个模块共享一个公共对象（在本例中是logger）。最好的方法是什么？我有一个解决办法，但感觉不太对劲。你知道吗

在伪代码中：

module_1.py

global logger

# module_1

def pass_logger_module1(plogger):
    global logger
    logger = plogger

module_2.py

global logger

# module_2

def pass_logger_module2(plogger):
    global logger
    logger = plogger

main_module.py

from module_1 import pass_logger_module1
from module_2 import pass_logger_module2

logger = set_logger(logfile, logformat, 'DEBUG')

pass_logger_module1(logger)
pass_logger_module2(logger)

Answer 1

首先，在custom_logger.py中定义自定义记录器

import logging
import sys


class CustomFormatter(logging.Formatter):
    err_fmt  = "[*] ERROR: %(msg)s"
    dbg_fmt  = "[-] DEBUG: %(module)s: %(lineno)d: %(msg)s"
    info_fmt = "[+] %(msg)s"

    def __init__(self):
        super().__init__(fmt="%(levelno)d: %(msg)s", datefmt=None, style='%')

    def format(self, record):
        # Save the original format configured by the user
        # when the logger formatter was instantiated
        format_orig = self._style._fmt

        # Replace the original format with one customized by logging level
        if record.levelno == logging.DEBUG:
            self._style._fmt = CustomFormatter.dbg_fmt

        elif record.levelno == logging.INFO:
            self._style._fmt = CustomFormatter.info_fmt

        elif record.levelno == logging.ERROR:
            self._style._fmt = CustomFormatter.err_fmt

        # Call the original formatter class to do the grunt work
        result = logging.Formatter.format(self, record)

        # Restore the original format configured by the user
        self._style._fmt = format_orig

        return result


class CustomLogger(logging.Logger):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        formatter = CustomFormatter()
        handler = logging.StreamHandler(sys.stdout)
        handler.setFormatter(formatter)
        self.addHandler(handler)
        self.setLevel(logging.INFO)

然后，在其他模块中，导入CustomLogger。你知道吗

from custom_logger import CustomLogger


logger = CustomLogger(__name__)

logger.debug("Hello, world!")

Answer 2

一种方法是通过第三个模块公开共享对象，如下所示：

我的_记录器.py你知道吗

logger = set_logger(logfile, logformat, 'DEBUG')

模块1.py

from my_logger import logger
...

模块2.py

from my_logger import logger
...

然后，您的主模块可以同时导入模块\u 1和模块\u 2，而不必了解记录器，并避免循环导入情况。你知道吗

Answer 3

正如在注释中指出的，这不是使用logging模块的方法。你知道吗

不过，对于“不同模块文件的公共对象”有一个更一般的答案 与你的例子相反，意思是：

main_module.py

# this is in global
logger = set_logger(logfile, logformat, 'DEBUG')

module_1.py

from main_module import logger

module_2.py

from main_module import logger

编辑： 为了避免循环导入，可以将logger存储在不同的模块中：

settings.py

# this is in global
logger = set_logger(logfile, logformat, 'DEBUG')

main_module.py

from settings import logger