如何为Python中每个Client类实例分配独立日志器作为属性？

我正在编写一个分布式进程模拟库，包含一个中心实体和分散的客户端。每个客户端由通用的Client类实例表示，模拟期间每个实例独立存于内存，并有关联属性存储模拟数据。我需要为中心实体和每个Client实例区分不同的日志器。

目前的临时方案是将中心实体和Client类放在不同模块，在每个模块顶部从自定义工厂类导入不同日志器初始化，工厂类代码如下：

import logging

class Loggers:
    @staticmethod
    def central_logger():
        central_logger = logging.getLogger("central_logger")
        central_logger.setLevel(logging.DEBUG)
        formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
        ch = logging.StreamHandler()
        ch.setLevel(logging.DEBUG)
        ch.setFormatter(formatter)
        central_logger.addHandler(ch)
        central_logger.propagate = False
        return central_logger
    
    @staticmethod
    def client_logger():
        # 创建节点的顶级日志器
        client_logger = logging.getLogger("node_logger")
        client_logger.setLevel(logging.DEBUG)
        formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
        zh = logging.StreamHandler()
        zh.setLevel(logging.DEBUG)
        zh.setFormatter(formatter)
        client_logger.addHandler(zh)
        client_logger.propagate = False
        return client_logger

这种方式能区分中心和客户端日志器，但尝试将日志器作为Client类的属性初始化时（如下代码），每个客户端最终都会重置为默认的通用日志器，无法满足需求：

class Client:
    def __init__(self) -> None:
        self.logger = Loggers.client_logger(*可传入参数以个性化特定客户端的日志器*)

请问在上述场景下，有没有巧妙的方法将日志器作为类属性进行初始化？

方法1：为每个客户端创建子日志器 #

利用Python logging模块的层级特性，给每个Client实例创建专属的子日志器，继承父日志器node_logger的配置，同时保留自己的标识。这样既不用重复配置，又能区分不同客户端的日志：

修改工厂类的client_logger方法，支持传入客户端ID：

import logging

class Loggers:
    # 中心日志器代码不变，新增重复配置检查
    @staticmethod
    def central_logger():
        central_logger = logging.getLogger("central_logger")
        if not central_logger.handlers:  # 避免重复添加处理器导致日志重复输出
            central_logger.setLevel(logging.DEBUG)
            formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
            ch = logging.StreamHandler()
            ch.setLevel(logging.DEBUG)
            ch.setFormatter(formatter)
            central_logger.addHandler(ch)
            central_logger.propagate = False
        return central_logger
    
    @staticmethod
    def client_logger(client_id):
        # 先确保父日志器已完成基础配置
        parent_logger = logging.getLogger("node_logger")
        if not parent_logger.handlers:
            parent_logger.setLevel(logging.DEBUG)
            formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
            zh = logging.StreamHandler()
            zh.setLevel(logging.DEBUG)
            zh.setFormatter(formatter)
            parent_logger.addHandler(zh)
            parent_logger.propagate = False
        # 创建子日志器，名称格式为 node_logger.client_xxx，确保每个实例唯一
        return logging.getLogger(f"node_logger.client_{client_id}")

修改Client类的初始化逻辑，传入客户端ID：

class Client:
    def __init__(self, client_id) -> None:
        self.client_id = client_id
        self.logger = Loggers.client_logger(client_id)

这样每个客户端的日志器名称都是node_logger.client_xxx，日志输出会自动带上这个唯一名称，轻松区分不同客户端，同时继承父日志器的配置，无需重复设置处理器和格式。

方法2：将基础日志器设为类属性，动态绑定实例专属日志器 #

如果想把日志器相关配置作为类属性统一管理，同时让每个实例拥有个性化日志器，可以在类加载时完成基础日志器的配置，然后在实例初始化时创建专属子日志器：

import logging

class Client:
    # 类属性：所有实例共享的基础客户端日志器
    _base_client_logger = logging.getLogger("node_logger")
    
    @classmethod
    def __init_subclass__(cls) -> None:
        # 仅在类加载时配置一次基础日志器，避免重复添加处理器
        if not cls._base_client_logger.handlers:
            cls._base_client_logger.setLevel(logging.DEBUG)
            formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
            zh = logging.StreamHandler()
            zh.setLevel(logging.DEBUG)
            zh.setFormatter(formatter)
            cls._base_client_logger.addHandler(zh)
            cls._base_client_logger.propagate = False
    
    def __init__(self, client_id) -> None:
        self.client_id = client_id
        # 实例专属子日志器，自动继承基础日志器的配置
        self.logger = logging.getLogger(f"{self._base_client_logger.name}.client_{client_id}")

这种方式下，_base_client_logger作为类属性只会被配置一次，每个实例的logger是它的子日志器，既共享基础配置，又拥有唯一标识。

关键注意事项 #

• 必须检查日志器是否已有处理器，避免每次调用配置方法时重复添加，导致同一条日志被多次输出。
• 利用logging的父-子日志器层级结构，能大幅减少重复配置代码，同时实现日志的区分、过滤和统一管理。

内容的提问来源于stack exchange，提问作者Scolpe