Cos'è un interprete?

Scrivi python3 hello.py e compare l'output, ma guarda nella cartella dopo: non è stato creato nessun nuovo file di programma. Il programma che è stato davvero eseguito è python3 stesso, l'interprete Python. Ha letto hello.py, ha capito cosa significa ogni istruzione e l'ha eseguita. Esegui di nuovo lo script domani e l'interprete rilegge il sorgente dall'inizio.

Come funziona un interprete

Un interprete ripete un unico ciclo finché il programma non finisce: prende l'istruzione successiva, capisce cosa significa, la esegue, passa oltre. Mentre lavora tiene le variabili del programma nella propria memoria, ed è per questo che total = price * 3 può usare un price impostato qualche riga prima.

Il modo più chiaro per vederlo è la modalità interattiva, chiamata REPL (read, evaluate, print, loop). Scrivi python3 senza nome di file e ogni riga viene eseguita appena premi Invio:

>>> price = 4
>>> price * 3
12

Gli interpreti reali aggiungono una fase di preparazione. CPython, l'interprete Python standard, prima compila tutto il file in bytecode, un elenco compatto di istruzioni semplici, e poi fa girare un ciclo che esegue quel bytecode un'istruzione alla volta. Puoi stampare il bytecode di una riga:

import dis

source = "total = price * 3"
code = compile(source, "<example>", "exec")
dis.dis(code)

Python 3.12 stampa quanto segue (le altre versioni differiscono nei dettagli):

  0           0 RESUME                   0

  1           2 LOAD_NAME                0 (price)
              4 LOAD_CONST               0 (3)
              6 BINARY_OP                5 (*)
             10 STORE_NAME               1 (total)
             12 RETURN_CONST             1 (None)

Ognuna di queste righe è un passo del ciclo dell'interprete: prendi il valore di price, prendi la costante 3, moltiplicale, salva il risultato in total. Niente di tutto questo è codice macchina; è l'interprete, che a sua volta è un programma C compilato, a eseguire ogni passo.

Gli errori emergono quando la riga viene eseguita

Siccome un interprete esegue man mano, un programma può fare lavoro vero prima di incontrare un errore. Esegui questo codice e le prime due righe vengono stampate prima del crash:

print("Step 1: starting")
print("Step 2: still fine")
print("Step 3:", 10 / 0)
print("Step 4: never reached")

Step 1: starting
Step 2: still fine
Traceback (most recent call last):
  ...
ZeroDivisionError: division by zero

Un errore di sintassi si comporta in modo diverso, perché CPython compila tutto il file in bytecode prima di eseguirne qualsiasi parte. Cambia la riga 3 in print("Step 3:" 10) (manca la virgola) e non viene stampato niente, nemmeno Step 1:

SyntaxError: invalid syntax. Perhaps you forgot a comma?

Quindi "un interprete esegue il codice riga per riga" è vero solo a metà. La grammatica viene controllata prima per tutto il file; tutto il resto, come dividere per zero o usare un nome che non esiste, viene scoperto solo quando quella riga viene eseguita. Vedi errore di sintassi per il primo tipo.

Differenza tra compilatore e interprete

Un compilatore traduce l'intero programma in un file separato prima che venga eseguito. Un interprete esegue il programma stesso, ogni volta. Le differenze pratiche derivano da questo:

La differenza di velocità è reale nei cicli stretti di calcoli: lo stesso ciclo può essere molte volte più veloce in C compilato che in CPython. Per i programmi che passano la maggior parte del tempo ad aspettare la rete, il disco o l'utente, la differenza spesso è troppo piccola per notarla.

Compilato o interpretato non è una proprietà del linguaggio

Un linguaggio è un insieme di regole; il compilatore o l'interprete è un programma che le implementa. Lo stesso linguaggio si può eseguire in entrambi i modi, e i più diffusi mescolano le due cose:

• Python. CPython compila in bytecode e lo interpreta. PyPy, un'altra implementazione, aggiunge un compilatore just-in-time (JIT) che trasforma in codice macchina il codice eseguito spesso mentre il programma gira.
• Java. javac compila il sorgente in bytecode in anticipo. La Java Virtual Machine poi interpreta quel bytecode e compila JIT in codice macchina i metodi più usati. Da Java 11, java Main.java esegue direttamente un singolo file sorgente compilandolo prima in memoria.
• JavaScript. I browser e Node.js usano motori come V8, che iniziano interpretando il codice e compilano in codice macchina le parti più usate mentre il programma gira.
• C e C++. Quasi sempre compilati in anticipo con GCC, Clang o MSVC.

python3 app.py            # Python: interpreter, bytecode behind the scenes
node app.js               # JavaScript: V8 interprets, then JIT-compiles
javac Main.java           # Java step 1: compile to Main.class
java Main                 # Java step 2: the JVM runs the bytecode

In ogni caso, l'interprete o la macchina virtuale fa parte dell'ambiente di runtime del programma: deve essere installato ovunque il programma venga eseguito.

Falsi miti comuni

• "Un interprete traduce ogni riga in codice macchina." Un interprete classico non produce mai codice macchina per il tuo programma. Legge un'istruzione e la esegue usando codice che era già stato compilato dentro l'interprete. Produrre codice macchina durante l'esecuzione è ciò che fa un compilatore JIT.
• "I linguaggi interpretati non hanno una fase di compilazione." CPython, YARV di Ruby e PHP compilano tutti prima in bytecode. La fase è automatica e invisibile, quindi è facile non accorgersene.
• "Interpretato significa lento." La compilazione JIT ha colmato gran parte della distanza. V8 esegue JavaScript abbastanza velocemente per applicazioni grandi come VS Code, che è costruito su Electron.
• "Python è l'interprete." Python è il linguaggio. CPython, PyPy e MicroPython sono interpreti diversi per quel linguaggio, e possono differire per velocità e per le librerie che supportano.

Cosa leggere dopo

Per l'altra metà del confronto, leggi cos'è un compilatore e come trasforma il codice sorgente in codice macchina. La pagina sull'ambiente di runtime spiega cos'altro porta con sé l'interprete. Per provare un interprete in prima persona, esegui uno script Python o apri il playground Python.