Faccio questo breve accenno, per caso ho voluto quantificare la differenza del tempo di esecuzione fra due script Python, semplici, che in realtà facevano parte di un progetto più ampio, benchmark di performance fra diversi linguaggi di programmazione.
Questo esempio è semplicemente l'algoritmo di risoluzione numerica (approssimata) dell'integrale di una distribuzione gaussiana (media nulla, deviazione standard unitaria), giusto per eseguire delle operazioni e poi confrontare il tempo di esecuzione del programma (media fra più dati misurati) a seconda di come viene scritto l'algoritmo.
- caso 1: codice Python "standard" - tempo medio 2,95 secondi
import time
import numpy as np
start=time.time()
ris=0
N=10**6
a=0
b=20
h=(b-a)/N
def f(x):
return 1/(2*np.pi)*np.exp(-x**2/2)
for i in range(0,N):
ris+=h*f(a+i*h)
end=time.time()
print(end-start,"s")
- caso 2: codice Python senza libreria esterna: tempo medio 0,49 secondi
import time
start=time.time()
ris=0
N=10**6
a=0
b=20
h=(b-a)/N
def f(x):
return 1/(2*3.141592653589793)*2.718281828459045**(-x**2/2)
for i in range(N):
ris+=h*f(a+i*h)
end=time.time()
print(end-start,"s")
- caso 3: codice Python migliorato, senza definire una funzione - tempo medio: 0,36 secondi
import time
start=time.time()
ris=0
N=10**6
a=0
b=20
h=(b-a)/N
for i in range(N):
ris+=2.718281828459045**(-0.5*(a+i*h)**2)
ris*=h*1/(2*3.141592653589793)**0.5
end=time.time()
print(end-start,"s")
Risultati:in poche parole, anche un linguaggio interpretato e ad alto livello come Python, si può ottenre un'efficienza del codice "accettabile". Senza pensarci, uno potrebbe includere la libreria Numpy che definisce i valori di Pi greco e Nepero, dovendoli richiamare poi ad ogni iterazione del ciclo (in questo caso 106 = un milione di volte!!). Piccole migliorie poi - anche se peggiorano la leggibilità del codice, quindi dipende dal singolo caso, quando opportuno - sono ad esempio scrivere tutto in blocco (caso 3) piuttosto che richiamare ua funzione. Comunque, il confronto fra i tempi di esecuzione 2,95|0,49|0,36 rende l'idea. Ovviamente qui abbiamo un numero limitato di iterazioni, se l'algoritmo fosse più pesante, il tempo di esecuzione maggiore, il caso 1 impiegherebbe comunque circa 8 volte più tempo rispetto al caso 3! Quindi una differenza notevole!
Ho detto che questo esempio faceva parte di uno studio più esteso. Ebbene, giusto per fare un confronto, un linguaggio compilato come il C (la maggiore efficienza computazionale in assoluto!) genera un tempo di esecuzione medio di 0,044s, vale a dire 8,2 volte più efficiente del caso 3 (il migliore di Python) e 67 volte migliore del caso 1. Quindi ben altro livello 🙂 prestare attenzione anche all'efficienza di un linguaggio interpretato (Python, ma anche gli altri) prendendo spunto da questi esempi, comunque può portare notevoli miglioramenti!