摘要：问题描述：如何在 Python 脚本中添加时间延迟？解决方案 1：这会延迟 2.5 秒：import time time.sleep(2.5) 下面是另一个示例，其中某些操作大约每分钟运行一次：import time while True: print("This prints once...

问题描述：

如何在 Python 脚本中添加时间延迟？

解决方案 1：

这会延迟 2.5 秒：

import time

time.sleep(2.5)

下面是另一个示例，其中某些操作大约每分钟运行一次：

import time

while True:
    print("This prints once a minute.")
    time.sleep(60) # Delay for 1 minute (60 seconds).

解决方案 2：

sleep()从模块中使用time。它可以采用浮点参数来实现亚秒级的分辨率。

from time import sleep
sleep(0.1)  # Time in seconds

解决方案 3：

如何在 Python 中实现时间延迟？

在单线程中我建议使用睡眠功能：

>>> from time import sleep

>>> sleep(4)

此函数实际上暂停操作系统调用它的线程的处理，从而允许其他线程和进程在其休眠期间执行。

使用它来实现这个目的，或者只是延迟执行某个函数。例如：

>>> def party_time():
...     print('hooray!')
...
>>> sleep(3); party_time()
hooray!

我点击后三秒打印出“hooray!” Enter。

`sleep`使用多个线程和进程的示例

再次sleep暂停您的线程-它使用几乎零的处理能力。

为了演示，创建一个这样的脚本（我首先在交互式 Python 3.5 shell 中尝试这个脚本，但是由于某种原因子进程找不到该party_later函数）：

from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor, as_completed
from time import sleep, time

def party_later(kind='', n=''):
    sleep(3)
    return kind + n + ' party time!: ' + __name__

def main():
    with ProcessPoolExecutor() as proc_executor:
        with ThreadPoolExecutor() as thread_executor:
            start_time = time()
            proc_future1 = proc_executor.submit(party_later, kind='proc', n='1')
            proc_future2 = proc_executor.submit(party_later, kind='proc', n='2')
            thread_future1 = thread_executor.submit(party_later, kind='thread', n='1')
            thread_future2 = thread_executor.submit(party_later, kind='thread', n='2')
            for f in as_completed([
              proc_future1, proc_future2, thread_future1, thread_future2,]):
                print(f.result())
            end_time = time()
    print('total time to execute four 3-sec functions:', end_time - start_time)

if __name__ == '__main__':
    main()

此脚本的示例输出：

thread1 party time!: __main__
thread2 party time!: __main__
proc1 party time!: __mp_main__
proc2 party time!: __mp_main__
total time to execute four 3-sec functions: 3.4519670009613037

多线程

Timer 您可以使用线程对象触发稍后在单独的线程中调用的函数：

>>> from threading import Timer
>>> t = Timer(3, party_time, args=None, kwargs=None)
>>> t.start()
>>>
>>> hooray!

>>>

空行说明该函数已打印到我的标准输出，我必须点击Enter以确保我处于提示状态。

这种方法的优点是，当Timer线程正在等待时，我可以做其他事情，在这种情况下，Enter在函数执行之前点击一次（参见第一个空提示）。

多处理库中没有相应的对象。您可以创建一个，但出于某种原因它可能不存在。对于简单的计时器来说，子线程比全新的子进程更有意义。

解决方案 4：

还可以使用下列方法实现延迟。

第一种方法：

import time
time.sleep(5) # Delay for 5 seconds.

延迟的第二种方法是使用隐式等待方法：

 driver.implicitly_wait(5)

当您必须等到特定操作完成或找到元素时，第三种方法更有用：

self.wait.until(EC.presence_of_element_located((By.ID, 'UserName'))

解决方案 5：

我知道有五种方法：time.sleep()、、pygame.time.wait()matplotlib 的pyplot.pause()、、.after()和asyncio.sleep()。

time.sleep()例如（如果使用 tkinter 请不要使用）：

import time
print('Hello')
time.sleep(5) # Number of seconds
print('Bye')

pygame.time.wait()示例（如果您没有使用 pygame 窗口则不推荐，但您可以立即退出窗口）：

import pygame
# If you are going to use the time module
# don't do "from pygame import *"
pygame.init()
print('Hello')
pygame.time.wait(5000) # Milliseconds
print('Bye')

matplotlib 的函数pyplot.pause()示例（如果您不使用图表则不推荐，但您可以立即退出图表）：

import matplotlib
print('Hello')
matplotlib.pyplot.pause(5) # Seconds
print('Bye')

方法.after()（最好使用 Tkinter）：

import tkinter as tk # Tkinter for Python&nbsp;2
root = tk.Tk()
print('Hello')
def ohhi():
    print('Oh, hi!')
root.after(5000, ohhi) # Milliseconds and then a function
print('Bye')

最后，asyncio.sleep()方法（必须在异步循环中）：

await asyncio.sleep(5)

解决方案 6：

昏昏欲睡的发电机带来一点乐趣。

问题是关于时间延迟。它可以是固定时间，但在某些情况下，我们可能需要自上次测量以来的延迟。以下是一个可能的解决方案：

自上次（定期唤醒）以来测量的延迟

情况可能是这样的，我们想尽可能有规律地做某事，而不想被代码周围的所有东西last_time所困扰。next_time

蜂鸣器发生器

下面的代码（sleepy.py）定义了一个buzzergen生成器：

import time
from itertools import count

def buzzergen(period):
    nexttime = time.time() + period
    for i in count():
        now = time.time()
        tosleep = nexttime - now
        if tosleep > 0:
            time.sleep(tosleep)
            nexttime += period
        else:
            nexttime = now + period
        yield i, nexttime

调用常规 buzzergen

from sleepy import buzzergen
import time
buzzer = buzzergen(3) # Planning to wake up each 3 seconds
print time.time()
buzzer.next()
print time.time()
time.sleep(2)
buzzer.next()
print time.time()
time.sleep(5) # Sleeping a bit longer than usually
buzzer.next()
print time.time()
buzzer.next()
print time.time()

运行它我们看到：

1400102636.46
1400102639.46
1400102642.46
1400102647.47
1400102650.47

我们也可以直接在循环中使用它：

import random
for ring in buzzergen(3):
    print "now", time.time()
    print "ring", ring
    time.sleep(random.choice([0, 2, 4, 6]))

运行它我们可能会看到：

now 1400102751.46
ring (0, 1400102754.461676)
now 1400102754.46
ring (1, 1400102757.461676)
now 1400102757.46
ring (2, 1400102760.461676)
now 1400102760.46
ring (3, 1400102763.461676)
now 1400102766.47
ring (4, 1400102769.47115)
now 1400102769.47
ring (5, 1400102772.47115)
now 1400102772.47
ring (6, 1400102775.47115)
now 1400102775.47
ring (7, 1400102778.47115)

如我们所见，这个蜂鸣器并不太死板，即使我们睡过头而打乱了正常的作息时间，它也能让我们赶上正常的睡眠时间。

解决方案 7：

Python 标准库中的Tkinter库是一个可以导入的交互式工具。基本上，您可以创建按钮、框、弹出窗口以及以窗口形式显示的内容，然后使用代码进行操作。

如果您使用 Tkinter，请不要使用time.sleep()，因为它会弄乱您的程序。我遇到过这种情况。相反，使用root.after()并将的值替换为毫秒。例如，在 Tkinter 中time.sleep(1)相当于root.after(1000)。

否则，time.sleep()正如许多答案所指出的，这是可行的方法。

解决方案 8：

延迟是通过时间库完成的，特别是该time.sleep()函数。

让它等待一秒钟：

from time import sleep
sleep(1)

这是有效的，因为通过执行以下操作：

from time import sleep

您仅从时间库中提取睡眠函数，这意味着您只需使用以下命令调用它：

sleep(seconds)

而不必打字

time.sleep()

输入起来太长了，很尴尬。

使用这种方法，您将无法访问时间库的其他功能，也无法拥有名为的变量sleep。但您可以创建一个名为的变量time。

from [library] import [function] (, [function2])如果您只是想要模块的某些部分，那么这样做就很棒。

您也可以这样做：

import time
time.sleep(1)

只要您输入，您就可以访问time 库的其他功能，但您无法创建变量 time ，因为它会覆盖导入。解决此问题的方法是time.clock()`time.[function]()`

import time as t

这将允许您以的形式引用时间库，从而t允许您执行以下操作：

t.sleep()

这适用于任何图书馆。

解决方案 9：

如果你想在 Python 脚本中添加时间延迟：

使用time.sleep或者Event().wait像这样：

from threading import Event
from time import sleep

delay_in_sec = 2

# Use time.sleep like this
sleep(delay_in_sec)         # Returns None
print(f'slept for {delay_in_sec} seconds')

# Or use Event().wait like this
Event().wait(delay_in_sec)  # Returns False
print(f'waited for {delay_in_sec} seconds')

但是，如果您想延迟某个函数的执行，请执行以下操作：

使用方式threading.Timer如下：

from threading import Timer

delay_in_sec = 2

def hello(delay_in_sec):
    print(f'function called after {delay_in_sec} seconds')

t = Timer(delay_in_sec, hello, [delay_in_sec])  # Hello function will be called 2 seconds later with [delay_in_sec] as the *args parameter
t.start()  # Returns None
print("Started")

输出：

Started
function called after 2 seconds

为什么要使用后一种方法？

它不会停止整个脚本的执行（除了您传递给它的函数）。
启动计时器后，您也可以通过执行以下操作来停止它timer_obj.cancel()。

解决方案 10：

asyncio.sleep

请注意，在最近的 Python 版本（Python 3.4 或更高版本）中，您可以使用asyncio.sleep。它与异步编程和 asyncio 相关。查看下一个示例：

import asyncio
from datetime import datetime

@asyncio.coroutine
def countdown(iteration_name, countdown_sec):
    """
    Just count for some countdown_sec seconds and do nothing else
    """
    while countdown_sec > 0:
       print(f'{iteration_name} iterates: {countdown_sec} seconds')
       yield from asyncio.sleep(1)
       countdown_sec -= 1

loop = asyncio.get_event_loop()
tasks = [asyncio.ensure_future(countdown('First Count', 2)),
         asyncio.ensure_future(countdown('Second Count', 3))]

start_time = datetime.utcnow()

# Run both methods. How much time will both run...?
loop.run_until_complete(asyncio.wait(tasks))

loop.close()

print(f'total running time: {datetime.utcnow() - start_time}')

我们可能认为它会在第一个方法中“休眠” 2 秒，然后在第二个方法中“休眠” 3 秒，这段代码总共运行 5 秒。但它会打印：

total_running_time: 0:00:03.01286

建议阅读asyncio 官方文档以了解更多详细信息。

解决方案 11：

虽然其他人都建议使用事实上的模块，但time我想我会分享一种使用函数的不同matplotlib方法pyplot。pause

一个例子

from matplotlib import pyplot as plt
plt.pause(5)    # Pauses the program for 5 seconds

通常这用于防止情节在绘制后立即消失或制作粗糙的动画。

import如果您已经导入，这将节省您的时间matplotlib。

解决方案 12：

这是一个简单的时间延迟示例：

import time

def delay(period='5'):
    # If the user enters nothing, it'll wait 5 seconds
    try:
        # If the user not enters a int, I'll just return ''
        time.sleep(period)
    except:
        return ''

另外，在Tkinter中：

import tkinter

def tick():
    pass

root = Tk()
delay = 100 # Time in milliseconds
root.after(delay, tick)
root.mainloop()

解决方案 13：

你也可以尝试这个：

import time
# The time now
start = time.time() 
while time.time() - start < 10: # Run 1- seconds
    pass
# Do the job

现在shell不会崩溃或者没有反应了。

我如何延迟时间？ [重复]

问题描述：

解决方案 1：

解决方案 2：

解决方案 3：

如何在 Python 中实现时间延迟？

`sleep`使用多个线程和进程的示例

多线程

解决方案 4：

解决方案 5：

解决方案 6：

自上次（定期唤醒）以来测量的延迟

蜂鸣器发生器

调用常规 buzzergen

解决方案 7：

解决方案 8：

解决方案 9：

如果你想在 Python 脚本中添加时间延迟：

但是，如果您想延迟某个函数的执行，请执行以下操作：

为什么要使用后一种方法？

解决方案 10：

asyncio.sleep

解决方案 11：

一个例子

解决方案 12：

解决方案 13：

云端的项目管理软件

问题描述：

解决方案 1：

解决方案 2：

解决方案 3：

如何在 Python 中实现时间延迟？

sleep使用多个线程和进程的示例

多线程

解决方案 4：

解决方案 5：

解决方案 6：

自上次（定期唤醒）以来测量的延迟

蜂鸣器发生器

调用常规 buzzergen

解决方案 7：

解决方案 8：

解决方案 9：

如果你想在 Python 脚本中添加时间延迟：

但是，如果您想延迟某个函数的执行，请执行以下操作：

为什么要使用后一种方法？

解决方案 10：

asyncio.sleep

解决方案 11：

一个例子

解决方案 12：

解决方案 13：

云端的项目管理软件

`sleep`使用多个线程和进程的示例