如何在Python中延迟时间？

时间：2009-02-04 07:04:10

标签： python delay sleep timedelay

我想知道如何在Python脚本中加时间延迟。

12 个答案:

答案 0 :(得分：2710)

import time
time.sleep(5)   # Delays for 5 seconds. You can also use a float value.

这是另一个例子，大约每分钟运行一次：

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

答案 1 :(得分：679)

您可以使用sleep() function in the time module。它可以采用浮动参数进行亚秒级分辨率。

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

答案 2 :(得分：64)

  

如何在Python中延迟时间？

在一个帖子中我建议sleep function：

>>> from time import sleep

>>> sleep(4)

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

将其用于此目的，或者仅仅是为了延迟执行某个功能。例如：

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

＆＃34;！万岁＆＃34;在我按 Enter 后3秒打印。

使用具有多个线程和进程的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 threading对象在单独的线程中触发稍后调用的函数：

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

>>>

空白行说明该功能已打印到我的标准输出，我必须按 Enter 以确保我处于提示状态。

这个方法的好处是，当Timer线程在等待时，我能够做其他事情，在这种情况下，在执行函数之前，按一次 Enter （看到第一个空提示。）

multiprocessing library中没有相应的对象。你可以创建一个，但它可能不存在是有原因的。对于简单的计时器而言，子线程比整个新的子进程更有意义。

答案 3 :(得分：44)

困了generator，有点好玩。

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

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

情况可能是，我们希望尽可能经常地做一些事情，我们不想在我们的代码周围使用所有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)

正如我们所看到的，这个蜂鸣器并不太僵硬，即使我们睡过头而且不按规定的时间安排，也能让我们经常睡不着觉。

答案 4 :(得分：24)

Python标准库中的tkinter库是一个可以导入的交互式工具。基本上，你可以创建按钮和框，弹出窗口以及用代码操作的窗口。

如果您使用tkinter，请勿使用TIME.SLEEP()，因为它会破坏您的程序。这发生在我身上。相反，使用root.after()并用毫秒来替换多少秒的值。例如，time.sleep(1)相当于tkinter中的root.after(1000)。

否则，time.sleep()，许多答案已经指出，这是要走的路。

答案 5 :(得分：24)

延迟是使用time library完成的，特别是time.sleep()函数。

让它等一下：

from time import sleep
sleep(1)

这是有效的，因为这样做：

from time import sleep

您从sleep function中提取time library ，这意味着您可以通过以下方式调用它：

sleep(seconds)

而不是输入

time.sleep()

键入的内容很长。

使用此方法，您将无法访问time library的其他功能，并且您无法拥有名为sleep的变量。但是你可以创建一个名为time的变量。

如果您只是想要某个模块的某些部分，那么执行from [library] import [function] (, [function2])非常有用。

你可以这样做：

import time
time.sleep(1)

只要您输入time.[function]()，您就可以访问time library的其他功能，例如time.clock()，但您无法创建变量时间，因为它会覆盖进口。要做到这一点的解决方案

import time as t

允许您将time library引用为t，允许您执行以下操作：

t.sleep()

这适用于任何图书馆。

答案 6 :(得分：24)

我知道5种方法：time.sleep()，pygame.time.wait()，matplotlib的pyplot.pause()，.after()和driver.implicitly_wait()。

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 2
root = tk.Tk()
print('Hello')
def ohhi():
 print('Oh, hi!')
root.after(5000, ohhi)#milliseconds and then a function
print('Bye')

最后，driver.implicitly_wait()方法（硒）：

driver.implicitly_wait(5)#waits 5 seconds

答案 7 :(得分：18)

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

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

 driver.implicitly_wait(5)

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

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

答案 8 :(得分：6)

asyncio.sleep

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

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 official documentation了解更多详细信息

答案 9 :(得分：5)

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

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()

答案 10 :(得分：4)

虽然其他人都提出了事实上的time模块，但我认为我会使用matplotlib的{​​{1}}函数pause分享不同的方法。

一个例子

pyplot

通常，这用于防止绘图在绘制后立即消失或制作原始动画。

如果您已导入from matplotlib import pyplot as plt plt.pause(5) # Pauses the program for 5 seconds ，则会为您节省import。

答案 11 :(得分：4)

如果您想在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 sec later with [delay_in_sec] as *args parameter
t.start()  # returns None
print("Started")

输出：

Started
function called after 2 seconds

为什么使用后一种方法？

  • 不会停止执行整个脚本。 （除了传递的函数之外）
  • 启动计时器后，您也可以通过执行timer_obj.cancel()来停止计时器。
相关问题
最新问题