introduzione
Lo scopo di questo articolo è di introdurci al cronométralo Biblioteca.
Supponiamo di voler misurare il tempo di esecuzione di un frammento di codice. Cosa fa per vivere? Fino ad ora, Mi piace che la maggior parte delle persone faccia qualcosa del genere:
tempo di importazione
start_time = ora.ora()
"""Un po' di codice"""
end_time = time.time()
Stampa(F"Il tempo di esecuzione è: {end_time-start_time}")
Ora diciamo di voler confrontare i tempi di esecuzione di due diverse funzioni, dopo:
tempo di importazione def funzione_1(*parametri): #fare qualcosa # valore di ritorno def funzione_2(*parametri): #fare qualcosa #valore di ritorno #misurazione del tempo impiegato dalla funzione_1 start_of_f1 = time.time() valore1 = funzione_1(*parametri) end_of_f1 = time.time() Stampa(f”Il tempo impiegato dalla funzione_1 è:{start_of_f1-end_of_f1}")#misurare il tempo preso da function_2 start_of_f2 = time.time() valore2 = funzione_1(*parametri) end_of_f2 = time.time()Stampa(f”Il tempo impiegato dalla funzione_1 è:{inizio_di_f2-fine_di_f2}")
Questo è il modo in cui la maggior parte delle persone misura i tempi di esecuzione e confronta due funzioni.
tuttavia, se dobbiamo misurare il tempo necessario per un pezzo di codice molto piccolo, questo metodo non produce risultati accurati. Persino, quando si confrontano le funzioni, tutti gli altri processi e attività che si verificano nel sistema operativo lo stanno rovinando tempo tempo() esempio. Perciò, non accurato quando si confrontano le funzioni.
Per affrontare questo problema, Python ha un cronométralo modulo che ha lo scopo di misurare i tempi di esecuzione di frammenti di codice piccoli e grandi. Qui, in questo articolo, diamo prima un'occhiata cronométralo libreria in Python usando alcuni esempi.
Primo, diamo un'occhiata alla tua panoramica come fornita nel documentazione.
timeit in Python
Questo modulo fornisce un modo semplice per cronometrare piccoli frammenti di codice Python. Ha sia a Interfaccia a riga di comando così come un invocabile uno. Evita una serie di errori comuni per misurare i tempi di esecuzione.
Questo modulo ha una funzione, timeit.timeit (stmt = pasar, setup = pass, timer = , numero = 1000000) .Questa funzione accetta quattro argomenti:
- stmt: Il frammento di codice i cui tempi di esecuzione devono essere misurati.
- collocamento: Il codice da eseguire prima dell'esecuzione stmt. In genere, è usato per importare alcuni moduli o dichiarare alcune variabili necessarie. Diventerà più chiaro con gli esempi.
- Timer: È un oggetto timeit.Timer predefinito. Ha un valore predefinito ragionevole, quindi non dobbiamo fare molto al riguardo.
- numero: Specificare il numero di volte stmt sarà eseguito.
Tornerà il tempo necessario (in secondi) eseguire il stmt, la specificata numero volte.
Vediamo alcuni esempi per capirlo meglio.
importa ora
#Questo codice verrà eseguito solo una volta, prima di stmt.
setup_code = "from math import sqrt"
#Questo codice verrà eseguito come specificato dal parametro 'numero'
codice_stmt = "somma(sqrt(X) per x nell'intervallo(1,10000))"
iterazioni = 10000
time = timeit.timeit(stmt = stmt_code, setup = setup_code, numero = iterazioni)
Stampa(tempo)
#17.9 secondi
#QUESTO USCITO È PER 10000 ITERAZIONI DELLO SNIPPET DI CODICE E NON UNA SINGOLA ITERAZIONE.
Stampa(F"Il tempo per la singola iterazione è {tempo/iterazioni}")
Tutto quello che abbiamo fatto è stato passare il codice come una stringa e specificare il numero di iterazioni al timeit.timeit funzione.
Ora vediamo un modo per usare questa fantastica libreria per confrontare due funzioni.
Per questo esempio, confrontiamo due funzioni di ordinamento, uno è un semplice ordinamento a bolle e l'altro è la funzione integrata di Python ordinato () funzione. Qui ne vedremo anche un altro cronométralo funzione di chiamata ripetere().
def bubble_sort(arr):
per io nel raggio d'azione(len(arr)):
per j nell'intervallo(0, len(arr) - io - 1):
se arr[J] > arr[J + 1]:
arr[J], arr[J + 1] = arr[J + 1], arr[J]
ritorno ar
def make_random_array():
da importazione casuale randint
Restituzione [datazione(-100, 100) per io nel raggio d'azione(20)]
test_array = make_random_array()
'''
Dal momento che vogliamo assicurarci di testare le nostre funzioni sullo stesso array, stiamo dichiarando un array
qui e in seguito lo chiameremo in compare_functions().
'''
def confronta_funzioni():
importa ora
setup_code1 = """
da __main__ import bubble_sort
da __main__ import test_array
"""
setup_code2 = """
da __main__ import test_array
"""
stmt_code1 = "bubble_sort(test_array)"
stmt_code2 = "smistato(test_array)"
times1 = timeit.repeat(stmt=stmt_code1, setup=setup_code1, numero=10000, ripetizione=5)
times2 = timeit.repeat(stmt=stmt_code2, setup=setup_code2, numero=10000, ripetizione=5)
Stampa(F"Il tempo impiegato dal bubble sort è {min(volte1)}")
Stampa(F"Il tempo impiegato dall'ordinamento integrato è {min(volte2)}")
se __nome__ == "__principale__":
compare_funzioni()
"""
Il tempo impiegato dal bubble sort è 0.2646727000001192
Il tempo impiegato dall'ordinamento integrato è 0.0031973000000107277
"""
Qui, l'output è il valore minimo nell'elenco. volte1 e volte 2.
Nel codice di configurazione, abbiamo avuto,
da __main__ import bubble sort da __main__ import arrQuesto importa la funzione bubble_sort già definita nel nostro programma e importa anche l'array 'test_array' che abbiamo dichiarato nel programma in precedenza. Ciò assicurerà che entrambe le funzioni siano testate sullo stesso array, 'test_array'.
timeit.repeat () prendi un parametro aggiuntivo, ripetere (valore predefinito = 5). Questo restituisce un elenco di runtime di frammenti di codice ripetuti più volte.
Come previsto, il tempo necessario per lo smistamento delle bolle è molto più lungo del tempo ordinato () funzione.
Ora, finire, vediamo come possiamo usare l'interfaccia a riga di comando in questa libreria.
Quando viene chiamato come programma dalla riga di comando, viene utilizzato il seguente modulo:
python -m timeit [-n N] [-r N] [-u u] [-s S][dichiarazione ...]
Qui,
- -n N, quante volte verrà eseguita l''istruzione'.
- -r N, quante volte ripetere
- -ss, dichiarazione di configurazione
- -uu, unità di uscita del timer, (nano, micro, mille, seg)
Alcuni esempi come:
$ python -m timeit -s 'testo = "stringa di esempio"; carattere = "G"' 'carattere nel testo'
5000000 loop, il meglio di 5: 0.0877 usec per ciclo
$ python -m timeit -s 'testo = "stringa di esempio"; carattere = "G"' 'testo.trova(char)'
1000000 loop, il meglio di 5: 0.342 usec per ciclo
Questo conclude l'introduzione del modulo timeit. Ho cercato di coprire tutto ciò che è necessario sapere per iniziare a utilizzare questo modulo d'ora in poi.
Ecco il documentazione ufficiale del modulo. Dai un'occhiata per saperne di più su questo modulo. Ti incoraggio anche a dare un'occhiata al codice sorgente di questo modulo. qui.
Spero che tu abbia imparato qualcosa da questo articolo e, di seguito, puoi usare la funzionalità di questo modulo nel tuo codice. Paz.
Circa l'autore
Kushagra Bansal
Sono uno studente universitario laureando in Matematica e sono uno studente appassionato con un vivo interesse per l'Informatica e l'Astrofisica. Mi identifico come uno studente veloce e credo nell'imparare facendo. Nuove tecnologie come l'apprendimento automatico, il apprendimento profondoApprendimento profondo, Una sottodisciplina dell'intelligenza artificiale, si affida a reti neurali artificiali per analizzare ed elaborare grandi volumi di dati. Questa tecnica consente alle macchine di apprendere modelli ed eseguire compiti complessi, come il riconoscimento vocale e la visione artificiale. La sua capacità di migliorare continuamente man mano che vengono forniti più dati lo rende uno strumento chiave in vari settori, dalla salute... e visione artificiale, eccetera., sono davvero colpito. Mi piace molto anche leggere.
