如何在代码中添加延迟

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

当您运行一个简单的 Python 程序时,代码执行是按顺序发生的——一条语句接一条语句——没有任何时间延迟。 但是,在某些情况下您可能需要延迟代码的执行。 Python 内置时间模块中的 sleep() 函数可以帮助您做到这一点。

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

Python time.sleep() 的语法

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

import time

由于 sleep() 函数是时间模块的一部分,您现在可以通过以下通用语法访问和使用它:

time.sleep(n) 

这里,n 是睡眠的秒数。 它可以是整数或浮点数。

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

▶ 您也可以只从时间模块导入睡眠函数:

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 秒的固定延迟。 接下来,让我们编写另一个示例,以在循环遍历可迭代对象时引入不同的延迟时间。

  个性化 Slack 帐户的 10 种方法

在这个例子中,我们想做以下事情:

  • 遍历一个句子,访问每个单词,然后打印出来。
  • 打印出每个单词后,我们希望等待一段特定的时间——然后再打印出句子中的下一个单词。

循环遍历一串字符串

考虑字符串,句子。 它是一个字符串,其中每个单词本身就是一个字符串。

如果我们遍历字符串,我们将得到每个字符,如下所示:

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

# Output (truncated for readability)
H
o
w
.
.
.
t
a
k
e
?

但这不是我们想要的。 我们想遍历句子并访问每个单词。 为此,我们可以在句子字符串上调用 split() 方法。 这将返回一个字符串列表——通过拆分句子字符串获得——包含所有出现的空格。

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

# Output
How
long
will
this
take?

循环遍历具有不同延迟的可迭代对象

让我们重温一下这个例子:

  • sentence 是我们想要循环访问每个单词的字符串。
  • delay_times 是我们将在每次循环期间用作 sleep() 函数参数的延迟时间列表。

这里我们想同时循环遍历两个列表:delay_times列表和拆分句子字符串得到的字符串列表。 您可以使用 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)

如果没有睡眠功能,控件将立即进行下一次迭代。 因为我们引入了延迟,下一次循环只有在睡眠操作完成后才会发生。

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

$ python3 delay_times.py

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

Python 中的倒数计时器

作为下一个示例,让我们用 Python 编写一个简单的倒数计时器。

  如何在 Microsoft Word 中汇总行和列

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

# /python-sleep/countdown.py
import time

def countDown(n):
    for i in range(n,-1,-1):
        if i==0:
            print("Ready to go!")
        else:
             print(i)
             time.sleep(1)

接下来我们来解析countDown()函数的定义:

  • 该函数接受一个数字 n 作为参数,并从该数字 n 开始倒数到零。
  • 我们使用 time.sleep(1) 在计数之间实现一秒的延迟。
  • 当计数达到 0 时,该函数打印出“Ready to go!”。

🎯 为了实现倒计时操作,我们使用了负步长值为-1 的range() 函数。 range(n, -1, -1) 将帮助我们遍历 n、n – 1、n – 2 中的数字范围,依此类推直到零。 回想一下,在使用 range() 函数时,终点默认被排除在外。

接下来让我们以 5 作为参数添加对 countDown() 函数的调用。

countDown(5)

现在运行脚本 countdown.py 并查看 countDown 函数的运行情况!

$ python3 countdown.py

多线程中的休眠函数

Python 线程模块提供开箱即用的多线程功能。 在 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 = …) 创建一个线程,该线程使用 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 的睡眠持续时间最长,为两秒,因此它是最后一个完成执行的线程。

要了解更多信息,请阅读有关 Python 中多线程基础知识的教程。

结论

在本教程中,您学习了如何使用 Python 的 sleep() 函数为代码添加时间延迟。

您可以从内置时间模块 time.sleep() 访问 sleep() 函数。 要将执行延迟 n 秒,请使用 time.sleep(n)。 此外,您还看到了通过不同的值、倒计时和多线程延迟循环中后续迭代的示例。

您现在可以探索时间模块的更多高级功能。 想在 Python 中处理日期和时间吗? 除了时间模块之外,您还可以利用日期时间和日历模块的功能。

接下来,学习用Python计算时间差。⏰