我想知道如何在Python脚本中加时间延迟.
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).
您可以sleep()在时间模块中使用该功能.它可以采用浮动参数进行亚秒级分辨率.
from time import sleep sleep(0.1) # Time in seconds
在这里阅读更多.
如何在Python中延迟时间？
在单个线程中我建议睡眠功能:
>>> from time import sleep >>> sleep(4)
这实际上暂停了操作系统调用它的线程的处理,允许其他线程和进程在休眠时执行.
将其用于此目的,或仅仅是为了延迟执行某个功能.例如:
>>> def party_time():
... print('hooray!')
...
>>> sleep(3); party_time()
hooray!
"万岁!" 我打了3秒后打印出来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在执行函数之前点击一次(参见第一个空提示).
多处理库中没有相应的对象.你可以创建一个,但它可能不存在是有原因的.对于简单的计时器而言,子线程比整个新的子进程更有意义.
一个沉睡的发电机有点乐趣.
问题是时间延迟.它可以是固定的时间,但在某些情况下,我们可能需要从上次开始测量延迟.这是一个可能的解决方案:
自上次以来测量的延迟(定期醒来)这种情况可能是,我们希望尽可能经常地做一些事情,我们不希望与所有的打扰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)
正如我们所看到的,这种蜂鸣器并不太僵硬,即使我们睡过头而且不按规定时间安排,也能让我们赶上经常困倦的时间间隔.
可以使用三种方法实现延迟.
让我们从最简单的一个开始:
import time time.sleep(5) # Delay for 5 seconds.
第二种延迟方法是使用隐式等待方法:
driver.implicitly_wait(5)
当您必须等到特定操作完成或找到元素时,第三种方法更有用:
self.wait.until(EC.presence_of_element_located((By.ID, 'UserName'))
Python标准库中的tkinter库是一个可以导入的交互式工具.基本上,您可以创建按钮和框以及弹出窗口和显示为您使用代码操作的窗口的内容.
如果您使用tkinter,请勿使用,time.sleep()因为它会破坏您的程序.这发生在我身上.相反,使用root.after()并以毫秒为单位替换多秒的值.例如,time.sleep(1)相当于root.after(1000)tkinter.
否则,time.sleep()许多答案已经指出,这是要走的路.
延迟是通过时间库完成的,特别是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.clock(),只要你键入time.[function](),但你不能创建变量的时间,因为它会覆盖进口.解决这个问题的方法
import time as t
这将允许你引用时库作为t,让你做:
t.sleep()
这适用于任何库.
有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
请注意,在最近的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官方文档以获取更多详细信息
使用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()。
尽管其他所有人都建议使用事实上的time模块，但我认为我会使用matplotlib的pyplot功能共享另一种方法pause。
from matplotlib import pyplot as plt plt.pause(5) # Pauses the program for 5 seconds
通常，这用于防止绘图在绘制后立即消失或制作原始动画。
import如果您已经matplotlib导入，这将为您节省一个。
这是一个简单的时间延迟示例：
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()
京公网安备 11010802040832号 | 京ICP备19059560号-6 