Question

我想从两个python脚本test1.py中更改sensor_value的值：

from time import sleep 

class Sensor_value:
    def __init__(self):
        self.sensor_value = 1
    
    def __str__(self):
        return str(self.sensor_value)

    def change(self, val):
        assert isinstance(val, int)
        self.sensor_value = val

sensor_value = Sensor_value()

while True :
    sensor_value.change(sensor_value.sensor_value - 1)
    sleep(2)
    print("value = {} from test 1".format(sensor_value))

和test2.py

from test1 import sensor_value
from time import sleep 

while True :
    sensor_value.change(sensor_value.sensor_value + 1)
    sleep(3)
    print("value = {} from test 2".format(sensor_value))

当我运行test2.py时，代码卡在test1.py while循环中，而从不输入test2.py while循环

这是输出：

$ python test2.py
value = 0 from test 1
value = -1 from test 1
value = -2 from test 1
value = -3 from test 1

有人可以帮我吗

Answer 1

您必须修改test1.py脚本，必须在if语句下添加while循环以检查是否__name__ == "__main__"。

发生的事情是，无论何时导入test1模块，解释器都会执行test1模块。

例如，如果在test1模块中添加了一条打印语句，则在导入test1模块期间，它将执行test1模块的所有语句。

在这种情况下，在运行test2脚本时，解释器将卡在执行test1模块的while循环的test2模块的第一行。

from test1 import sensor_value

但是，如果您像下面那样修改test1代码：

from time import sleep 

class Sensor_value:
    def __init__(self):
        self.sensor_value = 1
    
    def __str__(self):
        return str(self.sensor_value)

    def change(self, val):
        assert isinstance(val, int)
        self.sensor_value = val

sensor_value = Sensor_value()
if __name__=='__main__': ### putting while loop under if statement.
    
    while True :
        sensor_value.change(sensor_value.sensor_value - 1)
        sleep(2)
        print("value = {} from test 1".format(sensor_value))

在这里，它将首先检查该模块是否为主模块，否则，如果该模块是从另一个模块导入的，则if语句将失败，并且将忽略test1模块的while循环。

Answer 2

您可以尝试使用threading或multiprocessing或其他方法来同时运行两个脚本，但这可能需要更多更改，并且可能使用queue从一个过程中发送值到另一个。简短地说：当两个函数/脚本访问同一变量时，可能会很复杂。

这就是为什么我更愿意重写第二个while True循环以在一个循环中运行所有代码的原因。

在第一个脚本中，我将使用if __name__ == '__main__':，以便在直接运行它而不是将其导入另一个脚本时运行它的循环。

test1.py

from time import sleep 

class Sensor_value:
    def __init__(self):
        self.sensor_value = 1
    
    def __str__(self):
        return str(self.sensor_value)

    def change(self, val):
        assert isinstance(val, int)
        self.sensor_value = val

sensor_value = Sensor_value()

if __name__ == '__main__': # don't run when imported to other script
    while True:
        sensor_value.change(sensor_value.sensor_value - 1)
        sleep(2)
        print("value = {} from test 1".format(sensor_value))

然后在几秒钟的脚本中，我将使用sleep(1)，并数秒以检查要执行的部分。

test2.py

from test1 import sensor_value
from time import sleep 

seconds = 0

while True:

    if seconds % 2 == 0: # every 2 seconds
        sensor_value.change(sensor_value.sensor_value - 1)
        print("value = {} from test 1".format(sensor_value))

    if seconds % 3 == 0: # every 3 seconds
        sensor_value.change(sensor_value.sensor_value + 1)
        print("value = {} from test 2".format(sensor_value))

    sleep(1)  # it needs to sleep only 1 second

    seconds += 1

对于线程，我会将代码放入函数中，以便稍后使用Thread()

运行它们

test1.py

from time import sleep 

class Sensor_value:
    def __init__(self):
        self.sensor_value = 1
    
    def __str__(self):
        return str(self.sensor_value)

    def change(self, val):
        assert isinstance(val, int)
        self.sensor_value = val

sensor_value = Sensor_value()

def run_test1():
    while True:
        sensor_value.change(sensor_value.sensor_value - 1)
        sleep(2)
        print("value = {} from test 1".format(sensor_value))

if __name__ == '__main__': # don't run when imported to other script
    run_test1()

然后在第二个脚本中启动两个线程

test2.py

from test1 import sensor_value, run_test1
from time import sleep 
import threading

def run_test2():
    while True:
        sensor_value.change(sensor_value.sensor_value + 1)
        sleep(3)
        print("value = {} from test 3".format(sensor_value))


# create threads - `target` needs only function name without `()`
t1 = threading.Thread(target=run_test1)  # Thread(target=run_test1, args=(arg1,arg2))
t2 = threading.Thread(target=run_test1)

# start threads
t1.start()
t2.start()

# ... other code ...

# wait for the end of threads
t1.join()
t2.join()

但是有时候threads可能无法正确更新相同的变量，并且可能需要一些额外的代码来锁定对变量的访问，或者使用queue将值发送到将对其进行更新的主线程。 / p>

有什么办法可以在python中的2个脚本中修改值？

2 个答案: