Как я могу сделать задержку в Python?

Question

Я хотел бы знать, как поместить задержку в скрипт Python.

Answer 1

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

Answer 2

Вы можете использовать функцию sleep() в модуле time . Может принимать аргумент с плавающей точкой для разрешения менее секунды.

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

Answer 3

Как я могу сделать задержку в 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):

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!

>>> 

Пустая строка показывает, что функция распечатана по моему стандарту, и мне пришлось нажать Введите , чтобы убедиться, что я был в приглашении.

Достоинством этого метода является то, что пока ожидался поток Timer, я смог сделать другие вещи, в данном случае, нажав Enter один раз - до выполнения функции (см. Первую пустое приглашение).

В многопроцессорной библиотеке нет соответствующего объекта . Вы можете создать его, но, вероятно, по какой-то причине его не существует. Подпоток имеет гораздо больше смысла для простого таймера, чем целый новый подпроцесс.

Answer 4

Немного веселья с сонным генератором .

Вопрос о задержке. Это может быть фиксированное время, но в некоторых случаях нам может понадобиться задержка, измеренная с прошлого раза. Вот одно из возможных решений:

Задержка, измеренная с прошлого раза (регулярно просыпаться)

Ситуация может быть, мы хотим делать что-то как можно более регулярно, и мы не хотим беспокоиться о всех вещах 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)

Как мы видим, этот зуммер не слишком жесткий и позволяет нам наверстывать упущенное с регулярными сонными интервалами, даже если мы спим и выходим из обычного графика.

Answer 5

Есть 5 методов, которые я знаю: time.sleep(), pygame.time.wait(), matplotlib's 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

Answer 6

Задержки выполняются с помощью библиотеки времени , в частности, функции time.sleep().

Чтобы просто подождать секунду:

from time import sleep
sleep(1)

Это работает, потому что, делая:

from time import sleep

Вы извлекаете функцию сна only из библиотеки времени , что означает, что вы можете просто вызвать ее с помощью:

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

Это работает в любой библиотеке.

Answer 7

Библиотека tkinter в стандартной библиотеке Python - это интерактивный инструмент, который вы можете импортировать. По сути, вы можете создавать кнопки, поля, всплывающие окна и тому подобное, которые выглядят как окна, которыми вы манипулируете с кодом.

Если вы используете tkinter, НЕ ИСПОЛЬЗУЙТЕ TIME.SLEEP(), потому что это испортит вашу программу. Это случилось со мной. Вместо этого используйте root.after() и замените значения на сколько угодно секунд на миллисекунды. Например, time.sleep(1) эквивалентно root.after(1000) в tkinter.

В противном случае, time.sleep(), на что указывают многие ответы, - это путь.

Answer 8

Задержки также могут быть реализованы с помощью следующих методов.

Первый метод

import time
time.sleep(5) # Delay for 5 seconds.

Вторым методом задержки будет использование метода неявного ожидания:

 driver.implicitly_wait(5)

Третий метод более полезен, когда вам нужно подождать, пока не будет выполнено определенное действие, или пока не будет найден элемент:

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

Answer 9

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 для получения более подробной информации

Answer 10

Это простой пример задержки:

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 ''

Другой, в Ткинтере:

import tkinter

def tick():
    pass

root=Tk()
delay=100 # time in milliseconds
root.after(delay,tick)
root.mainloop()