Python 3.x 两个文件之间变量x的循环增量，步长=1

如何在两个文件“a.py”和“b.py”之间通过step=1运行变量x的循环增量（python 3.8）？初始x=0英寸“a.py”；如果“b.py”（或“a.py”）执行另一个文件，则x变为x=1（第一个增量），然后当“a.py”（或“b.py”）运行另一个文件时，x变为x=2（第二个增量），依此类推，直到x=10

我已尝试过此（不成功）尝试：

b、 派克

a、 派克

你问的是

但是你需要重新设计你的应用程序。不是两个不同的文件a.py和b.py，而是需要一个结合了这两个文件的主文件：

from multiprocessing import Process, Manager

def a_worker(shared_var, *args):
    print("A", shared_var.value, args)
    shared_var.value += 1

def b_worker(shared_var, *args):
    print("B", shared_var.value, args)
    shared_var.value += 1

if __name__ == "__main__":
    manager = Manager()
    var = manager.Value('i', 0) # shared variable

    print("Initial value: ", var.value)

    a_proc = Process(target=a_worker, args=(var, "a_args"))
    b_proc = Process(target=b_worker, args=(var, "b_args"))

    # Spawn processes
    a_proc.start() 
    b_proc.start()

    # Wait for processes to terminate
    a_proc.join()
    b_proc.join()

    print("After a & b finished: ", var.value)

这里

a\u-worker

和

b\u-worker

是实现

a.py

和

b.py

业务逻辑的函数。有关更多详细信息，请参阅

更新

乒乓球策略。处理A增量，然后处理B增量，然后处理A增量，然后。。。直到共享变量达到10：

from multiprocessing import Process, Manager, Pipe

def a_worker(shared_var, pipe):
    while shared_var.value < 10:
        print("A", shared_var.value)
        shared_var.value += 1
        pipe.send("Your turn")
        pipe.recv()
    pipe.close()

def b_worker(shared_var, pipe):
    while shared_var.value < 10:
        pipe.recv()
        print("B", shared_var.value)
        shared_var.value += 1
        pipe.send("Your turn")
    pipe.close()

if __name__ == "__main__":
    manager = Manager()
    var = manager.Value('i', 0) # shared variable
    a_conn, b_conn = Pipe()

    print("Initial value: ", var.value)

    a_proc = Process(target=a_worker, args=(var, a_conn))
    b_proc = Process(target=b_worker, args=(var, b_conn))

    # Spawn processes
    a_proc.start() 
    b_proc.start()

    # Wait for processes to terminate
    a_proc.join()
    b_proc.join()

    print("After a & b finished: ", var.value)

来自多处理导入进程、管理器、管道的

def a_worker（共享_变量，管道）：
当共享变量值<10时：
打印（“A”，共享变量值）
共享变量值+=1
管道发送（“轮到你了”）
pipe.recv（）
管道关闭
def b_worker（共享_变量，管道）：
当共享变量值<10时：
pipe.recv（）
打印（“B”，共享变量值）
共享变量值+=1
管道发送（“轮到你了”）
管道关闭
如果名称=“\uuuuu main\uuuuuuuu”：
经理=经理（）
var=manager.Value（'i'，0）#共享变量
a_conn，b_conn=管道（）
打印（“初始值：”，变量值）
a_proc=Process（target=a_worker，args=（var，a_conn））
b_proc=Process（target=b_worker，args=（var，b_conn））
#繁殖过程
a_proc.start（）
b_过程开始（）
#等待进程终止
a_proc.join（）
b_proc.join（）
打印（“a&b完成后：”，变量值）

---

这个程序使用管道来协调A和B。进程A启动，做一些事情，然后将控制传递给B，并等待它返回。进程B开始等待A，从A接收消息，增加变量并将控件传递回。

exec（open（“A.py”）.read（）

您真的不应该这样做。我使你的代码极易受到攻击。谢谢你的建议。但是在你的程序中，x只从n增加到n+2。对。这只是一个基本的例子。通过使用管道在a和B之间来回传递控制，对其进行了一点扩展。

from multiprocessing import Process, Manager

def a_worker(shared_var, *args):
    print("A", shared_var.value, args)
    shared_var.value += 1

def b_worker(shared_var, *args):
    print("B", shared_var.value, args)
    shared_var.value += 1

if __name__ == "__main__":
    manager = Manager()
    var = manager.Value('i', 0) # shared variable

    print("Initial value: ", var.value)

    a_proc = Process(target=a_worker, args=(var, "a_args"))
    b_proc = Process(target=b_worker, args=(var, "b_args"))

    # Spawn processes
    a_proc.start() 
    b_proc.start()

    # Wait for processes to terminate
    a_proc.join()
    b_proc.join()

    print("After a & b finished: ", var.value)

from multiprocessing import Process, Manager, Pipe

def a_worker(shared_var, pipe):
    while shared_var.value < 10:
        print("A", shared_var.value)
        shared_var.value += 1
        pipe.send("Your turn")
        pipe.recv()
    pipe.close()

def b_worker(shared_var, pipe):
    while shared_var.value < 10:
        pipe.recv()
        print("B", shared_var.value)
        shared_var.value += 1
        pipe.send("Your turn")
    pipe.close()

if __name__ == "__main__":
    manager = Manager()
    var = manager.Value('i', 0) # shared variable
    a_conn, b_conn = Pipe()

    print("Initial value: ", var.value)

    a_proc = Process(target=a_worker, args=(var, a_conn))
    b_proc = Process(target=b_worker, args=(var, b_conn))

    # Spawn processes
    a_proc.start() 
    b_proc.start()

    # Wait for processes to terminate
    a_proc.join()
    b_proc.join()

    print("After a & b finished: ", var.value)