你的核心问题是业务逻辑和日志逻辑耦合太紧密，导致A类里充斥着冗余的if self.log判断。咱们可以通过解耦和依赖注入的思路来重构，同时保证日志系统的可定制性，下面分几个方案一步步来：

方案1：解耦日志生成与存储（简单直接） #

先把A类的职责收窄：只负责执行业务逻辑，生成日志消息，不处理日志的存储和开关判断。日志的收集由B类来负责，这样A类里就不用写那些判断了。

重构后的代码：

def do_things():
    # 你的业务逻辑实现
    pass

def save_to_file(content, filename="log.txt"):
    with open(filename, "w") as f:
        f.write("\n".join(content))

class A:
    def __init__(self, enable_logging=True):
        self.enable_logging = enable_logging
    
    def __call__(self):
        do_things()
        # 只在需要时返回日志消息，不用在业务逻辑里加判断
        return "I did things" if self.enable_logging else None

class B:
    def __init__(self):
        self.a = A(enable_logging=True)
        self.log_master = []
    
    def __call__(self, num):
        for i in range(num):
            log_msg = self.a()
            # 只在B里做一次判断，把日志消息加入收集器
            if log_msg:
                self.log_master.append(log_msg)
            self.log_master.append("other things")
        save_to_file(self.log_master)

这个方案的好处是A类代码干净了，所有日志相关的判断和收集都集中在B类，逻辑更清晰。

方案2：依赖注入日志记录器（可定制性更强） #

如果以后需要扩展日志的方式（比如输出到控制台、数据库，或者不同的日志格式），可以用依赖注入的方式，给A类传入一个日志记录器对象，A只需要调用记录器的方法，不用关心具体实现。

首先定义一个基础的日志记录器接口，再实现不同的子类：

# 空记录器：当不需要日志时使用，替代if判断
class NullLogger:
    def log(self, message):
        pass

# 内存记录器：把日志存在列表里，适合B类收集
class ListLogger:
    def __init__(self):
        self.entries = []
    
    def log(self, message):
        self.entries.append(message)

# 业务类A：完全和日志实现解耦
class A:
    def __init__(self, logger=None):
        # 默认用空记录器，避免空指针
        self.logger = logger or NullLogger()
    
    def __call__(self):
        do_things()
        # 直接调用记录器，不用任何判断
        self.logger.log("I did things")

# 协调类B：负责配置日志和收集内容
class B:
    def __init__(self):
        self.logger = ListLogger()
        # 把日志记录器注入A
        self.a = A(logger=self.logger)
        self.log_master = []
    
    def __call__(self, num):
        for i in range(num):
            self.a()
            # 取出A本次调用的日志（如果需要每次单独取，可以调整ListLogger支持单次获取）
            # 这里假设每次调用A会生成一条日志，直接取最后一条
            if self.logger.entries:
                self.log_master.append(self.logger.entries.pop())
            self.log_master.append("other things")
        save_to_file(self.log_master)

这种方式的优势是可扩展性极强：如果以后要把日志输出到文件，只需要写一个FileLogger类，注入给A就行，完全不用修改A和B的业务逻辑。

方案3：使用Python标准库logging（工业级规范） #

如果你的项目需要更专业的日志功能（比如日志级别、多目标输出、格式化、日志轮转等），直接用Python自带的logging模块是最佳选择，它已经帮你封装好了所有复杂逻辑。

示例代码：

import logging

# 先配置全局日志基础设置
logging.basicConfig(level=logging.INFO)

def do_things():
    pass

class A:
    def __init__(self):
        # 获取A类专属的日志记录器
        self.logger = logging.getLogger(__name__ + ".A")
    
    def __call__(self):
        do_things()
        # 直接记录日志，不用判断
        self.logger.info("I did things")

class B:
    def __init__(self):
        self.a = A()
        self.log_master = []
        
        # 自定义一个内存日志处理器，把日志消息收集到log_master
        class MemoryHandler(logging.Handler):
            def emit(self, record):
                # 格式化日志消息（这里只保留原始消息）
                msg = self.format(record)
                self.log_master.append(msg)
        
        # 配置处理器的格式
        self.memory_handler = MemoryHandler()
        self.memory_handler.setFormatter(logging.Formatter("%(message)s"))
        # 把处理器添加到A的日志记录器
        self.a.logger.addHandler(self.memory_handler)
    
    def __call__(self, num):
        for i in range(num):
            self.a()
            self.log_master.append("other things")
        
        # 保存到文件
        with open("log.txt", "w") as f:
            f.write("\n".join(self.log_master))

logging模块支持的功能非常多：你可以设置不同的日志级别（DEBUG/INFO/WARNING等）、同时输出到控制台和文件、自动轮转日志文件、添加时间戳等，完全满足生产环境的需求。

总结最佳实践 #

1. 解耦职责：业务类（A）只负责业务逻辑和生成日志消息，日志的存储、判断、输出交给专门的日志组件；
2. 空对象模式：用NullLogger替代重复的if判断，让代码更简洁；
3. 依赖注入：通过传入日志记录器，让日志系统可以灵活替换实现；
4. 优先用标准库：logging模块是Python生态的标准日志方案，稳定性和扩展性都远优于自己实现。

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