Eii, bentornato sul mio blog. Oggi ti andrò a mostrare un modo carino e semplice da implementare per cronometrare i tempi di esecuzione del tuo codice Python.

Andrò a creare una classe istanziabile all’interno di qualsiasi altro file Python e creerò dei metodi per far partire il cronometro, stopparlo ed infine stampare un messaggio con il tempo dell’esecuzione.

1. Perché cronometrare il codice?

Cronometrare il proprio codice può essere molto utile nel momento in cui dobbiamo andare a fare degli interventi di ottimizzazione di alcune funzioni che impiegano troppo tempo per essere eseguite.

Questo tutorial è più da intendersi come esercizio in quanto è interessante (secondo me) capire la logica che c’è dietro più che il “come è implementato”.

Capendo i ragionamenti alla base è possibile implementare lo stesso algoritmo con altri linguaggi di programmazione, il tutorial è stato scritto in Python solo per comodità.

2. Capiamo l’algoritmo

Il principio alla base è molto semplice, per calcolare il tempo trascorso tra l’inizio di una funzione e la sua fine verranno istanziati due oggetti di tipo “date time” che rappresentano uno snapshot del momento in cui l’oggetto viene creato. Successivamente si trasformeranno i due “snapshot” in millisecondi e si andrà ad effettuare la differenza tra il secondo snapshot (quello rappresentante la fine della funzione) ed il primo snapshot (rappresentante l’inizio della funzione), così facendo otteniamo precisamente il tempo in millisecondi trascorso tra l’inizio della funzione e la fine della stessa.

3. Passiamo al codice

Qui di seguito ti vado ad incollare il codice dell’intera classe che rappresenta il cronometro

import time

"""
Cronometer class useful for check the execution
time of functions in any Python code
"""
class ChronoMeter():

    # properties
    start_time = 0
    end_time = 0

    """
    Method to start the cronometer
    """
    def start_chrono(self):
        self.start_time = self.current_milli_time()

    """
    Method for stopping chronometer
    """
    def stop_chrono(self):
        self.end_time = self.current_milli_time()

    """
    Method that return the execution time,
    the difference between end time and
    start time
    """
    def get_execution_time(self):
        return self.end_time - self.start_time

    """
    Method that print the execution time
    """
    def print_time(self):
        print(f"execution time: {self.get_execution_time()} ms")
    
    """
    Method that return the current time in 
    milliseconds
    """
    def current_milli_time(self):
        return round(time.time() * 1000)

Qui invece ti vado ad incollare un codice di test sul quale voglio effettuare una misurazione dei tempi di esecuzione.

from cronometer import ChronoMeter
import time

chrono = ChronoMeter()

chrono.start_chrono()

for i in range(1, 99999):
    print(i)

chrono.stop_chrono()
chrono.print_time()

Qui invece vediamo l’esecuzione del software. Come puoi notare, viene istanziato un oggetto di tipo ChronoMeter, viene invocato il metodo start_chrono(), viene eseguito il codice di esempio ed infine viene invocato il metodo stop_chrono() per fermare il cronometro. Infine viene invocato il metodo print_time() per comunicare all’utente il tempo finale.

Da notare il messaggio che recita “execution time: 313 ms”, quel messaggio viene creato dalla classe cronometro.

4. Conclusioni

Questo breve tutorial finisce qui, ti ho mostrato un metodo che uso io per cronometrare quanto tempo impiega il mio codice per essere eseguito.

Se hai idee migliori per cronometrare il codice oppure vuoi chiedermi qualcosa a riguardo non farti problemi a lasciare un commento qui sotto.

ciao e alla prossima 🙂


0 commenti

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *