Я хотел бы знать, как установить временную задержку в Python script.
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. Может принимать аргумент с плавающей точкой для разрешения менее секунды.
from time import sleep
sleep(0.1) # Time in seconds
Пожалуйста, прочтите это, что может помочь вам в дальнейшем:
Попробуйте функцию сна в модуле времени.
import time time.sleep(60)И поставить это в
whileциклы и оператор будет выполняться только на минуту... Это позволяет запускать выражение в заранее определенные промежутки времени, независимо от того, как долго команда принимает ( до тех пор, как он занимает меньше минуты или 5 или 60 или как там у вас установлено) Например, я хотел запускать пинг раз в минуту. Если я простоtime.sleep(60)илиtime.sleep(45)даже, пинг не всегда будет занимать одинаковое количество времени. Вот код :)time.sleep(time.localtime(time.time())[5])
[5]просто извлекает секунды из возвращаемого значенияtime.localtime().Самое замечательное в
time.sleep- он поддерживает числа с плавающей запятой!import time time.sleep(0.1)
Как я могу сделать задержку в Python?
В одной теме я предлагаю функцию сна:
>>> 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 не удалось найти функцию 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, и мы не хотим беспокоиться о всех 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, НЕ ИСПОЛЬЗУЙТЕ TIME.SLEEP() потому что это 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](), но вы не можете создать переменную time, потому что она перезапишет импорт. Решение этого сделать
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')
Пример функции 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 - использовать библиотеку time. Как это:
import time
time.sleep(10)
Просто замените 10 на количество секунд, которое вы хотите отложить. Вы можете использовать такие форматы, как '10.1 ',' 5.07 'и т.д.
Не рекомендуется использовать это с Tkinter
import time
time.sleep(1) #sleep for one second.
Простой пример:
#After five seconds,output "hello python!!!"
import time
time.sleep(5)
print("hello python!!!")
Обратите внимание, что в последних версиях 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 для более подробной информации.
Используйте 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(). В то время как все остальные предложили модуль 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()
Вы можете использовать метод сна во временном пакете, чтобы задержать выполнение программы на Python
import time
time.sleep(1) # Delays for 1 seconds.
Чтобы установить временную задержку, вы должны импортировать модуль time. И с этим модулем вам нужно только написать:
time.sleep(The amount of time)
Например, если вы хотите поставить временную задержку за секунду до того, как компьютер выполнит другую строку, вы должны поместить:
time.sleep(1)
print('Hello World!')
Что все:)
Я искал предыдущие ответы, и я просто хотел бы основываться на них.
Я часто хотел создать эффект печати, вот как вы можете это сделать (Python 3):
import time # For pausing
def typewrite(text):
for i in text:
print(i, end="", flush=True) # flush is True, so the result will get printed before waiting
time.sleep(0.1)
И в Python 2:
import time, sys # Time is for pausing, sys for printing without a new line
def typewrite(text):
sys.stdout.flush() # flush is True, so the result will get printed before waiting
for i in text:
sys.stdout.write(i)
time.sleep(0.1)
Я надеюсь, что это помогло вам в некотором роде.
Вы можете создать временную задержку в Python, используя два простых подхода, основанных на time.sleep().
Первый подход:
import time
for i in range(2): # Looping two times
print('Hey, what about delay?')
time.sleep(.500) # Time delay = 500 milliseconds (1/2 sec)
print('Are you still here?')
Второй подход:
import time
def delay(seconds):
return time.sleep(seconds)
delay(2.5) # Time delay = 2.5 seconds
Вы также можете попробовать это:
import time
#the time now
start = time.time()
while time.time() - start < 10: #run 1- seconds
pass
#do the job
теперь оболочка не будет падать или не реагировать
вот очень простой пример
import time
for i in range(10):
time.sleep(1)
print(i)
Если у вас установлен autopygui, вы можете использовать:
#imports
import pyautogui
pyautogui._autoPause(time1)
И общее время паузы будет time1 секунд
Если вам нужно плавать задержки, вы можете использовать sleep:
from time import sleep
sleep(0.1)
Если вам нужна целочисленная задержка, вы можете использовать time.sleep следующим образом:
import time
time.sleep(1)
Вот список способов спать или ждать:
time.sleep(secs) # https://docs.python.org/3/library/time.html#time.sleep
threading.Event.wait
threading.Timer
tkinter.Tk.after
asyncio.sleep
matplotlib.pyplot.pause
Использование pygame
import pygame
pygame.init()
while True:
pygame.time.wait(1000)
print("This prints every second.")
print("Please note that this method uses milliseconds.")