Come posso creare un ritardo temporale in Python?


Mi piacerebbe sapere come mettere un ritardo di tempo in uno script Python.


Answers



import time
time.sleep(5)   # delays for 5 seconds. You can Also Use Float Value.

Ecco un altro esempio in cui qualcosa viene eseguito all'incirca una volta al minuto:

import time 
while True:
    print("This prints once a minute.")
    time.sleep(60)   # Delay for 1 minute (60 seconds).



È possibile utilizzare la funzione sleep () nel modulo temporale. Può richiedere un argomento float per la risoluzione del secondo secondo.

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



Leggi https://web.archive.org/web/20090207081238/http://faqts.com/knowledge_base/view.phtml/aid/2609/fid/378 , che può aiutarti ulteriormente:

Prova la funzione sleep nel modulo time.

import time
time.sleep(60)

E metti questo in un ciclo while e una dichiarazione verrà eseguita solo al minuto ... Ciò ti consente di eseguire una dichiarazione a intervalli predefiniti indipendentemente dal tempo impiegato dal comando (a patto che impieghi meno di un minuto o 5 o 60 o qualsiasi cosa tu abbia impostato su) Ad esempio, volevo eseguire un ping una volta al minuto. Se ho solo time.sleep(60) o time.sleep(45) pari, il ping non richiederà sempre lo stesso tempo. Ecco il codice :)

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

[5] estrae i secondi dal valore di ritorno time.localtime() .

La cosa bella di time.sleep è che supporta numeri in virgola mobile!

import time
time.sleep(0.1) 

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




Un po 'di divertimento con il generatore assonnato.

La domanda riguarda il ritardo temporale. Può essere fissato il tempo, ma in alcuni casi potremmo aver bisogno di un ritardo misurato dall'ultima volta. Ecco una possibile soluzione:

Ritardo misurato dall'ultima volta (svegliarsi regolarmente)

La situazione può essere, vogliamo fare qualcosa con la maggiore regolarità possibile e non vogliamo preoccuparci di tutte le cose last_time , next_time attorno al nostro codice.

generatore di cicalini

Il seguente codice ( sleepy.py ) definisce buzzergen gerenarator

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

Invocazione di buzzergen regolari

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

e eseguendolo vediamo:

1400102636.46
1400102639.46
1400102642.46
1400102647.47
1400102650.47

Possiamo anche usarlo direttamente in un ciclo:

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

e eseguendolo potremmo vedere:

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)

Come si vede, questo cicalino non è troppo rigido e ci consente di raggiungere intervalli regolari assonnati anche se dormiamo troppo ed evitiamo il normale orario.




Come posso creare un ritardo temporale in Python?

In un singolo thread suggerisco la funzione sleep:

>>> from time import sleep

>>> sleep(4)

Questo in effetti sospende l'elaborazione del thread in cui viene chiamato dal sistema operativo, consentendo l'esecuzione di altri thread e processi mentre sta dormendo.

Usalo per questo scopo, o semplicemente per ritardare una funzione dall'esecuzione. Per esempio:

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

"Evviva!" stampato 3 secondi dopo che ho premuto Invio .

Esempio di utilizzo del sleep con più thread e processi

Ancora una volta, sleep sospende il thread: utilizza una potenza di elaborazione prossima a zero.

Per dimostrare, creare uno script come questo (l'ho provato per la prima volta in una shell Python 3.5 interattiva, ma i processi secondari non riescono a trovare la funzione party_later per qualche motivo):

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

Esempio di output da questo 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

multithreading

È possibile attivare una funzione da chiamare in un secondo momento in un thread separato con l'oggetto threading del Timer :

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

>>> 

La riga vuota indica che la funzione è stata stampata sul mio standard e che ho dovuto premere Invio per assicurarmi che fosse su un prompt.

L'aspetto positivo di questo metodo è che mentre il thread Timer era in attesa, sono stato in grado di fare altre cose, in questo caso, premendo Invio una volta - prima che la funzione fosse eseguita (vedere il primo prompt vuoto).

Non c'è un rispettivo oggetto nella libreria multiprocessing. Puoi crearne uno, ma probabilmente non esiste per un motivo. Un sottoprocesso ha molto più senso per un semplice timer rispetto a un intero processo secondario.




La libreria tkinter nella libreria standard Python è uno strumento interattivo che puoi importare. Fondamentalmente, puoi creare pulsanti, finestre e popup e cose che appaiono come finestre che puoi manipolare con il codice.

Se usi tkinter, NON UTILIZZARE TIME.SLEEP() perché TIME.SLEEP() il tuo programma. Questo è successo a me. Invece, utilizzare root.after() e sostituire i valori per molti secondi, con un millisecondo. Ad esempio, time.sleep(1) è equivalente a root.after(1000) in tkinter.

Altrimenti, time.sleep() , che molte risposte hanno indicato, che è la strada da percorrere.




Per ritardare è necessario importare il modulo time . E con quel modulo hai solo bisogno di scrivere:

time.sleep(The amount of time)

Ad esempio, se vuoi inserire un ritardo di un secondo prima che il computer esegua un'altra linea, devi inserire:

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

È tutto :)




Buona domanda.

Puoi ottenerlo semplicemente facendo questo:

from time import sleep

# doing stuff
sleep(0.5) # sleeping half a second (sleep() uses seconds, but you can also use floats)
# doing stuff..

Spero, potrei aiutare.




i ritardi sono fatti con la libreria del tempo , in particolare la funzione time.sleep () ...

Per farlo aspettare un attimo:

from time import sleep
sleep(1)

Questo funziona perché facendo:

from time import sleep

estrai la funzione sleep solo dalla libreria time, il che significa che puoi chiamarla semplicemente con:

sleep(seconds)

piuttosto che dover digitare:

time.sleep()

che è goffamente lungo da digitare.

Con questo metodo, non si otterrà l'accesso alle altre funzionalità della libreria di orari e non si può avere una variabile chiamata sleep. ma potresti creare una variabile chiamata time.

Fare da [library] import [function] (, [function2]) è grandioso se vuoi solo certe parti di un modulo.

Potresti farlo ugualmente come:

import time
time.sleep(1)

e avresti accesso alle altre funzionalità della libreria di orari come time.clock () finché scrivi il tempo. funzione ma non è possibile creare il tempo variabile.




I ritardi possono essere implementati utilizzando tre metodi.

Iniziamo con quello più semplice:

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

Il secondo metodo per ritardare sarebbe utilizzare il metodo di attesa implicito.

 driver.implicitly_wait(5)

Il terzo metodo è più utile quando devi attendere fino al completamento di una determinata azione o fino a quando non viene trovato un elemento.

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



Utilizzando pygame

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