Python Sleep 函数：如何在代码中加入延迟

本教程将教你如何使用Python内置的时间模块中的sleep()函数向代码添加时间延迟。

当你运行一个简单的Python程序时，代码的执行是按照顺序-一个接一个-没有任何时间延迟进行的。然而，在某些情况下，您可能需要延迟代码的执行。Python内置的时间模块中的sleep()函数可以帮助您实现这一点。

在本教程中，您将学习Python中使用sleep()函数的语法以及几个示例，以了解它的工作原理。让我们开始吧！

Python time.sleep()的语法

Python标准库中内置的time模块提供了几个有用的与时间相关的函数。作为第一步，将time模块导入到您的工作环境中：

import time

由于sleep()函数是time模块的一部分，您现在可以使用以下通用语法访问和使用它：

time.sleep(n)

在这里，n是要延迟的秒数。它可以是整数或浮点数。

有时所需的延迟可能是几毫秒。在这些情况下，您可以将毫秒的持续时间转换为秒，并在调用sleep函数时使用它。例如，如果您想引入100毫秒的延迟，可以将其指定为0.1秒：time.sleep(0.1)。

▶ 您还可以从time模块中仅导入sleep函数：

from time import sleep

如果您使用上述导入方法，可以直接调用sleep()函数，而无需使用time.sleep()。

现在，您已经学习了Python sleep()函数的语法，让我们通过编写示例代码来看看该函数的作用。您可以从此GitHub仓库的python-sleep文件夹中下载本教程中使用的Python脚本。👩🏽‍💻

使用sleep()延迟代码执行

作为第一个示例，让我们使用sleep函数延迟执行一个简单的Python程序。

在下面的代码片段中：

第一个print()语句在没有任何延迟的情况下执行。
然后，我们使用sleep()函数引入了5秒的延迟。
只有当睡眠操作完成后，才会执行第二个print()语句。

# /python-sleep/simple_example.py
import time

print("Print now")
time.sleep(5)
print("Print after sleeping for 5 seconds")

现在运行simple_example.py文件并观察输出：

$ python3 simple_example.py

向代码块中添加不同的延迟

在前面的示例中，我们在两个print()语句的执行之间引入了5秒的固定延迟。接下来，让我们编写另一个示例，以在循环遍历可迭代对象时引入不同的延迟时间。

在这个示例中，我们想要做到以下几点：

遍历一个句子，访问每个单词并将其打印出来。
在打印出每个单词后，我们希望等待一定的时间间隔，然后再打印出句子中的下一个单词。

循环遍历字符串

考虑字符串sentence。它是一个每个单词本身都是一个字符串的字符串。

如果我们循环遍历字符串，我们将得到每个字符，如下所示：

>>> sentence = "How long will this take?"
>>> for char in sentence:
...     print(char)

# 输出（为了方便阅读而截断）
H
o
w
.
.
.
t
a
k
e
?

但这不是我们想要的。我们想要遍历句子并访问每个单词。为了做到这一点，我们可以在sentence字符串上调用split()方法。这将返回一个字符串列表 – 通过在所有空格出现的地方分割sentence字符串。

>>> sentence.split()
['How', 'long', 'will', 'this', 'take?']
>>> for word in sentence.split():
...     print(word)

# 输出
How
long
will
this
take?

以不同延迟循环迭代

让我们重新访问一下这个例子：

sentence是我们想要遍历的字符串，以访问每个单词。
delay_times是我们将在循环中使用作为sleep()函数参数的延迟时间列表。

我们希望同时循环遍历两个列表：延迟时间delay_times列表和通过将sentence字符串拆分得到的字符串列表。您可以使用zip()函数来执行这种并行迭代。

Python的zip()函数：zip(list1, list2)返回一个迭代器，其中每个元组包含list1和list2中索引i处的项目。

# /python-sleep/delay_times.py
import time

sleep_times = [3,4,1.5,2,0.75]
sentence = "How long will this take?"
for sleep_time,word in zip(sleep_times,sentence.split()):
    print(word)
    time.sleep(sleep_time)

如果没有sleep函数，控制流将立即进入下一次迭代。因为我们引入了延迟，只有在延迟操作完成后，才会进行下一次循环。

现在运行delay_times.py并观察输出：

$ python3 delay_times.py

在延迟后，字符串中的后续单词将被打印出来。在打印出字符串中索引i处的单词后的延迟是delay_times列表中索引i处的数字。

Python中的倒计时计时器

作为下一个例子，让我们在Python中编写一个简单的倒计时计时器。

让我们定义一个countDown()函数：

# /python-sleep/countdown.py
import time

def countDown(n):
    for i in range(n,-1,-1):
        if i==0:
            print("准备好了！")
        else:
             print(i)
             time.sleep(1)

接下来，让我们解析countDown()函数的定义：

该函数以一个数字n作为参数，从该数字n开始倒数到零。
我们使用time.sleep(1)来实现每个计数之间一秒的延迟。
当计数达到0时，函数打印出“准备好了！”。

🎯 为了实现倒计时操作，我们使用了值为-1的负步长值调用range()函数。range(n, -1, -1)将帮助我们循环遍历从n、n-1、n-2等到零的范围内的数字。回想一下，默认情况下，在使用range()函数时，排除了终点。

接下来，让我们添加一个调用带有5作为参数的countDown()函数。

countDown(5)

现在运行脚本countdown.py，看看countDown函数的运行情况！

$ python3 countdown.py

多线程中的Sleep函数

Python的threading模块提供了开箱即用的多线程功能。在Python中，全局解释器锁（GIL）确保在任何时刻只有一个活动线程在运行。

然而，在I/O操作和等待操作（如睡眠）期间，处理器可以暂停执行当前线程，并切换到另一个等待的线程。

为了了解这是如何工作的，让我们举一个例子。

在Python中创建和运行线程

考虑以下函数func1()，func2()和func3()。它们循环遍历一定范围的数字并将其打印出来。然后在每次循环通过时进行睡眠操作-睡眠指定的秒数。我们为每个函数使用了不同的延迟时间，以更好地理解执行如何在多个线程之间切换。

import time

def func1():
    for i in range(5):
        print(f"Running t1, print {i}.")
        time.sleep(2)

def func2():
    for i  in range(5):
         print(f"Running t2, print {i}.")
         time.sleep(1)


def func3():
    for i in range(4):
         print(f"Running t3, print {i}.")
         time.sleep(0.5)

在Python中，您可以使用Thread()构造函数实例化一个线程对象。使用语法threading.Thread(target = …, args = …)创建一个运行target函数的线程，该函数使用args元组中指定的参数。

在本示例中，函数func1，func2和func3不接受任何参数。因此，只需指定函数的名称作为目标即可。然后，我们分别使用func1，func2和func3作为目标定义线程对象t1，t2和t3。

t1 = threading.Thread(target=func1)
t2 = threading.Thread(target=func2)
t3 = threading.Thread(target=func3)

t1.start()
t2.start()
t3.start()

以下是线程示例的完整代码：

# /python-sleep/threads.py
import time
import threading

def func1():
    for i in range(5):
        print(f"Running t1, print {i}.")
        time.sleep(2)

def func2():
    for i  in range(5):
         print(f"Running t2, print {i}.")
         time.sleep(1)

def func3():
    for i in range(4):
         print(f"Running t3, print {i}.")
         time.sleep(0.5)

t1 = threading.Thread(target=func1)
t2 = threading.Thread(target=func2)
t3 = threading.Thread(target=func3)

t1.start()
t2.start()
t3.start()

观察输出。执行在三个线程之间交替切换。线程t3具有最短的等待时间，因此它的暂停时间最短。线程t1具有最长的睡眠时间为两秒，因此它是最后一个完成执行的线程。