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

Вызов регулярного генератора buzzergen

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

Рекомендую прочитать ввода-вывода официальную документацию для более подробной информации

Если вы хотите поставить задержку в скрипте Python:

Время использования.сна или `событие().подожди, как это:

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'функция Spyplot, [пауза`](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 импортного производства.