turtle - Come posso creare un ritardo temporale in Python?




turtle sleep python (8)

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.

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


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

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 finché non viene trovato un elemento:

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

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 time.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 tempo.

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

Potresti ugualmente farlo come

import time
time.sleep(1)

e tu avresti accesso alle altre funzionalità della libreria temporale come time.clock() finché scrivi il time.[function]() , ma non puoi creare il tempo variabile.


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


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


Questo è un semplice esempio di ritardo temporale:

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

Un altro, in Tkinter:

import tkinter

def tick():
    pass

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

Un po 'di divertimento con un generator 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 buzzer

Il seguente codice ( sleepy.py ) definisce un generatore di 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

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 mentre lo eseguiamo 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 permette di raggiungere con intervalli regolari assonnati anche se dormiamo troppo e si esce dal normale orario.





timedelay