如何在独立执行的b.py中读取a.py的实时变量值？

你遇到的问题核心在于Python进程的内存隔离特性：

• 当你运行python a.py时，这是一个独立的Python进程，它的全局变量i只存在于这个进程的私有内存空间里。
• 当你单独运行python b.py并导入a模块时，Python会在b的进程中重新加载a.py的代码，创建一个全新的i实例——这个i和a进程里的i完全是两个毫不相关的变量，自然只能拿到初始值0。
• 用c.py中转也解决不了问题，因为每个进程都会加载自己的c模块实例，变量依然不共享。

下面是几种可行的实现方式，你可以根据场景选择：

1. 文件存储（最简单的轻量方案） #

通过将i的值写入文件，让b.py读取文件内容来获取实时值。

修改后的a.py #

#!/usr/bin/env python3
import time

i = 0

def run():
    global i
    print(i)
    i += 1
    # 将当前i值写入文件（覆盖式写入）
    with open('shared_i.txt', 'w') as f:
        f.write(str(i))

def get_i():
    global i
    return i

if __name__ == "__main__":
    while True:
        run()
        time.sleep(5)

修改后的b.py #

#!/usr/bin/env python3
try:
    # 读取文件中的i值
    with open('shared_i.txt', 'r') as f:
        current_i = f.read().strip()
    print(current_i)
except FileNotFoundError:
    # 如果文件不存在，返回初始值0
    print(0)

注意：如果有多个进程同时读写文件，建议加文件锁避免数据错乱。

2. Socket通信（适合进程间实时交互） #

让a.py启动一个简单的Socket服务器，b.py作为客户端连接后请求当前的i值。

修改后的a.py #

#!/usr/bin/env python3
import time
import socket
import threading

i = 0

def update_i():
    """后台线程持续更新i的值"""
    global i
    while True:
        print(i)
        i += 1
        time.sleep(5)

def handle_client(conn):
    """处理客户端的请求，返回当前i值"""
    global i
    conn.send(str(i).encode('utf-8'))
    conn.close()

if __name__ == "__main__":
    # 启动后台更新线程
    threading.Thread(target=update_i, daemon=True).start()
    
    # 启动Socket服务器
    host = 'localhost'
    port = 12345
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as server_socket:
        server_socket.bind((host, port))
        server_socket.listen()
        print(f"Socket server running on {host}:{port}")
        # 持续监听客户端连接
        while True:
            conn, addr = server_socket.accept()
            handle_client(conn)

修改后的b.py #

#!/usr/bin/env python3
import socket

host = 'localhost'
port = 12345

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as client_socket:
    client_socket.connect((host, port))
    # 接收服务器返回的i值
    data = client_socket.recv(1024)
    print(f"当前i值：{data.decode('utf-8')}")

3. 共享内存（适合高性能场景） #

使用Python的multiprocessing模块提供的共享内存对象，让多个进程直接访问同一块内存区域。这种方式性能更高，但实现稍复杂。

修改后的a.py #

#!/usr/bin/env python3
import time
from multiprocessing import Manager, Process

def update_shared_i(shared_i):
    """持续更新共享的i值"""
    while True:
        with shared_i.get_lock():  # 加锁避免并发修改冲突
            print(shared_i.value)
            shared_i.value += 1
        time.sleep(5)

if __name__ == "__main__":
    # 创建Manager，用于跨进程共享变量
    with Manager() as manager:
        # 创建一个共享的整数变量，初始值0
        shared_i = manager.Value('i', 0)
        # 启动更新进程
        update_process = Process(target=update_shared_i, args=(shared_i,))
        update_process.start()
        update_process.join()

修改后的b.py #

#!/usr/bin/env python3
from multiprocessing import Manager

# 提示：实际场景中需要让b.py连接到a.py启动的同一个Manager实例
# 可以将Manager的地址写入文件，让b.py读取后连接，这里简化演示
with Manager() as manager:
    shared_i = manager.Value('i', 0)
    print(f"当前i值：{shared_i.value}")

提示：共享内存方式适合对性能要求较高的场景，若只是简单的变量同步，文件或Socket方案更易实现。

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