如何在Python脚本中设置时间延迟?


当前回答

如何在Python中设置时间延迟?

在一个线程中,我建议使用睡眠功能:

>>> from time import sleep

>>> sleep(4)

该函数实际上暂停了操作系统调用它的线程的处理,允许其他线程和进程在休眠时执行。

为此目的使用它,或者简单地延迟函数的执行。例如:

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

“万岁!”在我按下Enter键3秒后打印。

对多个线程和进程使用睡眠的示例

同样,睡眠会暂停线程-它使用几乎为零的处理能力。

为了演示,创建一个这样的脚本(我第一次在交互式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键(见第一个空提示)。

多处理库中没有相应的对象。你可以创建一个,但它可能是没有原因的。对于一个简单的计时器来说,子线程比一个全新的子进程更有意义。

其他回答

使用时间模块中的sleep()。对于亚秒分辨率,它可以使用浮点参数。

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

异步休眠

请注意,在最近的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官方文档以了解更多详细信息。

虽然其他人都建议使用事实上的时间模块,但我想我应该使用matplotlib的pyplot函数pause来分享一种不同的方法。

一个例子

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

通常,这是为了防止绘图在绘制后立即消失或制作粗糙的动画。

如果您已经导入了matplotlib,这将为您保存一个导入。

也可以通过以下方法实现延迟。

第一种方法:

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

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

 driver.implicitly_wait(5)

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

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

这将延迟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).