我想知道如何在 Python 脚本中设置时间延迟。
问问题
3471698 次
13 回答
3277
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).
于 2009-02-04T07:05:59.533 回答
849
您可以使用模块sleep()中的功能time。它可以采用浮点参数进行亚秒级分辨率。
from time import sleep
sleep(0.1) # Time in seconds
于 2008-09-15T16:34:29.780 回答
108
如何在 Python 中进行时间延迟？
在一个线程中，我建议使用sleep 功能：
>>> from time import sleep
>>> sleep(4)
这个函数实际上暂停了操作系统调用它的线程的处理，允许其他线程和进程在它休眠时执行。
将其用于该目的，或仅用于延迟执行功能。例如：
>>> def party_time():
... print('hooray!')
...
>>> sleep(3); party_time()
hooray!
“万岁！” 在我点击 3 秒后打印Enter。
sleep使用多个线程和进程的示例
再次，sleep暂停您的线程 - 它使用几乎为零的处理能力。
party_later为了演示，创建一个这样的脚本（我首先在交互式 Python 3.5 shell 中尝试了这个，但由于某种原因子进程找不到该函数）：
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在函数执行之前点击一次（见第一个空提示）。
多处理库中没有相应的对象。您可以创建一个，但它可能由于某种原因不存在。对于一个简单的计时器来说，一个子线程比一个全新的子进程更有意义。
于 2017-06-21T03:25:05.187 回答
81
延迟也可以通过以下方法实现。
第一种方法：
import time
time.sleep(5) # Delay for 5 seconds.
第二种延迟方法是使用隐式等待方法：
driver.implicitly_wait(5)
当您必须等到特定操作完成或找到元素时，第三种方法更有用：
self.wait.until(EC.presence_of_element_located((By.ID, 'UserName'))
于 2018-01-05T10:41:24.263 回答
57
我知道有五种方法：time.sleep(), pygame.time.wait(), matplotlib's 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 2
root = tk.Tk()
print('Hello')
def ohhi():
print('Oh, hi!')
root.after(5000, ohhi) # Milliseconds and then a function
print('Bye')
最后，asyncio.sleep()方法：
import asyncio
asyncio.sleep(5)
于 2018-07-05T20:47:48.973 回答
55
一个昏昏欲睡的发电机有点乐趣。
问题是关于时间延迟。它可以是固定时间，但在某些情况下，我们可能需要测量自上次以来的延迟。这是一种可能的解决方案：
自上次以来测量的延迟（定期醒来）
情况可能是，我们想尽可能有规律地做某事，我们不想打扰我们代码周围的所有东西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
调用常规蜂鸣器
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)
正如我们所看到的，这个蜂鸣器不是太死板，即使我们睡过头并且超出了正常的日程安排，也能让我们赶上定期的困倦时间。
于 2014-05-14T21:30:35.883 回答
34
Python 标准库中的Tkinter库是一个可以导入的交互式工具。基本上，您可以创建按钮和框以及弹出窗口和显示为您使用代码操作的窗口的东西。
如果您使用 Tkinter，请不要使用time.sleep()，因为它会破坏您的程序。这发生在我身上。取而代之的是，使用root.after()并用毫秒替换值。例如，time.sleep(1)相当于root.after(1000)在 Tkinter 中。
否则，time.sleep()许多答案已经指出，这是要走的路。
于 2017-02-28T19:45:40.240 回答
28
延迟是通过时间库完成的，特别是time.sleep()函数。
让它等待一秒钟：
from time import sleep
sleep(1)
这是有效的，因为这样做：
from time import sleep
您仅从time library中提取sleep 函数 ，这意味着您可以使用以下命令调用它：
sleep(seconds)
而不必打字
time.sleep()
打字太长了。
使用此方法，您将无法访问时间库的其他功能，并且您无法拥有名为sleep. 但是您可以创建一个名为time.
from [library] import [function] (, [function2])如果您只想要模块的某些部分，那么这样做很好。
你同样可以这样做：
import time
time.sleep(1)
只要您键入，您就可以访问时间库的其他功能，但是您无法创建变量 time 因为它会覆盖导入。解决这个问题time.clock()time.[function]()
import time as t
这将允许您将时间库引用为t，允许您执行以下操作：
t.sleep()
这适用于任何图书馆。
于 2017-06-13T19:04:18.173 回答
14
如果您想在 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()。
于 2019-01-10T12:13:25.860 回答
13
异步睡眠
请注意，在最近的 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 官方文档了解更多详情。
于 2018-12-03T19:12:52.497 回答
9
虽然其他人都建议使用事实上的time模块，但我想我会使用matplotlib'spyplot函数分享不同的方法，pause.
一个例子
from matplotlib import pyplot as plt
plt.pause(5) # Pauses the program for 5 seconds
通常，这用于防止情节在绘制后立即消失或制作粗略的动画。
import如果您已经matplotlib导入，这将节省您的时间。
于 2018-06-05T07:10:14.920 回答
8
这是时间延迟的一个简单示例：
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()
于 2018-09-16T08:14:05.107 回答
1
你也可以试试这个：
import time
# The time now
start = time.time()
while time.time() - start < 10: # Run 1- seconds
pass
# Do the job
现在外壳不会崩溃或没有反应。
于 2019-04-13T06:09:22.323 回答