Pythonsleep函数使用教程

在文章实战开发的过程中，我们经常会遇到一些这样那样的问题，然后要卡好半天，等问题解决了才发现原来一些细节知识点还是没有掌握好。今天golang学习网就整理分享《Python sleep函数暂停程序方法》，聊聊，希望可以帮助到正在努力赚钱的你。

答案是使用time.sleep()可让Python程序暂停执行，它通过操作系统调度实现非阻塞休眠，精度受系统影响，适用于常规延时；在异步编程中应改用asyncio.sleep()以避免阻塞事件循环，同时time模块还提供time.time()、perf_counter()、monotonic()等函数用于计时和时间格式化操作。

Python中让程序暂停执行，核心就是利用time模块中的sleep()函数。它能让你的代码在指定的时间里“打个盹”，之后再继续运行，实现简单而有效的延时操作。

解决方案

要让Python程序暂停，你只需要导入time模块，然后调用time.sleep()函数，并传入你希望暂停的秒数作为参数。这个秒数可以是整数，也可以是浮点数，意味着你可以精确到毫秒甚至更短的时间。

比如，你想让程序暂停5秒：

import time

print("程序开始执行...")
time.sleep(5) # 程序会在这里暂停5秒
print("程序暂停了5秒后继续执行。")

或者，如果你需要更精细的控制，比如暂停半秒：

import time

print("开始计时...")
time.sleep(0.5) # 暂停0.5秒
print("0.5秒过去了。")

这个函数在很多场景下都非常有用。我记得刚开始写爬虫的时候，就经常用sleep来模拟人类浏览行为，避免请求过于频繁导致被目标网站封禁IP，虽然有点笨，但真的管用。它也能用来模拟耗时操作，或者在某些定时任务中作为简单的延时机制。不过，需要注意的是，time.sleep()会阻塞当前执行它的线程，这意味着在暂停期间，这个线程什么也做不了。

time.sleep()函数的工作原理和精确性如何？

当你调用time.sleep(seconds)时，Python并不是真的让你的CPU“空转”了seconds秒。实际上，它会通知操作系统（OS）：“嘿，我这个进程/线程要休息seconds秒，这段时间你可以把CPU资源分配给其他需要运行的任务。”然后，操作系统会把你的进程/线程标记为“休眠”状态，并将其从可运行队列中移除。等到指定的seconds时间过去，或者操作系统认为合适的时候，它会再次将你的进程/线程唤醒，并放回可运行队列，等待CPU调度。

所以，time.sleep()并不是一个“忙等”操作，它很“礼貌”地让出了CPU资源。

至于精确性，这其实是一个比较复杂的问题。在大多数现代操作系统上，time.sleep()的精确度通常能达到毫秒级别，甚至更高。但它并不是绝对精确的。影响其精确性的因素有很多：

1. 操作系统调度粒度： 操作系统有自己的调度周期和策略，它可能不会在seconds时间刚到的那一刻就立即唤醒你的进程。
2. 系统负载： 如果你的系统非常繁忙，CPU资源紧张，那么即使sleep时间到了，你的进程也可能需要等待一段时间才能再次获得CPU。
3. 硬件中断： 各种硬件中断也可能影响到睡眠的精确性。

举个例子，你sleep(0.001)，理论上是1毫秒，但在实际运行中，可能因为各种原因，它实际暂停了1.5毫秒或者0.8毫秒。对于大多数应用场景，比如控制请求频率、简单的定时，这种程度的偏差是完全可以接受的。但如果你在做一些对时间精度要求极高的实时系统，比如高频交易或者科学实验数据采集，那么time.sleep()可能就不是最佳选择了，你可能需要考虑更底层的系统调用或者专门的实时操作系统。

在异步编程中，time.sleep()会带来什么问题？又该如何解决？

time.sleep()最大的“缺点”在于它的阻塞性。在传统的同步编程模型中，这通常不是问题，因为程序本来就是顺序执行的。但当你踏入异步编程的世界，比如使用Python的asyncio库时，time.sleep()就成了“毒药”。

想象一下，你有一个asyncio的事件循环，它负责调度多个协程（coroutine）的执行。如果一个协程里面调用了time.sleep(5)，那么整个事件循环都会被这个sleep操作卡住5秒！在这5秒内，其他所有的协程，即使它们已经准备好运行，也无法得到执行，因为事件循环被阻塞了。这完全违背了异步编程的初衷——通过非阻塞I/O和协作式多任务来提高程序的并发性。

所以，在异步编程中，我们绝不能直接使用time.sleep()。正确的做法是使用asyncio模块提供的异步版本：asyncio.sleep()。

asyncio.sleep()是一个awaitable对象，它会“暂停”当前的协程，但同时会将控制权交还给事件循环。这样，事件循环就可以去执行其他已经准备好的协程了。等到asyncio.sleep()指定的延时时间到了，事件循环会再次调度之前暂停的协程继续执行。

来看个对比：

使用 time.sleep() (错误示例):

import asyncio
import time

async def task_a():
    print("Task A: 开始...")
    time.sleep(2) # 阻塞整个事件循环
    print("Task A: 结束。")

async def task_b():
    print("Task B: 开始...")
    await asyncio.sleep(0.1) # 即使这里是异步sleep，也会被上面的time.sleep阻塞
    print("Task B: 结束。")

async def main_blocking():
    await asyncio.gather(task_a(), task_b())

print("--- 使用 time.sleep() 阻塞 ---")
# asyncio.run(main_blocking()) # 运行会发现 task_b 并没有在 task_a 暂停时执行

（注：如果你真的运行上面的main_blocking()，你会发现Task B的“开始”和“结束”都会在Task A的time.sleep(2)结束后才出现，因为整个事件循环被卡住了。）

使用 asyncio.sleep() (正确示例):

import asyncio

async def task_async_a():
    print("Task Async A: 开始...")
    await asyncio.sleep(2) # 非阻塞暂停
    print("Task Async A: 结束。")

async def task_async_b():
    print("Task Async B: 开始...")
    await asyncio.sleep(0.1) # 非阻塞暂停
    print("Task Async B: 结束。")

async def main_non_blocking():
    await asyncio.gather(task_async_a(), task_async_b())

print("\n--- 使用 asyncio.sleep() 非阻塞 ---")
asyncio.run(main_non_blocking())

运行main_non_blocking()，你会看到Task Async A: 开始...和Task Async B: 开始...几乎同时出现，然后Task Async B: 结束。很快打印，接着等待2秒后，Task Async A: 结束。才打印。这才是异步编程期望的行为。

所以，记住一点：在异步函数（用async def定义的函数）中，需要暂停时，务必使用await asyncio.sleep()，而不是time.sleep()。

除了简单的暂停，time模块还有哪些实用的时间操作功能？

time模块远不止一个sleep()函数那么简单，它提供了一系列处理时间相关任务的工具，对于程序的计时、性能分析以及时间格式化都非常有用。

1. time.time()：获取当前时间戳 这个函数返回自纪元（通常是1970年1月1日00:00:00 UTC）以来经过的秒数，以浮点数表示。它非常适合用来测量代码执行的时间间隔，或者作为生成唯一标识符的一部分。

   import time
   start_time = time.time()
   # 模拟一些耗时操作
   sum(range(10**7))
   end_time = time.time()
   print(f"操作耗时: {end_time - start_time:.4f} 秒")

2. time.perf_counter()：更高精度的性能计数器time.time()可能会受到系统时钟调整的影响，而time.perf_counter()则提供了一个具有最高可用分辨率的计时器，它不受系统时钟调整的影响，更适合用来测量短时间间隔的性能。

   import time
   start_perf = time.perf_counter()
   # 模拟一些短时操作
   [x*x for x in range(10**5)]
   end_perf = time.perf_counter()
   print(f"高精度操作耗时: {end_perf - start_perf:.6f} 秒")

3. time.monotonic()：单调时钟 这个函数也返回一个单调递增的值，同样不受系统时钟调整的影响。它特别适用于测量持续时间，因为它可以保证返回的值总是向前推进的，即使系统时间被手动修改或通过NTP同步。

   import time
   start_mono = time.monotonic()
   time.sleep(1.2) # 暂停1.2秒
   end_mono = time.monotonic()
   print(f"单调时钟测量暂停时间: {end_mono - start_mono:.4f} 秒")

4. time.ctime() 和 time.strftime()：格式化时间time模块还能帮助你把时间戳转换成人类可读的字符串。 time.ctime()会把一个时间戳（或当前时间）转换成一个易读的字符串，格式类似 "Mon Jan 01 00:00:00 2024"。 time.strftime()则提供了更强大的格式化能力，你可以根据需要自定义输出格式。

   import time
   current_timestamp = time.time()
   print(f"当前时间（ctime）: {time.ctime(current_timestamp)}")
   # 自定义格式：年-月-日 时:分:秒
   print(f"当前时间（strftime）: {time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(current_timestamp))}")

   time.localtime()会将时间戳转换成一个struct_time对象，strftime就是用这个对象来格式化输出。

这些函数共同构成了time模块的强大功能，它们在日常编程中处理时间问题时，都是非常实用的工具。理解并善用它们，能让你的Python程序在时间管理上更加灵活和高效。

以上就是《Pythonsleep函数使用教程》的详细内容，更多关于Python,异步编程,time.sleep(),程序暂停,asyncio.sleep()的资料请关注golang学习网公众号！