delay time.sleep - ¿Cómo puedo hacer un retraso de tiempo en Python?




delays milliseconds (11)

Me gustaría saber cómo poner un retraso de tiempo en un script de Python.


Answers

La mejor manera de retrasar el tiempo en Python es usar la biblioteca de time . Me gusta esto:

import time
time.sleep(10)

Simplemente reemplaza 10 con la cantidad de segundos que quieres retrasar. Puede utilizar formatos como '10 .1 ',' 5.07 ', etc.

No se recomienda usar esto con Tkinter.


Este es un ejemplo fácil de un retraso de tiempo:

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

Otro, en Tkinter:

import tkinter

def tick():
    pass

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

La biblioteca tkinter en la biblioteca estándar de Python es una herramienta interactiva que puede importar. Básicamente, puedes crear botones y cuadros y ventanas emergentes y cosas que aparecen como ventanas que manipulas con el código.

Si usa tkinter, NO USE TIME.SLEEP() porque TIME.SLEEP() su programa. Esto me paso a mi En su lugar, use root.after() y reemplace los valores por muchos segundos, con milisegundos. Por ejemplo, time.sleep(1) es equivalente a root.after(1000) en tkinter.

De lo contrario, time.sleep() , que muchas respuestas han señalado, que es el camino a seguir.


Puede usar la función sleep() en el módulo de tiempo. Puede tomar un argumento flotante para la resolución de sub segundo.

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

Un poco de diversión con un generator sueño.

La pregunta es sobre el retraso del tiempo. Puede ser un tiempo fijo, pero en algunos casos podríamos necesitar un retraso medido desde la última vez. Aquí hay una posible solución:

Retraso medido desde la última vez (despertarse regularmente)

La situación puede ser, queremos hacer algo tan regularmente como sea posible y no queremos molestarnos con todas las cosas de next_time last_time , next_time todas partes de nuestro código.

Generador de zumbador

El siguiente código ( sleepy.py ) define un generador de 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

Invocando buzzergen regular

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

Y ejecutándolo vemos:

1400102636.46
1400102639.46
1400102642.46
1400102647.47
1400102650.47

También podemos usarlo directamente en un bucle:

import random
for ring in buzzergen(3):
    print "now", time.time()
    print "ring", ring
    time.sleep(random.choice([0, 2, 4, 6]))

Y ejecutándolo podríamos ver:

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)

Como vemos, este timbre no es demasiado rígido y nos permite alcanzar intervalos regulares de sueño, incluso si nos quedamos dormidos y salimos del horario regular.


Los retrasos se realizan con la biblioteca de tiempo , específicamente la función time.sleep() ...

Solo para hacer esperar un segundo:

from time import sleep
sleep(1)

Esto funciona porque al hacer:

from time import sleep

extrae la time.sleep() solo de la biblioteca de tiempo, lo que significa que solo puede llamar con:

sleep(seconds)

en lugar de tener que escribir

time.sleep()

que es torpemente largo para escribir.

Con este método, no obtendría acceso a las otras funciones de la biblioteca de tiempo y no puede tener una variable llamada suspensión. Pero podrías crear una variable llamada tiempo.

Hacer from [library] import [function] (, [function2]) es genial si solo quieres ciertas partes de un módulo.

Podrías hacerlo igualmente como

import time
time.sleep(1)

y tendría acceso a las otras funciones de la biblioteca de tiempos como time.clock() siempre que escriba time.[function]() , pero no pudo crear el tiempo variable.


Lea https://web.archive.org/web/20090207081238/http://faqts.com/knowledge_base/view.phtml/aid/2609/fid/378 , que puede ayudarlo más:

Intente la función dormir en el módulo de tiempo.

import time
time.sleep(60)

Y ponga esto en un bucle while y una instrucción solo se ejecutará en el minuto ... Eso le permite ejecutar una instrucción en intervalos predefinidos sin importar cuánto demore el comando (siempre que tome menos de un minuto o 5 o 60 minutos). o lo que sea que configures para) Por ejemplo, quería ejecutar un ping una vez por minuto. Si solo time.sleep(60) o time.sleep(45) incluso, el ping no siempre llevará la misma cantidad de tiempo. Aquí está el código :)

time.sleep(time.localtime(time.time())[5])

El [5] simplemente extrae los segundos del valor de retorno de time.localtime() .

Lo bueno de time.sleep es que admite números de punto flotante.

import time
time.sleep(0.1) 

http://python.org/doc/current/lib/module-time.html


Mientras que todos los demás han sugerido el módulo de time de facto, pensé que compartiría un método diferente usando la función pyplot , pause .

Un ejemplo

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

Normalmente, esto se utiliza para evitar que la trama desaparezca tan pronto como se traza o para hacer animaciones en bruto.

Esto le ahorraría una import si ya ha importado matplotlib .


¿Cómo puedo hacer un retraso de tiempo en Python?

En un solo hilo sugiero la función dormir:

>>> from time import sleep

>>> sleep(4)

En realidad, esto suspende el procesamiento del subproceso en el que es llamado por el sistema operativo, permitiendo que otros subprocesos y procesos se ejecuten mientras duerme.

Utilícelo para ese propósito, o simplemente para demorar la ejecución de una función. Por ejemplo:

>>> def party_time():
...     print('hooray!')
... 
>>> sleep(3); party_time()
hooray!

"¡hurra!" Imprimí 3 segundos después de presionar Enter .

Ejemplo usando sleep con múltiples hilos y procesos

Una vez más, el modo de sleep suspende el hilo: utiliza una potencia de procesamiento próxima a cero.

Para demostrarlo, cree un script como este (primero intenté esto en un shell interactivo de Python 3.5, pero los subprocesos no pueden encontrar la función party_later por alguna razón):

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

Ejemplo de salida de este script:

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

Multihilo

Puede activar una función para que se llame más tarde en un subproceso separado con el objeto de subprocesamiento del Timer :

>>> from threading import Timer
>>> t = Timer(3, party_time, args=None, kwargs=None)
>>> t.start()
>>>
>>> hooray!

>>> 

La línea en blanco ilustra que la función se imprimió en mi salida estándar y tuve que presionar Intro para asegurar que estaba en un aviso.

La ventaja de este método es que mientras el subproceso del Timer estaba esperando, pude hacer otras cosas, en este caso, presionando Intro una vez, antes de que se ejecutara la función (consulte el primer indicador vacío).

No hay un objeto respectivo en la biblioteca de multiprocesamiento. Puedes crear uno, pero probablemente no exista por una razón. Un subproceso tiene mucho más sentido para un temporizador simple que un subproceso completamente nuevo.


Hay 4 métodos que conozco: time.sleep() , pygame.time.wait() , pyplot.pause() de pyplot.pause() , y .after() .

time.sleep() (no usar si usa Tkinter):

import time
print('Hello')
time.sleep(5) #number of seconds
print('Bye')

pygame.time.wait() (no recomendado si no está utilizando la ventana de pygame, pero podría salir de la ventana al instante):

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

Ejemplo de la función pyplot.pause() no recomendado si no está utilizando el gráfico, pero podría salir del gráfico al instante):

import matplotlib
print('Hello')
matplotlib.pyplot.pause(5)#seconds 
print('Bye')

Finalmente, el método .after() (mejor con 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')

Parece que las otras personas ya te han dicho cómo resolver el problema. Espero que esto te ayude a entender qué son los decoradores.

Los decoradores son solo azúcar sintáctica.

Esta

@decorator
def func():
    ...

se expande a

def func():
    ...
func = decorator(func)






python delay sleep timedelay