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

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

ОТВЕТЫ

Ответ 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).

Ответ 2

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

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

Ответ 3

Пожалуйста, прочтите это, что может помочь вам в дальнейшем:

Попробуйте функцию сна в модуле времени.

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)

Дополнительная информация

Ответ 4

Как я могу сделать задержку в 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 один раз - до выполнения функции (см. Первое пустое приглашение).

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

Ответ 5

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

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

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

Ситуация может заключаться в том, что мы хотим делать что-то как можно 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

Вызов регулярного 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)

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

Ответ 6

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

Первый способ

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

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

 driver.implicitly_wait(5)

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

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

Ответ 7

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

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

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

Ответ 8

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

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

Ответ 9

Есть 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

Ответ 10

Лучший способ задержать время в Python - использовать библиотеку time. Как это:

import time
time.sleep(10)

Просто замените 10 на количество секунд, которое вы хотите отложить. Вы можете использовать такие форматы, как '10.1 ',' 5.07 'и т.д.

Не рекомендуется использовать это с Tkinter

Ответ 11

import time
time.sleep(1) #sleep for one second.

Простой пример:

#After five seconds,output "hello python!!!"
import time
time.sleep(5)
print("hello python!!!")

Ответ 12

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

Ответ 13

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

Используйте 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().

Ответ 14

В то время как все остальные предложили модуль time де-факто, я решил поделиться другим методом, использующим функцию matplotlib pyplot, pause.

Пример

from matplotlib import pyplot as plt
plt.pause(5)    # Pauses the program for 5 seconds

Обычно это используется для предотвращения исчезновения графика сразу после его построения или для создания грубой анимации.

Это сэкономит вам import если вы уже импортировали matplotlib.

Ответ 15

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

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

Ответ 16

Вы можете использовать метод сна во временном пакете, чтобы задержать выполнение программы на Python

import time
time.sleep(1)   # Delays for 1 seconds.

Ответ 17

Чтобы установить временную задержку, вы должны импортировать модуль time. И с этим модулем вам нужно только написать:

time.sleep(The amount of time)

Например, если вы хотите поставить временную задержку за секунду до того, как компьютер выполнит другую строку, вы должны поместить:

time.sleep(1)
print('Hello World!')

Что все:)

Ответ 18

Я искал предыдущие ответы, и я просто хотел бы основываться на них.

Я часто хотел создать эффект печати, вот как вы можете это сделать (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)

Я надеюсь, что это помогло вам в некотором роде.

Ответ 19

Вы можете создать временную задержку в 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

Ответ 20

Вы также можете попробовать это:

import time
#the time now
start = time.time() 
while time.time() - start < 10: #run 1- seconds
    pass
#do the job

теперь оболочка не будет падать или не реагировать

Ответ 21

вот очень простой пример

import time
for i in range(10):
 time.sleep(1)
 print(i)

источник

Ответ 22

Если у вас установлен autopygui, вы можете использовать:

#imports
import pyautogui

pyautogui._autoPause(time1)

И общее время паузы будет time1 секунд

Ответ 23

Если вам нужно плавать задержки, вы можете использовать sleep:

from time import sleep
sleep(0.1)

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

import time
time.sleep(1)

Ответ 24

Вот список способов спать или ждать:

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

Ответ 25

Использование pygame

import pygame
pygame.init()
while True:
    pygame.time.wait(1000)
    print("This prints every second.")
    print("Please note that this method uses milliseconds.")