Python多文件顺序调用时如何保留共享变量值？

问题场景 #

我在项目文件夹中包含4个Python文件：main.py、first.py、second.py、variables.py。仅运行main.py，它通过subprocess依次调用first.py和second.py，三个文件均导入variables.py。variables.py中仅声明了一个共享变量shared_variable，我期望first.py修改该变量后，main.py及后续调用的second.py能沿用修改后的值，但实际并未生效。

我的理解流程：

• first.py导入variables.py时，变量被初始化为初始值
• first.py修改该变量
• first.py执行结束返回main.py后，变量值恢复为初始值

想了解背后的内存存储、生命周期原理，以及可行的解决办法，目前考虑通过外部文本文件读写实现。

代码文件 #

main.py

import subprocess
import os
import variables

programs = ['first.py', 'second.py']
path=os.getcwd() + '\\running multiple py with shared variables\\'
for program in programs:
    subprocess.run(['python', path+program])
    print('running main.py')
    print(variables.shared_variable)

first.py

import variables
print('running first.py')
variables.shared_variable = 'First modification'
print(variables.shared_variable)

second.py

import variables
print('running second.py')
print(variables.shared_variable)

variables.py

shared_variable = "Initial value"

终端输出 #

running first.py
First modification
running main.py
Initial value                   -> 我希望这里是"First modification"
running second.py
Initial value                   -> 我希望这里是"First modification"
running main.py
Initial value                   -> 这里我不太在意，但本来以为会是"First modification"

背后的核心原理 #

进程的完全独立性 #

使用subprocess.run()调用first.py和second.py时，这两个文件会被操作系统启动为独立的Python进程，与main.py所在进程完全隔离。每个进程拥有专属的内存空间，包括独立的全局变量、导入模块的副本，进程间内存无法直接互通。

模块导入与变量生命周期 #

• 每个进程启动后，会独立执行模块导入流程：first.py导入variables.py时，会在自己的内存里创建shared_variable的副本，初始值为"Initial value"；main.py和second.py同理，各自持有独立的变量副本。
• first.py修改的只是自身进程内的变量副本，这个修改完全局限在first.py的内存中，和main.py的变量没有任何关联。
• 当first.py进程执行结束，操作系统会回收它的全部内存空间，修改后的变量值也随之销毁，main.py内的shared_variable自始至终都是它自己导入时的初始值。
• second.py启动时是全新进程，重新导入variables.py，自然拿到的是初始值。

可行的解决办法 #

由于进程间内存完全隔离，必须通过**进程间通信（IPC）**机制传递变量值，以下是几种常用方案：

1. 外部文件存储（你提到的方案） #

通过读写文本、JSON等外部文件实现变量共享，所有进程从同一文件读取最新值，修改后写入文件。

修改后的变量操作工具（可整合到variables.py）

import json

VAR_FILE = "shared_var.json"

def get_shared_variable():
    try:
        with open(VAR_FILE, 'r', encoding='utf-8') as f:
            data = json.load(f)
            return data.get('shared_variable', "Initial value")
    except FileNotFoundError:
        return "Initial value"

def set_shared_variable(value):
    with open(VAR_FILE, 'w', encoding='utf-8') as f:
        json.dump({'shared_variable': value}, f)

修改后的first.py

import variables
print('running first.py')
variables.set_shared_variable('First modification')
print(variables.get_shared_variable())

修改后的main.py（关键部分）

# 替换原print(variables.shared_variable)为：
print(variables.get_shared_variable())

修改后的second.py

import variables
print('running second.py')
print(variables.get_shared_variable())

2. 管道/环境变量传递 #

利用subprocess的标准输出捕获first.py的修改值，再通过环境变量或命令行参数传递给second.py。

修改first.py（输出变量值供主进程捕获）

import variables
print('running first.py')
variables.shared_variable = 'First modification'
print(variables.shared_variable)
# 额外输出变量值（单独一行，方便主进程提取）
print(variables.shared_variable)

修改main.py（捕获值并传递）

import subprocess
import os
import variables

programs = ['first.py', 'second.py']
path=os.getcwd() + '\\running multiple py with shared variables\\'
current_var = variables.shared_variable

for program in programs:
    if program == 'first.py':
        # 捕获子进程输出
        result = subprocess.run(['python', path+program], capture_output=True, text=True)
        print(result.stdout)
        # 提取最后一行的变量值
        current_var = result.stdout.strip().split('\n')[-1]
    else:
        # 通过环境变量传递给second.py
        env = os.environ.copy()
        env['SHARED_VAR'] = current_var
        result = subprocess.run(['python', path+program], env=env, capture_output=True, text=True)
        print(result.stdout)
    print('running main.py')
    print(current_var)

修改second.py（读取环境变量）

import os
import variables
print('running second.py')
# 优先读取环境变量，无则用默认值
shared_var = os.getenv('SHARED_VAR', variables.shared_variable)
print(shared_var)

3. 共享内存（高频场景首选） #

如果改用multiprocessing模块启动子进程，可以直接使用共享内存对象（Value/Array），实现高效的进程间变量共享。

示例代码（整合逻辑到main.py）

from multiprocessing import Process, Value
import os

def run_first(shared_var):
    print('running first.py')
    # 用字节串存储字符串，或使用String类型
    shared_var.value = b'First modification'
    print(shared_var.value.decode())

def run_second(shared_var):
    print('running second.py')
    print(shared_var.value.decode())

if __name__ == '__main__':
    # 创建共享变量，类型为字节串（c_char_p）
    shared_var = Value('c', b"Initial value")
    # 启动第一个子进程
    p1 = Process(target=run_first, args=(shared_var,))
    p1.start()
    p1.join()
    print('running main.py')
    print(shared_var.value.decode())
    
    # 启动第二个子进程
    p2 = Process(target=run_second, args=(shared_var,))
    p2.start()
    p2.join()
    print('running main.py')
    print(shared_var.value.decode())

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