Questo tutorial ti insegnerà come utilizzare la funzione sleep() dal modulo time integrato di Python per aggiungere ritardi temporali al codice.
Quando esegui un semplice programma Python, l’esecuzione del codice avviene in sequenza, un’istruzione dopo l’altra, senza alcun ritardo. Tuttavia, in alcuni casi potrebbe essere necessario ritardare l’esecuzione del codice. La funzione sleep() del modulo time integrato di Python ti aiuta a farlo.
In questo tutorial imparerai la sintassi dell’uso della funzione sleep() in Python e diversi esempi per capire come funziona. Iniziamo!
Sommario:
Sintassi di Python time.sleep()
Il modulo time, integrato nella libreria standard di Python, fornisce diverse utili funzioni relative al tempo. Come primo passo, importa il modulo orario nel tuo ambiente di lavoro:
import time
Poiché la funzione sleep() fa parte del modulo time, ora puoi accedervi e utilizzarla con la seguente sintassi generale:
time.sleep(n)
Qui, n è il numero di secondi per dormire. Può essere un numero intero o un numero in virgola mobile.
A volte il ritardo richiesto può essere di pochi millisecondi. In questi casi è possibile convertire la durata in millisecondi in secondi e utilizzarla nella chiamata alla funzione sleep. Ad esempio, se si desidera introdurre un ritardo di 100 millisecondi, è possibile specificarlo come 0,1 secondi: time.sleep(0.1).
▶ È inoltre possibile importare solo la funzione sleep dal modulo orario:
from time import sleep
Se utilizzi il metodo precedente per l’importazione, puoi chiamare direttamente la funzione sleep(), senza utilizzare time.sleep().
Ora che hai imparato la sintassi della funzione sleep() di Python, codifichiamo degli esempi per vedere la funzione in azione. Puoi scaricare gli script Python usati in questo tutorial dalla cartella python-sleep in questo repository GitHub. 👩🏽💻
Ritarda l’esecuzione del codice con sleep()
Come primo esempio, usiamo la funzione sleep per ritardare l’esecuzione di un semplice programma Python.
Nel seguente frammento di codice:
- La prima istruzione print() viene eseguita senza alcun ritardo.
- Introduciamo quindi un ritardo di 5 secondi utilizzando la funzione sleep().
- La seconda istruzione print() verrà eseguita solo al termine dell’operazione sleep.
# /python-sleep/simple_example.py
import time
print("Print now")
time.sleep(5)
print("Print after sleeping for 5 seconds")
Ora esegui il file simple_example.py e osserva l’output:
$ python3 simple_example.py
Aggiungi diversi ritardi a un blocco di codice
Nell’esempio precedente, abbiamo introdotto un ritardo fisso di 5 secondi tra l’esecuzione di due istruzioni print(). Quindi, codifichiamo un altro esempio per introdurre diversi tempi di ritardo durante il ciclo di un iterabile.
In questo esempio, vorremmo fare quanto segue:
- Passa attraverso una frase, accedi a ogni parola e stampala.
- Dopo aver stampato ogni parola, vorremmo attendere un periodo di tempo specifico, prima di stampare la parola successiva nella frase.
Looping attraverso una stringa di stringhe
Considera la stringa, la frase. È una stringa in cui ogni parola è una stringa in sé.
Se eseguiamo un ciclo della stringa, otterremo ogni carattere, come mostrato:
>>> sentence = "How long will this take?" >>> for char in sentence: ... print(char) # Output (truncated for readability) H o w . . . t a k e ?
Ma non è questo che vogliamo. Vorremmo scorrere la frase e accedere a ogni parola. Per fare ciò, possiamo chiamare il metodo split() sulla stringa della frase. Ciò restituirà un elenco di stringhe, ottenuto dividendo la stringa della frase, su tutte le occorrenze di spazi bianchi.
>>> sentence.split() ['How', 'long', 'will', 'this', 'take?'] >>> for word in sentence.split(): ... print(word) # Output How long will this take?
Looping attraverso iterabili con ritardi diversi
Rivediamo l’esempio:
- frase è la stringa che vorremmo scorrere per accedere a ciascuna parola.
- delay_times è l’elenco dei tempi di ritardo che useremo come argomento della funzione sleep() durante ogni passaggio del ciclo.
Qui vorremmo scorrere contemporaneamente due liste: la lista delay_times e la lista di stringhe ottenute dividendo la stringa della frase. È possibile utilizzare la funzione zip() per eseguire questa iterazione parallela.
La funzione Python zip(): zip(list1, list2) restituisce un iteratore di tuple, dove ogni tupla contiene l’elemento all’indice i in list1 e list2.
# /python-sleep/delay_times.py
import time
sleep_times = [3,4,1.5,2,0.75]
sentence = "How long will this take?"
for sleep_time,word in zip(sleep_times,sentence.split()):
print(word)
time.sleep(sleep_time)
Senza la funzione sleep, il controllo procederebbe immediatamente all’iterazione successiva. Poiché abbiamo introdotto un ritardo, il passaggio successivo nel ciclo avviene solo dopo che l’operazione di sospensione è stata completata.
Ora esegui delay_times.py e osserva l’output:
$ python3 delay_times.py
Le parole successive nella stringa verranno stampate dopo un certo ritardo. Il ritardo dopo la stampa della parola all’indice i nella stringa è il numero all’indice i nell’elenco delay_times.
Conto alla rovescia in Python
Come prossimo esempio, codifichiamo un semplice conto alla rovescia in Python.
Definiamo una funzione countDown():
# /python-sleep/countdown.py
import time
def countDown(n):
for i in range(n,-1,-1):
if i==0:
print("Ready to go!")
else:
print(i)
time.sleep(1)
Successivamente, analizziamo la definizione della funzione countDown():
- La funzione accetta un numero n come argomento e conta fino a zero partendo da quel numero n.
- Usiamo time.sleep(1) per ottenere un ritardo di un secondo tra i conteggi.
- Quando il conteggio raggiunge lo 0, la funzione stampa “Pronto a partire!”.
🎯 Per eseguire l’operazione di conto alla rovescia, abbiamo utilizzato la funzione range() con un valore di incremento negativo di -1. range(n, -1, -1) ci aiuterà a scorrere l’intervallo di numeri in n, n – 1, n – 2 e così via fino a zero. Ricordiamo che il punto finale è escluso per impostazione predefinita quando si utilizza la funzione range().
Quindi aggiungiamo una chiamata alla funzione countDown() con 5 come argomento.
countDown(5)
Ora esegui lo script countdown.py e guarda la funzione countDown in azione!
$ python3 countdown.py
Funzione Sleep nel multithreading
Il modulo di threading Python offre funzionalità di multithreading pronte all’uso. In Python, il Global Interpreter Lock o GIL assicura che ci sia un solo thread attivo in esecuzione in qualsiasi momento.
Tuttavia, durante le operazioni di I/O e le operazioni di attesa come la sospensione, il processore può sospendere l’esecuzione del thread corrente e passare a un altro thread in attesa.
Per capire come funziona, facciamo un esempio.
Creazione ed esecuzione di thread in Python
Considera le seguenti funzioni, func1(), func2() e func3(). Passano in rassegna una serie di numeri e li stampano. Questo è seguito da un’operazione di sospensione, per un numero specifico di secondi, durante ogni passaggio attraverso il ciclo. Abbiamo utilizzato diversi tempi di ritardo per ciascuna delle funzioni per comprendere meglio come l’esecuzione passa da un thread all’altro contemporaneamente.
import time
def func1():
for i in range(5):
print(f"Running t1, print {i}.")
time.sleep(2)
def func2():
for i in range(5):
print(f"Running t2, print {i}.")
time.sleep(1)
def func3():
for i in range(4):
print(f"Running t3, print {i}.")
time.sleep(0.5)
In Python, puoi usare il costruttore Thread() per istanziare un oggetto thread. Utilizzando la sintassi threading.Thread(target = …, args = …) crea un thread che esegue la funzione target con l’argomento specificato nella tupla args.
In questo esempio le funzioni, func1, func2 e func3, non accettano argomenti. Quindi è sufficiente specificare solo il nome della funzione come target. Definiamo quindi gli oggetti thread, t1, t2 e t3 con rispettivamente func1, func2 e func3 come target.
t1 = threading.Thread(target=func1) t2 = threading.Thread(target=func2) t3 = threading.Thread(target=func3) t1.start() t2.start() t3.start()
Ecco il codice completo per l’esempio di threading:
# /python-sleep/threads.py
import time
import threading
def func1():
for i in range(5):
print(f"Running t1, print {i}.")
time.sleep(2)
def func2():
for i in range(5):
print(f"Running t2, print {i}.")
time.sleep(1)
def func3():
for i in range(4):
print(f"Running t3, print {i}.")
time.sleep(0.5)
t1 = threading.Thread(target=func1)
t2 = threading.Thread(target=func2)
t3 = threading.Thread(target=func3)
t1.start()
t2.start()
t3.start()
Osservare l’output. L’esecuzione cambia tra i tre thread. Il thread t3 ha il tempo di attesa più basso, quindi viene sospeso per il minor tempo possibile. Il thread t1 ha la durata di sospensione più lunga di due secondi, quindi è l’ultimo thread a terminare l’esecuzione.
Per saperne di più, leggi il tutorial sulle basi del multithreading in Python.
Conclusione
In questo tutorial, hai imparato come usare la funzione sleep() di Python per aggiungere ritardi temporali al codice.
Puoi accedere alla funzione sleep() dal modulo time integrato, time.sleep(). Per ritardare l’esecuzione di n secondi, utilizzare time.sleep(n). Inoltre, hai visto esempi di ritardare le successive iterazioni in un ciclo con valori diversi, conto alla rovescia e multithreading.
Ora puoi esplorare funzionalità più avanzate del modulo temporale. Vuoi lavorare con date e orari in Python? Oltre al modulo orario, puoi sfruttare la funzionalità dei moduli data/ora e calendario.
Successivamente, impara a calcolare la differenza di fuso orario in Python.⏰