【Python】实现限时循环的学习笔记

songyuc2024-02-24 16:45

1 问题描述

今天我们在实现Emutouch时，有这样一个需求：我们希望在指定的时间内启动一个程序，如果超时就报错，类似于一种 "限时循环"的效果，理想的示例代码如下，

python 复制代码 
while Limited_time(10): # if timeout，`Limited_time` would throw an timeout error from inside
    # Here is the logic of checking if the program has started
    if start_success：
       break

2 学习咨询

2.1 GPT-4-32k

南溪：您好，我们今天在编程时遇到一个小问题，我们希望用循环来检查一个程序是否已经启动，并给定一定的时间限制，如果超时就报错，也就是说，是否可以使用python实现一种"限时循环"的效果，期望效果的示例代码如下，

python 复制代码 
while Limited_time(10): # if timeout，`Limited_time` would throw an timeout error from inside
    # Here is the logic of checking if the program has started
    if start_success：
       break

GPT-4-32k：你可以通过自定义一个带有超时功能的上下文管理器或者使用 time 模块来实现限时循环的效果。下面是一个简单的实现示例：

python 复制代码 
import time

class LimitedTime:
    def __init__(self, timeout):
        self.timeout = timeout
        self.start_time = None

    def __enter__(self):
        self.start_time = time.time()
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        pass

    def is_timeout(self):
        return time.time() - self.start_time > self.timeout

# 使用示例
try:
    with LimitedTime(10) as timer:
        while True:
            if timer.is_timeout():
                raise TimeoutError("Timeout waiting for the program to start.")
            
            # 这里是检查程序是否已经启动的逻辑
            start_success = False # 假设这里是检查程序是否启动的结果
            if start_success:
                print("Program started successfully.")
                break
            time.sleep(1)  # 避免CPU过度占用
except TimeoutError as e:
    print(e)

在上面的代码中，LimitedTime 类定义了一个上下文管理器，它记录了开始的时间，并在每次循环中检查是否超出了设定的时间限制。如果超时，它会抛出一个 TimeoutError。

请注意，在实际的代码实现中，你需要替换 # 这里是检查程序是否已经启动的逻辑 部分为你具体的逻辑代码，并根据实际情况设置合理的检查间隔（这里使用了 time.sleep(1) 作为示例）。

另外，TimeoutError 是一个内置的异常类型，可用于这种情况。如果你的环境中没有 TimeoutError，可以使用 Exception 或者自定义一个异常类型。

南溪：我感觉你给出的代码还是有点复杂，因为try:跟with limited_time(10): 会增加两行的缩进，是否可以实现成

python 复制代码 
while Limited_time(10): # if timeout，`Limited_time` would throw an timeout error from inside
    # Here is the logic of checking if the program has started
    if start_success：
       break

这种简单的形式呢？

GPT-4-32k：要实现类似于这样的简洁语法结构，可以定义一个生成器函数，它会在超时时抛出一个异常。请看下面的示例：

python 复制代码 
import time

class TimeoutError(Exception):
    pass

def limited_time(timeout):
    start_time = time.time()
    while True:
        if time.time() - start_time > timeout:
            raise TimeoutError("Operation timed out.")
        yield

# 使用示例
try:
    for _ in limited_time(10):
        # 这里是检查程序是否已经启动的逻辑
        start_success = False  # 假设这里是检查程序是否启动的结果
        if start_success:
            print("Program started successfully.")
            break
        time.sleep(1)  # 避免CPU过度占用
except TimeoutError as e:
    print(e)

在这个例子中，limited_time 函数是一个生成器，它会一直运行，直到超出指定的超时时间。在每次迭代时，它会检查是否已超时，一旦超时，则抛出TimeoutError异常。使用这个生成器的for循环就能够实现类似于你想要的"限时循环"的效果。

这种方式减少了代码的缩进层级，使得结构更为简洁。此外，limited_time生成器函数的设计使得它在其他地方也能复用，增加了代码的可维护性。

南溪： 可以看到这里的代码跟我们期望的还是不一样，这里是用for循环实现的。

南溪：我感觉你给出的代码还是有点复杂，我期望将这样的逻辑封装成一个Limited_time()的结构来直接调用，这里的"for _ in limited_time(10):"是否可以直接简化成"while Limited_time(10):"这样呢？

GPT-4-32k：为了实现 while Limited_time(10): 这样的简洁结构，我们可以定义一个函数，它返回一个可以在 while 循环中使用的对象。这个对象需要有一个方法来不断检查是否超时。这里，我们可以使用一个迭代器来实现这个效果。

以下是一个可能的实现：

python 复制代码 
import time

class TimeoutError(Exception):
    pass

class Limited_time:
    def __init__(self, timeout):
        self.timeout = timeout
        self.start_time = time.time()

    def __iter__(self):
        return self

    def __next__(self):
        if time.time() - self.start_time > self.timeout:
            raise TimeoutError("Operation timed out.")
        else:
            return True

# 使用示例
try:
    while next(Limited_time(10)):
        # 这里是检查程序是否已经启动的逻辑
        start_success = False  # 假设这里是检查程序是否启动的结果
        if start_success:
            print("Program started successfully.")
            break
        time.sleep(1)  # 避免CPU过度占用
except TimeoutError as e:
    print(e)

在这个实现当中，Limited_time 类实例化时传入超时时间，它实现了 __iter__ 和 __next__ 方法，使得它可以在 while 循环中使用。每次循环时，__next__ 方法会被调用，如果超时则抛出 TimeoutError 异常，否则继续循环。

尽管这种方法实现了 while Limited_time(timeout): 这样的语法，它仍然需要使用 try/except 块来捕获异常，因为这是处理超时错误的推荐方式。如果你不想捕获异常，你可以修改 __next__ 方法来返回一个布尔值而不是抛出异常，但这将改变你最初的需求（即在超时时抛出一个错误）。

南溪：

这里的代码明显是错误的，循环体while next(Limited_time(10)):每次都会生成一个新的对象，导致程序陷入死循环。

接下来我们咨询一下Claude教授。

2.2 Claude

南溪：您好，我们今天在编程时遇到一个小问题，我们希望用循环来检查一个程序是否已经启动，并给定一定的时间限制，如果超时就报错，也就是说，是否可以使用python实现一种"限时循环"的效果，期望效果的示例代码如下，

python 复制代码 
while Limited_time(10): # if timeout，`Limited_time` would throw an timeout error from inside
    # Here is the logic of checking if the program has started
    if start_success：
       break

Claude：您好,您提到的"限时循环"可以使用Python的time模块来实现。具体做法是:

python 复制代码 
import time

timeout = 10 # seconds
starttime = time.time()
while True:
  if time.time() - starttime > timeout:
    raise TimeoutError("Timeout!")

  # 检查程序是否启动的逻辑
  if start_success: 
    break

  time.sleep(0.1)

主要思路是:

  1. 设置一个超时时间timeout
  2. 在循环开始时记录当前时间starttime
  3. 在循环内部判断当前时间与starttime的时间差是否大于超时时间
  4. 如果超时就抛出TimeoutError异常
  5. 否则就执行正常的检查逻辑,如果程序启动就break退出循环

这里time.sleep可以添加一点延时,避免循环太快消耗CPU。

这个基本思路可以实现Python中的限时循环效果,请您参考是否符合需求。如果还有其他问题,欢迎继续讨论。

南溪：你在代码中使用了"while True:"，我感觉这种写法不是很优雅，能不能写成

python 复制代码 
while Limited_time(10): # if timeout，`Limited_time` would throw an timeout error from inside
    # Here is the logic of checking if the program has started
    if start_success：
       break

我们期望的这种形式呢

Claude：您的意思是希望实现一个Limited_time的函数,来封装这个超时逻辑对吧?可以这样实现:

python 复制代码 
import time

def Limited_time(timeout):
  starttime = time.time()  
  while True:
    if time.time() - starttime > timeout:
      raise TimeoutError("Timeout!")
    yield

# 使用
try:
  while Limited_time(10):
    # 检查程序启动逻辑
    if start_success:
      break
except TimeoutError as e:
  print(e) # 打印超时错误信息

我们实现一个Limited_time生成器函数,内部实现和之前类似,增加超时判断逻辑。

在外部通过while循环调用它,这样可以通过except捕获超时错误。

yield语句让该函数成为一个生成器,遍历它时内部的while True逻辑会执行。

这样就实现了您期望的形式,封装了超时逻辑,外部用while循环更简洁。请您检查下是否符合要求,如果还有其他问题欢迎继续讨论。

**南溪：**我感觉Claude给出的代码似乎有问题，我再询问一下；

南溪：你给出的def Limited_time(timeout)是一个"迭代器函数"吗？

Claude：对,我实现的Limited_time是一个生成器函数,它是一个迭代器。

生成器函数有以下几个特点:

  1. 包含yield语句
  2. 当调用时不会执行函数体代码,而是返回一个生成器对象
  3. 在遍历生成器对象时才会执行函数体内的代码
  4. 每次执行到yield时会暂停,并将yield后的值作为本次迭代的值
  5. 可以通过for循环遍历,也可以通过next()函数获取下一个迭代值

所以在这个例子中,Limited_time是一个生成器函数,包含yield语句。

在外部调用它时,不会执行while True循环,而是返回一个生成器对象。

在for或while循环遍历这个生成器对象时,才会进入Limited_time函数体,并执行while True循环。

每次执行到yield语句就会暂停并返回,实现了迭代的效果。

这就是生成器函数的关键特点,它实现了延迟执行和迭代效果。

所以您认识正确,Limited_time是一个迭代器函数/生成器函数,利用其迭代效果来实现了限时循环逻辑。

南溪：你给出的代码可能是错误的，因为"while Limited_time(10):"在每次while的循环检查时，都会调用新的函数，并没有发挥"迭代器"的作用，于是会导致程序陷入死循环

Claude：您的观点非常正确,我给出的代码的确有问题,会导致重复调用Limited_time而不是利用其迭代器特性。

我重新考虑了一下,应该这样改进:

python 复制代码 
import time

def Limited_time(timeout):
  # 代码同上

timer = Limited_time(10) # 提前创建迭代器

try:
  while True: 
    start_time = next(timer) # 触发迭代器进到函数内部执行
    
    # 检查程序启动逻辑
    if start_success:
      break
      
except StopIteration:
  print("Timeout!") # 迭代器完成时触发StopIteration异常

关键点是:

  1. 提前创建迭代器对象timer,而不是在while内调用
  2. 在while内使用next(timer)触发迭代器进入函数内部执行
  3. 最后用except StopIteration捕获迭代完成的异常

这样就可以正确利用Limited_time的迭代器特性,避免重复调用产生死循环。

非常感谢您指出我示例代码的错误,帮我改进了解决方案。这确实是一个迭代器应用需要注意的地方。如有其他问题,欢迎继续讨论!

南溪：

给出的代码还是使用的while True:，并没有很好地实现我们的要求。

接下来我们咨询一下讯飞星火教授。

2.3 讯飞星火

南溪：您好，我们今天在编程时遇到一个小问题，我们希望用循环来检查一个程序是否已经启动，并给定一定的时间限制，如果超时就报错，也就是说，是否可以使用python实现一种"限时循环"的效果，期望效果的示例代码如下，

python 复制代码 
while Limited_time(10): # if timeout，`Limited_time` would throw an timeout error from inside
    # Here is the logic of checking if the program has started
    if start_success：
       break

讯飞星火：可以使用Python的time模块实现这个功能。首先，我们需要记录循环开始的时间，然后在循环中检查当前时间与开始时间的差值是否超过了给定的时间限制。如果超过了时间限制，就抛出一个异常。示例代码如下：

python 复制代码 
import time

class TimeoutError(Exception):
    pass

def Limited_time(timeout):
    start_time = time.time()
    while True:
        current_time = time.time()
        if current_time - start_time > timeout:
            raise TimeoutError("Timeout")
        # 这里是检查程序是否启动的逻辑
        if start_success():
            break

try:
    Limited_time(10)
except TimeoutError as e:
    print(e)

南溪：我感觉你给出的代码似乎跟我们期望的示例不太一样，在你给出的代码，你将"检查程序是否启动的逻辑"放在了"Limited_time"里面，而我们期望的用法中，"检查程序启动的逻辑"应该是在同一个上下文中

讯飞星火：对不起，我理解错了你的需求。你可以将检查程序是否启动的逻辑放在循环外，然后在循环中只进行超时判断。示例代码如下：

python 复制代码 
import time

class TimeoutError(Exception):
    pass

def Limited_time(timeout):
    start_time = time.time()
    while True:
        current_time = time.time()
        if current_time - start_time > timeout:
            raise TimeoutError("Timeout")
        # 这里是检查程序是否启动的逻辑
        if not start_success():
            break

try:
    Limited_time(10)
except TimeoutError as e:
    print(e)

南溪：

给出的代码没有实现我们的要求，星火将"检查程序启动的逻辑"放在了Limited_time内部。

南溪：你这次给出的代码似乎就是仅仅多加了一个"not"，是吗？

讯飞星火：是的，我添加了"not"关键字来反转start_success()的结果。这样，当start_success()返回False时，循环将继续执行。

南溪：

我感觉星火教授的回答很奇怪，跟我的问题似乎没有什么关联。

3 后记

我们感觉这个简单的API应该是可以实现的，可以想到的是：使用单例模式（将LimitedTime实现成一个单例class）加上记录函数的调用栈信息，来有效地区分和判别当前循环，来判断当前循环的执行是否超时，以实现上述这种简单的调用形式；

相关推荐
eybk2 小时前
Pytorch+Mumu模拟器+萤石摄像头实现对小孩学习的监控
学习
6.942 小时前
Scala学习记录 递归调用 练习
开发语言·学习·scala
Aileen_0v02 小时前
【AI驱动的数据结构：包装类的艺术与科学】
linux·数据结构·人工智能·笔记·网络协议·tcp/ip·whisper
守护者1703 小时前
JAVA学习-练习试用Java实现“使用Arrays.toString方法将数组转换为字符串并打印出来”
java·学习
学会沉淀。4 小时前
Docker学习
java·开发语言·学习
Rinai_R4 小时前
计算机组成原理的学习笔记(7)-- 存储器·其二 容量扩展/多模块存储系统/外存/Cache/虚拟存储器
笔记·物联网·学习
吃着火锅x唱着歌4 小时前
PHP7内核剖析 学习笔记 第四章 内存管理（1）
android·笔记·学习
ragnwang4 小时前
C++ Eigen常见的高级用法 [学习笔记]
c++·笔记·学习
胡西风_foxww5 小时前
【es6复习笔记】rest参数（7）
前端·笔记·es6·参数·rest
热门推荐
0119个Web前端交互式3D JavaScript框架和库02优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间03玄机平台应急响应—webshell查杀04RAG 实践- Ollama+RagFlow 部署本地知识库05基于大语言模型（LLM）的合成数据生成、策展和评估的综述06(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明07【一文读懂】NTN（非地面网络）技术介绍08HCIA-datacom数通题库和录播视频资料09Docker 夺命连环 15 问10ZZ038 物联网应用与服务赛题第J套