咱们先拆解你当前代码的问题，再给你适配你场景的实用解决方案——毕竟跨进程共享变量和单进程里的全局变量完全不是一回事儿。

为什么你的代码没达到预期？ #

首先，你的globaltest.py里的statevar是函数内部的局部变量：每次调用varex()的时候，都会重新初始化statevar = 0。也就是说，stest.py调用varex(state)时，只是在函数里临时改了这个局部变量，函数执行完这个变量就被销毁了，根本没保存下来。

就算你把statevar改成模块级的全局变量（比如把它拿到函数外面，用global关键字引用），这在同一个进程里是有效的，但你的main_test.py和stest.py是两个独立的Python进程——每个进程启动时都会加载自己的globaltest.py副本，修改的只是各自进程里的变量，另一个进程完全看不到变化。这是Python进程内存隔离的特性决定的，每个进程都有自己独立的内存空间。

适合你场景的解决方案 #

你的需求是两个独立进程（数据采集主程序、Flask短信服务）共享状态，这时候必须用**进程间通信（IPC）**的方式。下面给几种从简单到复杂的方案，你可以根据自己的需求选：

方案1：文件存储（最简单，适合小数值） #

把状态值存在一个文本文件里，主程序定期读，短信服务程序更新文件内容。这种方式不需要任何额外依赖，实现起来特别快。

先写一个状态管理模块 state_manager.py：

import os

# 存储状态的文件路径
STATE_FILE = "./sensor_state.txt"

def init_state():
    # 首次运行时初始化文件，避免读取报错
    if not os.path.exists(STATE_FILE):
        with open(STATE_FILE, 'w') as f:
            f.write("0")

def get_state():
    # 读取当前状态
    with open(STATE_FILE, 'r') as f:
        return int(f.read().strip())

def set_state(value):
    # 更新状态
    with open(STATE_FILE, 'w') as f:
        f.write(str(value))

修改主程序 main_test.py：

from state_manager import init_state, get_state
from time import sleep

# 初始化状态文件
init_state()
while True:
    loc_var = get_state()
    print('local ', loc_var)
    sleep(3)

修改模拟服务 stest.py：

from state_manager import set_state
from time import sleep

i = 2
while True:
    set_state(i)
    print(f"已将状态设置为 {i}")
    i += 1
    sleep(1)

这个方案的优点是简单易上手，缺点是频繁读写文件可能有性能损耗，但你的场景里更新频率很低（短信触发），完全没问题。如果担心并发读写冲突，可以加个文件锁（比如用fcntl模块），不过你的场景大概率不需要。

方案2：共享内存（适合高频读写的数值） #

用Python自带的multiprocessing模块的Value来实现进程间共享内存。这种方式速度快，但只适合同一台机器上的进程，而且程序结束后共享内存会被释放（不持久化）。

状态管理模块 state_manager.py：

from multiprocessing import Value, Lock

# 用锁避免多个进程同时读写导致的冲突
state_lock = Lock()
# 定义一个共享的整数变量，'i'表示类型为整数
shared_state = Value('i', 0)

def get_state():
    with state_lock:
        return shared_state.value

def set_state(value):
    with state_lock:
        shared_state.value = value

主程序 main_test.py：

from state_manager import get_state
from time import sleep

while True:
    loc_var = get_state()
    print('local ', loc_var)
    sleep(3)

模拟服务 stest.py：

from state_manager import set_state
from time import sleep

i = 2
while True:
    set_state(i)
    print(f"已将状态设置为 {i}")
    i += 1
    sleep(1)

注意：运行这两个程序时，要确保它们在同一个Python环境里，而且共享内存只支持同一主机的进程。

方案3：SQLite数据库（适合持久化或复杂数据） #

如果你的状态需要持久化（比如程序重启后不丢失），或者以后可能扩展成更复杂的数据结构，用轻量级的SQLite数据库是个好选择——不需要单独启动数据库服务，文件形式存储，很方便。

状态管理模块 state_manager.py：

import sqlite3

# 数据库文件路径
DB_FILE = "./sensor_state.db"

def init_db():
    conn = sqlite3.connect(DB_FILE)
    cursor = conn.cursor()
    # 创建状态表
    cursor.execute('''CREATE TABLE IF NOT EXISTS sensor_state
                     (id INTEGER PRIMARY KEY, value INTEGER)''')
    # 初始化默认值
    cursor.execute("SELECT COUNT(*) FROM sensor_state WHERE id=1")
    if cursor.fetchone()[0] == 0:
        cursor.execute("INSERT INTO sensor_state VALUES (1, 0)")
    conn.commit()
    conn.close()

def get_state():
    conn = sqlite3.connect(DB_FILE)
    cursor = conn.cursor()
    cursor.execute("SELECT value FROM sensor_state WHERE id=1")
    result = cursor.fetchone()[0]
    conn.close()
    return result

def set_state(value):
    conn = sqlite3.connect(DB_FILE)
    cursor = conn.cursor()
    cursor.execute("UPDATE sensor_state SET value=? WHERE id=1", (value,))
    conn.commit()
    conn.close()

然后主程序和模拟服务的调用方式和方案1一样，先调用init_db()初始化数据库即可。

方案4：Redis（适合分布式或高并发场景） #

如果以后你的服务可能扩展到多台机器，或者需要更灵活的消息传递，可以用Redis作为中间件。需要先安装Redis服务，再安装Python的redis库：pip install redis

状态管理模块 state_manager.py：

import redis

# 连接本地Redis服务
redis_client = redis.Redis(host='localhost', port=6379, db=0)

def init_state():
    if not redis_client.exists('sensor_state'):
        redis_client.set('sensor_state', 0)

def get_state():
    return int(redis_client.get('sensor_state'))

def set_state(value):
    redis_client.set('sensor_state', value)

调用方式和前面的方案一致。

对你场景的推荐 #

你的场景是Flask+Twilio监听短信（更新频率低），主程序循环采集（读取频率中等），方案1或方案3是最适合的：

• 如果不需要持久化，方案1足够简单，零依赖；
• 如果需要程序重启后保留状态，方案3（SQLite）更合适，而且扩展性更好。

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