python sleep函数如何暂停程序_python time.sleep()函数使用方法-Python教程-PHP中文网

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

python sleep函数如何暂停程序_python time.sleep()函数使用方法

Python中让程序暂停执行，核心就是利用

time

登录后复制

模块中的

sleep()

登录后复制

函数。它能让你的代码在指定的时间里“打个盹”，之后再继续运行，实现简单而有效的延时操作。

解决方案

要让Python程序暂停，你只需要导入

time

登录后复制

模块，然后调用

time.sleep()

登录后复制

函数，并传入你希望暂停的秒数作为参数。这个秒数可以是整数，也可以是浮点数，意味着你可以精确到毫秒甚至更短的时间。

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

import time

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

登录后复制

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

立即学习“Python免费学习笔记（深入）”；

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()

登录后复制

的精确度通常能达到毫秒级别，甚至更高。但它并不是绝对精确的。影响其精确性的因素有很多：

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

举个例子，你

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()

登录后复制

。

怪兽AI数字人

数字人短视频创作，数字人直播，实时驱动数字人

查看详情

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()

登录后复制

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

```
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} 秒")
```
登录后复制
```
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} 秒")
```
登录后复制
```
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} 秒")
```
登录后复制
```
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
```
登录后复制
就是用这个对象来格式化输出。