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

wufei123 发布于 2025-09-17 阅读（11）
答案是使用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秒后继续执行。")

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

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()
。 Post AI Post AI

博客文章AI生成器

Post AI50 查看详情 Post 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()
函数那么简单，它提供了一系列处理时间相关任务的工具，对于程序的计时、性能分析以及时间格式化都非常有用。 

  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程序在时间管理上更加灵活和高效。

以上就是python sleep函数如何暂停程序_python time.sleep()函数使用方法的详细内容，更多请关注知识资源分享宝库其它相关文章！

相关标签： python 操作系统 工具 ai 爬虫 格式化输出 python程序 Python 标识符 字符串 循环 线程 并发 对象 事件 异步 大家都在看： Python网络爬虫：利用CSS选择器精准提取与过滤复杂网页数据 Python怎么将时间戳转换为日期_Python时间戳与日期转换指南 Python 列表元素交换：len() 函数、负索引与Pythonic实践 Python怎么安装pip_Python包管理工具pip安装指南 python怎么将数据写入CSV文件_python CSV文件写入操作指南

标签:  函数 使用方法 暂停 

相关阅读

发表评论:

◎欢迎参与讨论，请在这里发表您的看法、交流您的观点。

最近发表

标签列表