Я хотел бы узнать, как поместить временную задержку в сценарий 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()
в модуле time
. Она может принимать аргумент float для субсекундного разрешения.
from time import sleep
sleep(0.1) # Time in seconds
Как сделать временную задержку в Python?
В одном потоке я предлагаю функцию sleep:
>>> from time import sleep
>>> sleep(4)
Эта функция фактически приостанавливает обработку потока, в котором она вызывается операционной системой, позволяя другим потокам и процессам выполняться, пока она спит.
Используйте ее для этой цели или просто для задержки выполнения функции. Например:
>>> def party_time():
... print('hooray!')
...
>>> sleep(3); party_time()
hooray!
"ура!" будет напечатано через 3 секунды после того, как я нажму Enter.
sleep
с несколькими потоками и процессамиОпять же, sleep
приостанавливает ваш поток - он использует практически нулевую вычислительную мощность.
Для демонстрации создайте скрипт следующего вида (сначала я попытался сделать это в интерактивной оболочке Python 3.5, но подпроцессы почему-то не могут найти функцию 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 один раз - до того, как функция выполнится (см. первую пустую подсказку).
В библиотеке мультипроцессинга нет соответствующего объекта. Вы можете создать его, но, вероятно, он не существует по какой-то причине. Подпоток имеет гораздо больше смысла для простого таймера, чем целый новый подпроцесс.
Немного развлечений с сонным генератором.
Вопрос касается временной задержки. Это может быть фиксированное время, но в некоторых случаях нам может понадобиться задержка, измеряемая с момента последнего времени. Вот одно из возможных решений:
Ситуация может быть такой, что мы хотим делать что-то как можно регулярнее и не хотим возиться со всеми этими 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'))
Библиотеки tkinter в стандартной библиотеке Python-это интерактивный инструмент, который можно импортировать. В принципе, можно создать кнопки и всплывающие окна и вещи, которые выглядят как окна, которые манипулируют с кодом.
Если вы использовать tkinter, не используйте время.Сон (), потому что он будет портить вашу программу. Это случилось со мной. Вместо этого используйте корень.после () и заменить значения на сколько секунд, а миллисекунд. Например, время.сна(1)
эквивалентно `корень.после(1000) в tkinter.
В противном случае, время.сон()`, который многие ответы указывали, что путь.
Есть 5 методов, которые я знаю: время.сон(),
с которым Pygame.время.ждать(), библиотек matplotlib'ы
pyplot.пауза(),
.после () " и " водитель.implicitly_wait()`.
время.пример сна ()
(не использовать, если использовать Tkinter):
import time
print('Hello')
time.sleep(5) #number of seconds
print('Bye')
`с которым Pygame.время.постой пример () (не рекомендуется, если вы не используете окно, с которым 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 функция S`.пример паузы () (не рекомендуется, если не используется график, но вы могли бы выйти сразу на графике):
import matplotlib
print('Hello')
matplotlib.pyplot.pause(5)#seconds
print('Bye')
Этот .после способ ()
(лучше с 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')
Наконец, водитель.способ implicitly_wait ()
(селен):
driver.implicitly_wait(5)#waits 5 seconds
Задержки сделали с Время, а конкретно время .сон()
Функция.
Чтобы просто сделать его ждать второго:
from time import sleep
sleep(1)
Это работает, потому что:
from time import sleep
Извлечения спящий режим только от библиотеки, Что означает, что вы можете просто вызвать его с:
sleep(seconds)
Вместо того, чтобы вводить
time.sleep()
Которая несуразно длинное.
С помощью этого метода, вы не'т получить доступ к другим функциям время и вы можете'т иметь переменную под названием "Сон". Но вы можете создать переменную, называется "Время".
Делаем из [библиотека] импорт [функция] (, [функция2])` это здорово, если вы просто хотите, чтобы определенные части модуля.
Вы могли в равной степени творить как:
import time
time.sleep(1)
и у тебя есть доступ к другой функции Время, Как времени.часы()
Как долго, как вы вводите время.[функция]()`, но вы не'т создать переменную времени, потому что его бы заменить импорт. Решение этого делать
import time as t
что позволит вам получить ссылку на библиотеки как "Т", позволяя вам делать:
t.sleep()
Это работает в любой библиотеке.
Заметил в последних версиях питона (Python 3.4 В или выше) вы можете использовать ввода-вывода.сон
. Это'ы, связанные с асинхронного программирования и ввода-вывода. Проверьте следующий пример:
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
Рекомендую прочитать ввода-вывода официальную документацию для более подробной информации
Время использования.сна
или `событие().подожди, как это:
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.отменить()
.Это простой пример задержки:
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()
В то время как все остальные уже предложил де-факто "время" модуль, я думал, что я'd доля другой способ использования библиотек matplotlib'функция S
pyplot, [
пауза`](https://matplotlib.org/api/_as_gen/matplotlib.pyplot.pause.html).
from matplotlib import pyplot as plt
plt.pause(5) # Pauses the program for 5 seconds
Обычно это используется для предотвращения сюжет исчезнуть, как только она наносится или сырой анимации.
Это позволит сэкономить вам "импорт", если у вас уже есть библиотек matplotlib
импортного производства.