Python对象实例与模块间通信问题：多实例互访如何实现？

兄弟，你这个问题太典型了！我当初做GUI+后台逻辑的项目时也卡在这里好久，完全不用自责——这种双向依赖的场景本来就很容易让人挠头，尤其是刚从单向调用的思路转过来的时候。

本质上你遇到的是模块/类之间的双向耦合问题，核心解法就是把“直接持有实例调用”改成“间接交互”，下面给你几个实用的方案，按推荐度从高到低排序：

这个思路的核心是：所有类都不直接持有彼此的实例，而是通过一个事件总线来发送和监听事件。比如：

• Gui需要发网络请求时，给事件总线发一个send_network_request事件并带上参数
• Net类提前在事件总线上监听这个事件，收到后执行实际的网络操作
• Net拿到数据后，发一个network_data_received事件并带上数据
• Process类监听这个事件，处理数据后发data_processed事件
• Gui监听data_processed事件，更新UI展示结果

这样每个类只和事件总线打交道，完全不用关心其他类的存在，依赖关系瞬间清晰。给你写个极简的Python示例：

class EventBus:
    def __init__(self):
        self._listeners = {}  # 键：事件名，值：回调函数列表

    def subscribe(self, event_name, callback):
        if event_name not in self._listeners:
            self._listeners[event_name] = []
        self._listeners[event_name].append(callback)

    def publish(self, event_name, *args, **kwargs):
        for callback in self._listeners.get(event_name, []):
            callback(*args, **kwargs)

# 初始化事件总线
bus = EventBus()

class Gui:
    def __init__(self, bus):
        self.bus = bus
        # 监听数据处理完成事件
        self.bus.subscribe("data_processed", self.update_ui)

    def send_request(self, url):
        # 发布发送请求事件
        self.bus.publish("send_network_request", url)

    def update_ui(self, processed_data):
        print(f"UI更新：{processed_data}")

class Net:
    def __init__(self, bus):
        self.bus = bus
        # 监听发送请求事件
        self.bus.subscribe("send_network_request", self.fetch_data)

    def fetch_data(self, url):
        # 模拟网络请求
        raw_data = f"从{url}获取的原始数据"
        # 发布数据接收事件
        self.bus.publish("network_data_received", raw_data)

class Process:
    def __init__(self, bus):
        self.bus = bus
        # 监听数据接收事件
        self.bus.subscribe("network_data_received", self.process_data)

    def process_data(self, raw_data):
        processed_data = raw_data + "【已处理】"
        # 发布数据处理完成事件
        self.bus.publish("data_processed", processed_data)

# 初始化各个实例
gui = Gui(bus)
net = Net(bus)
process = Process(bus)

# 测试：Gui触发请求
gui.send_request("https://example.com")

这种方式扩展性极强，后面加新的类（比如日志模块），只需要让它监听对应的事件就行，完全不用改现有代码。

你觉得手动传实例不规范，其实是没把它做“规范”。依赖注入的核心就是显式地传递依赖，而不是让类自己去创建或者隐式导入依赖。

正确的做法是：先创建所有需要的实例，然后把每个类需要的依赖主动传进去。比如：

class Gui:
    def __init__(self, net_instance, process_instance):
        self.net = net_instance
        self.process = process_instance

    def show_message(self, msg):
        print(f"GUI提示：{msg}")

class Net:
    def __init__(self, gui_instance):
        self.gui = gui_instance

    def send_data(self, data):
        print(f"Net发送数据：{data}")
        self.gui.show_message("数据已发送")

class Process:
    def __init__(self, gui_instance):
        self.gui = gui_instance

    def handle_data(self, raw_data):
        processed = raw_data.upper()
        self.gui.show_message("数据处理完成")
        return processed

# 初始化顺序很重要：先创建Gui（先给临时None，后面补全）
gui = Gui(None, None)
# 再创建Net和Process，把Gui传进去
net = Net(gui)
process = Process(gui)
# 最后把Net和Process实例补回Gui
gui.net = net
gui.process = process

# 测试
gui.net.send_data("hello")
gui.process.handle_data("world")

这种方式的好处是依赖关系完全透明，看每个类的__init__就知道它需要什么，调试和测试都很方便（比如测试时可以传一个模拟的Gui实例）。如果觉得初始化代码有点绕，可以写个工厂函数封装：

def create_app():
    gui = Gui(None, None)
    net = Net(gui)
    process = Process(gui)
    gui.net = net
    gui.process = process
    return gui

app = create_app()

如果你的项目很小，不想搞复杂的事件总线或者依赖注入，可以用一个全局的单例容器来存储所有核心实例。各个类需要的时候直接从容器里取就行：

class AppContext:
    _instance = None

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
            # 初始化空的实例引用
            cls._instance.gui = None
            cls._instance.net = None
            cls._instance.process = None
        return cls._instance

# 初始化全局上下文
ctx = AppContext()
ctx.gui = Gui()
ctx.net = Net()
ctx.process = Process()

# 在Net类里调用Gui方法：
class Net:
    def receive_data(self):
        ctx.gui.show_message("收到网络数据")

这种方式最简单，但缺点也很明显：全局变量会让依赖关系变得隐蔽，测试时很难替换实例，大项目用久了容易变成“面条代码”，所以只推荐小项目用。

其实和类的问题思路一致：

• 尽量避免子模块直接导入父模块，而是通过依赖注入把父模块的函数/实例传给子模块
• 或者用事件总线作为中间层，子模块发布事件，父模块监听，反之亦然
• 绝对不要用全量导入（比如from .. import *），会导致依赖关系混乱，还容易出现循环导入问题

举个模块的例子：

# 父模块 app.py
from event_bus import bus
from child_modules import net_module

def handle_net_event(data):
    print(f"父模块处理数据：{data}")

# 父模块订阅子模块的事件
bus.subscribe("net_data_received", handle_net_event)

# 子模块 net_module.py
from event_bus import bus

def fetch_data():
    data = "子模块获取的数据"
    # 发布事件，父模块会监听
    bus.publish("net_data_received", data)

这样子模块完全不用知道父模块的存在，只需要和事件总线交互，完美解耦。

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