Python while循环是否有一个变体，在发生更改之前只运行一次子句？

关于标题，很抱歉，这是一个有点难以表达的问题。我正在使用Python。基本上，我希望程序无限期地检查变量。例如，如果变量超过100，我希望代码块A只运行一次，，然后我希望程序不做任何操作，直到变量回到100以下，然后运行代码块B，再次等待，直到变量回到100以上，然后再次运行块A，然后重复

我编写的当前设置如下所示：

while on = True:
    if value_ind >= 100:
        open_time = time()
    else: 
        close_time = time()
        calculate_time_open(open_time, close_time)

---

这里明显的问题是，无论哪个if/else代码块为true，它都会无限期地自行运行，并在我的列表中仅为一个事件创建多个条目。那么，如何让代码块只运行一次，然后等待更改，而不是在等待更改时不断重复？提前感谢。

您可以使用状态机：您的程序处于两种状态之一：“等待高/低值”，并且行为正常：

THRESHOLD = 100

waiting_for_high_value = True  # False means: waiting for low value

while True:  # Infinite loop (or "while on", if "on" is a changing variable)
    if waiting_for_high_value:
        if value_ind >= THRESHOLD:
            open_time = time()
            waiting_for_high_value = False
    else:  # Waiting for a low value:
        if value < THRESHOLD:
            close_time = time()
            calculate_time_open(open_time, close_time)
            waiting_for_high_value = True

THRESHOLD=100
等待高值=真#假表示：等待低值
while True:#无限循环（或“while on”，如果“on”是一个变化的变量）
如果等待\u高\u值：
如果值\u ind>=阈值：
打开时间=时间（）
正在等待\u高\u值=False
否则：#等待低值：
如果值<阈值：
关闭时间=时间（）
计算打开时间（打开时间、关闭时间）
正在等待\u高\u值=真

现在，您确实需要在循环过程中的某个地方更新测试值

value\u ind

。这最好通过局部变量来实现（而不是将全局变量更改为不可见的副作用）

---

PS：上面的答案可以推广到任意数量的状态，并且可以方便地添加一些必须在等待时连续执行的代码。不过，在您的特定情况下，您可以在两种状态之间切换，并且在等待更改时可能没有太多事情要做，因此Stefan Pochmann的回答也可能是合适的（除非它强制您在两个“等待”循环中复制代码）。

您可以使用状态机：您的程序处于两种状态之一：“等待高/低值”并适当地表现：

THRESHOLD = 100

waiting_for_high_value = True  # False means: waiting for low value

while True:  # Infinite loop (or "while on", if "on" is a changing variable)
    if waiting_for_high_value:
        if value_ind >= THRESHOLD:
            open_time = time()
            waiting_for_high_value = False
    else:  # Waiting for a low value:
        if value < THRESHOLD:
            close_time = time()
            calculate_time_open(open_time, close_time)
            waiting_for_high_value = True

THRESHOLD=100
等待高值=真#假表示：等待低值
while True:#无限循环（或“while on”，如果“on”是一个变化的变量）
如果等待\u高\u值：
如果值\u ind>=阈值：
打开时间=时间（）
正在等待\u高\u值=False
否则：#等待低值：
如果值<阈值：
关闭时间=时间（）
计算打开时间（打开时间、关闭时间）
正在等待\u高\u值=真

现在，您确实需要在循环过程中的某个地方更新测试值

value\u ind

。这最好通过局部变量来实现（而不是将全局变量更改为不可见的副作用）

---

PS：上面的答案可以推广到任意数量的状态，并且可以方便地添加一些必须在等待时连续执行的代码。不过，在您的特定情况下，您可以在两种状态之间切换，并且在等待更改时可能没有太多事情要做，因此Stefan Pochmann的回答也可能是合适的（除非它强制您在两个“等待”循环中复制代码）。

您可以使用状态机：您的程序处于两种状态之一：“等待高/低值”并适当地表现：

THRESHOLD = 100

waiting_for_high_value = True  # False means: waiting for low value

while True:  # Infinite loop (or "while on", if "on" is a changing variable)
    if waiting_for_high_value:
        if value_ind >= THRESHOLD:
            open_time = time()
            waiting_for_high_value = False
    else:  # Waiting for a low value:
        if value < THRESHOLD:
            close_time = time()
            calculate_time_open(open_time, close_time)
            waiting_for_high_value = True

THRESHOLD=100
等待高值=真#假表示：等待低值
while True:#无限循环（或“while on”，如果“on”是一个变化的变量）
如果等待\u高\u值：
如果值\u ind>=阈值：
打开时间=时间（）
正在等待\u高\u值=False
否则：#等待低值：
如果值<阈值：
关闭时间=时间（）
计算打开时间（打开时间、关闭时间）
正在等待\u高\u值=真

现在，您确实需要在循环过程中的某个地方更新测试值

value\u ind

。这最好通过局部变量来实现（而不是将全局变量更改为不可见的副作用）

---

PS：上面的答案可以推广到任意数量的状态，并且可以方便地添加一些必须在等待时连续执行的代码。不过，在您的特定情况下，您可以在两种状态之间切换，并且在等待更改时可能没有太多事情要做，因此Stefan Pochmann的回答也可能是合适的（除非它强制您在两个“等待”循环中复制代码）。

您可以使用状态机：您的程序处于两种状态之一：“等待高/低值”并适当地表现：

THRESHOLD = 100

waiting_for_high_value = True  # False means: waiting for low value

while True:  # Infinite loop (or "while on", if "on" is a changing variable)
    if waiting_for_high_value:
        if value_ind >= THRESHOLD:
            open_time = time()
            waiting_for_high_value = False
    else:  # Waiting for a low value:
        if value < THRESHOLD:
            close_time = time()
            calculate_time_open(open_time, close_time)
            waiting_for_high_value = True

THRESHOLD=100
等待高值=真#假表示：等待低值
while True:#无限循环（或“while on”，如果“on”是一个变化的变量）
如果等待\u高\u值：
如果值\u ind>=阈值：
打开时间=时间（）
正在等待\u高\u值=False
否则：#等待低值：
如果值<阈值：
关闭时间=时间（）
计算打开时间（打开时间、关闭时间）
正在等待\u高\u值=真

现在，您确实需要在循环过程中的某个地方更新测试值

value\u ind

。这最好通过局部变量来实现（而不是将全局变量更改为不可见的副作用）

PS：上面的答案可以推广到任意数量的状态，并且可以方便地添加一些必须在等待时连续执行的代码。不过，在您的特定情况下，您可以在两种状态之间切换，并且在等待更改时可能没有太多事情要做，因此Stefan Pochmann的回答也可能是合适的（除非它强制您在两个“等待”循环中复制代码）。

这怎么样

while True:

    # wait until the variable goes over 100, then do block A once
    while value_ind <= 100:
        pass
    <block A here>

    # wait until the variable goes below 100, then do block B once
    while value_ind => 100:
        pass
    <block B here>

这个怎么样

while True:

    # wait until the variable goes over 100, then do block A once
    while value_ind <= 100:
        pass
    <block A here>

    # wait until the variable goes below 100, then do block B once
    while value_ind => 100:
        pass
    <block B here>

H