Funzione Python time.sleep()

In questo tutorial scoprirai la funzione Python sleep(), che ti permette di introdurre un ritardo nell'esecuzione del programma. È una funzione utile soprattutto quando il tuo programma lavora con thread o quando ti occupi di grafica e animazioni. La funzione sleep è disponibile all'interno del modulo time, che contiene molte altre funzioni per l'accesso e le conversioni relative al tempo. Anche se questo modulo è disponibile su tutte le piattaforme, non tutte le funzioni al suo interno potrebbero essere disponibili o funzionare esattamente allo stesso modo. Vediamo più nel dettaglio il modulo time.sleep()...

Modulo time

Questo modulo fornisce funzioni che aiutano a manipolare il tempo e a usarlo nel tuo programma. Esistono altri moduli "cugini" che lavorano in modo più preciso con la data e il calendario del tuo sistema, ma questo modulo è più focalizzato sulla sola manipolazione del tempo, lavorando con le ore fino ai millisecondi.

Uno dei termini che sentirai spesso quando lavori con il tempo nel mondo dell'informatica è epoch.

Ma prima, assicurati di importare il modulo time. Per farlo, ti basta digitare:

import time

epoch

Questo è il punto preciso in cui il tempo ha avuto inizio. Non significa la nascita del nostro sistema solare o quando l'uomo ha iniziato a misurare il tempo, ma è in realtà relativamente vicino a oggi. Per i sistemi UNIX, l'epoch è il 1° gennaio 1970, 00:00:00 (UTC) (Era un giovedì, nel caso te lo stessi chiedendo...) Per scoprire l'epoch sul tuo sistema puoi digitare:

time.gmtime(0)

time.struct_time(tm_year=1970, tm_mon=1, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=1, tm_isdst=0)

Questo ti dirà l'anno (tm_year), il mese (tm_mon), il giorno (tm_mday), l'ora (tm_hour), il minuto (tm_min) e il secondo (tm_sec). Insieme al giorno della settimana (tm_wday) - è 3 poiché il lunedì è considerato l'inizio della settimana ed è contato come 0. Poi è seguito dal giorno dell'anno (tm_yday), noto anche come giorno giuliano. E infine, il flag dell'ora legale (tm_isdst) - DST sta per daylight saving time (ora legale). Questo campo può valere 0, -1 o 1. 0 se l'ora legale non è in vigore. 1 se l'ora legale è in vigore e infine -1 se l'informazione non è disponibile. Perché non disponibile, ti chiedi? Perché le regole dell'ora legale sono determinate dalle leggi locali e possono cambiare.

La maggior parte dei computer memorizza data e ora come differenza in secondi tra il 1° gennaio 1970, 00:00:00 (UTC) e il momento da memorizzare. Quindi, se digiti:

time.time()

1548611182.872067

Questo ti dirà i secondi trascorsi dal 1° gennaio 1970, 00:00:00 (UTC). Questa differenza è ciò che chiamiamo timestamp o tempo epoch UNIX, ed è sotto forma di numero in virgola mobile. Be'... a dire il vero, la differenza non è in termini di secondi, ma di qualcosa chiamato tick. In molti sistemi UNIX, l'orologio "ticchetta" da 50 a 100 volte in un secondo. Quindi, il tempo epoch UNIX è in realtà il numero di tick avvenuti dal 1° gennaio 1970, 00:00:00 UTC.

Ora che hai un'idea di cosa fa il modulo time, diamo un'occhiata alla funzione sleep().

time.sleep()

Semplicemente, time.sleep() accetta come argomento il numero di secondi per cui vuoi sospendere l'esecuzione del programma prima che prosegua al passaggio successivo. Vediamolo con l'aiuto di un semplice programma, in cui stampiamo l'ora corrente introducendo una pausa di 5 secondi tra una esecuzione e l'altra, creando quindi una differenza di 5 secondi tra ogni stampa dell'ora corrente. Usare time.ctime() aiuta a vedere l'ora locale in un formato ben leggibile.

for count in range(5):
    print(time.ctime())
    # Prints the current time with a five second difference
    time.sleep(5)

Sun Jan 27 18:46:24 2019
Sun Jan 27 18:46:29 2019
Sun Jan 27 18:46:34 2019
Sun Jan 27 18:46:39 2019
Sun Jan 27 18:46:44 2019

La sintassi della funzione è: time.sleep(sec) dove sec è l'argomento che specifica per quanti secondi il programma deve essere sospeso. La funzione non restituisce alcun valore.

sec - L'argomento è in realtà un numero in virgola mobile, quindi puoi rendere il tempo di sospensione più preciso. Tuttavia, questo è un po' incerto perché il tempo di sospensione effettivo può essere inferiore a quello richiesto o arbitrariamente più lungo. Per capire meglio il perché, immagina il programma come un problema o un'attività gestita da un commesso diverso in un negozio: quando sospendi il programma, la persona che ci stava lavorando viene immediatamente assegnata a un altro cliente. Ma poco dopo (prima dei secondi di sleep specificati), un altro commesso libero riprende l'attività e la porta a termine, quindi il tempo di sospensione può essere inferiore. Allo stesso modo, il tempo di sospensione può essere più lungo del richiesto di una quantità arbitraria a causa della pianificazione delle attività per tutti i commessi nel negozio, e quindi il programma deve aspettare il suo turno. Internamente è ovviamente più complesso, e sono già stati introdotti molti modi per gestire questa situazione.

for count in range(3):
    print(time.ctime())
    # Prints the current time with a five second difference
    time.sleep(2.5)

Sun Jan 27 18:46:49 2019
Sun Jan 27 18:46:52 2019
Sun Jan 27 18:46:54 2019

Python non fornisce garanzie sul comportamento di queste chiamate di funzione, soprattutto in ambito multipiattaforma. Il motivo di fondo è che la maggior parte delle funzioni definite in questo modulo richiama funzioni della libreria C della piattaforma con lo stesso nome. L'accuratezza dipende davvero dall'accuratezza della funzione di sleep del sistema operativo sottostante e, se hai bisogno di approfondire, ti conviene consultare la documentazione della piattaforma, perché la semantica di queste funzioni varia tra le piattaforme.

C'è però una buona notizia: a partire da Python versione 3.5, time.sleep(secs) ora sospende per almeno secs (l'argomento passato) anche se lo sleep viene interrotto da un segnale (di nuovo, immagina il segnale come un commesso come discusso sopra), tranne nel caso in cui l'handler del segnale sollevi un'eccezione.

Cosa succede internamente quando usi time.sleep()?
Questa parte serve per comprendere meglio la funzione, ma non è necessaria per iniziare a usarla. La funzione utilizza effettivamente il System Clock, un dispositivo elettronico in un computer che emette un segnale stabile ad alta frequenza che sincronizza tutti i componenti interni ed è parte del processore. Questo modulo solleva quelli che sono chiamati Interrupt Requests (IRQ) a intervalli programmabili. Gli IRQ sono responsabili di interrompere il codice corrente che il processore sta eseguendo, salvando lo stato attuale prima di passare il controllo a un altro pezzo di codice nel sistema operativo.
Quindi, ciò che fa la funzione sleep() è chiamare una routine sottostante di completamento I/O o una chiamata di procedura asincrona per bloccare il processo. Il sistema operativo annoterà che non vuoi fare altro finché non viene raggiunto un periodo di timeout. Una volta raggiunto questo timeout, il sistema operativo riprenderà il tuo processo dallo stato precedente che ricorda. E dal tuo punto di vista è stata semplicemente effettuata una chiamata alla funzione time.sleep().

Complimenti per aver padroneggiato la funzione time.sleep(). Dai un'occhiata al corso Python Data Science Toolbox (Parte 1) di DataCamp per saperne di più sulle funzioni in Python.