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




time.sleep python 3 (8)

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


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


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.


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.


Los retrasos se pueden implementar utilizando tres métodos.

Comencemos con el más fácil:

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

El segundo método para retrasar sería usar el método de espera implícito:

 driver.implicitly_wait(5)

El tercer método es más útil cuando tiene que esperar hasta que se complete una acción en particular o hasta que se encuentre un elemento:

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

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.


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.





timedelay