O que é um interpretador?

Digite python3 hello.py e a saída aparece, mas olhe a pasta depois: nenhum arquivo de programa novo foi criado. O programa que realmente executou foi o próprio python3, o interpretador Python. Ele leu hello.py, descobriu o que cada instrução significa e a executou. Rode o script de novo amanhã e o interpretador lê o código-fonte outra vez desde o começo.

Como um interpretador funciona

Um interpretador repete um ciclo até o programa terminar: pega a próxima instrução, descobre o que ela significa, executa, segue em frente. Enquanto trabalha, ele guarda as variáveis do programa na sua própria memória, e é por isso que total = price * 3 pode usar um price definido algumas linhas antes.

A forma mais clara de ver isso é o modo interativo, chamado REPL (read, evaluate, print, loop: ler, avaliar, imprimir, repetir). Digite python3 sem nome de arquivo e cada linha executa no momento em que você aperta Enter:

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

Interpretadores reais acrescentam uma etapa de preparação. O CPython, o interpretador Python padrão, primeiro compila o arquivo inteiro para bytecode, uma lista compacta de instruções simples, e depois roda um loop que executa esse bytecode uma instrução de cada vez. Você pode imprimir o bytecode de uma linha:

import dis

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

O Python 3.12 imprime o seguinte (outras versões diferem nos detalhes):

  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)

Cada uma dessas linhas é um passo do loop do interpretador: buscar o valor de price, buscar a constante 3, multiplicar os dois, guardar o resultado em total. Nada disso é código de máquina; o interpretador, que por sua vez é um programa C compilado, realiza cada passo.

Os erros aparecem quando a linha executa

Como um interpretador executa à medida que avança, um programa pode fazer trabalho real antes de chegar a um erro. Execute isto e as duas primeiras linhas são impressas antes da falha:

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

Um erro de sintaxe se comporta de outro jeito, porque o CPython compila o arquivo inteiro para bytecode antes de executar qualquer parte. Mude a linha 3 para print("Step 3:" 10) (falta a vírgula) e nada é impresso, nem mesmo o Step 1:

SyntaxError: invalid syntax. Perhaps you forgot a comma?

Então "um interpretador executa o código linha por linha" é só meia verdade. A gramática é verificada primeiro para o arquivo inteiro; todo o resto, como dividir por zero ou usar um nome que não existe, só é encontrado quando aquela linha executa. Veja erro de sintaxe para o primeiro tipo.

Compilador vs interpretador

Um compilador traduz o programa inteiro para um arquivo separado antes de ele executar. Um interpretador executa o próprio programa, toda vez. As diferenças práticas vêm daí:

A diferença de velocidade é real em loops apertados de aritmética: o mesmo loop pode executar muitas vezes mais rápido em C compilado do que no CPython. Em programas que passam a maior parte do tempo esperando a rede, o disco ou o usuário, a diferença muitas vezes é pequena demais para ser notada.

Compilado ou interpretado não é uma propriedade da linguagem

Uma linguagem é um conjunto de regras; o compilador ou o interpretador é um programa que as implementa. A mesma linguagem pode ser executada das duas formas, e a maioria das linguagens populares mistura as duas:

• Python. O CPython compila para bytecode e o interpreta. O PyPy, outra implementação, adiciona um compilador just-in-time (JIT) que transforma em código de máquina o código executado com frequência enquanto o programa roda.
• Java. O javac compila o código-fonte para bytecode antecipadamente. A Máquina Virtual Java então interpreta esse bytecode e compila por JIT os métodos mais usados para código de máquina. Desde o Java 11, java Main.java executa um único arquivo de código-fonte diretamente, compilando-o antes na memória.
• JavaScript. Navegadores e o Node.js usam motores como o V8, que começam interpretando o código e compilam as partes mais usadas para código de máquina enquanto o programa executa.
• C e C++. Quase sempre compilados antecipadamente com GCC, Clang ou 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

Seja qual for o caso, o interpretador ou a máquina virtual faz parte do ambiente de execução do programa: ele precisa estar instalado onde quer que o programa execute.

Equívocos comuns

• "Um interpretador traduz cada linha para código de máquina." Um interpretador clássico nunca gera código de máquina para o seu programa. Ele lê uma instrução e a realiza usando código que já foi compilado dentro do interpretador. Gerar código de máquina em tempo de execução é o que um compilador JIT faz.
• "Linguagens interpretadas não têm etapa de compilação." CPython, o YARV do Ruby e o PHP compilam para bytecode primeiro. A etapa é automática e invisível, por isso é fácil não perceber.
• "Interpretado significa lento." A compilação JIT fechou boa parte da diferença. O V8 executa JavaScript rápido o bastante para aplicações grandes como o VS Code, que é construído sobre o Electron.
• "Python é o interpretador." Python é a linguagem. CPython, PyPy e MicroPython são interpretadores diferentes para ela, e podem variar em velocidade e nas bibliotecas que suportam.

Para onde ir agora

Para a outra metade da comparação, leia o que é um compilador e como ele transforma código-fonte em código de máquina. A página ambiente de execução explica o que mais o interpretador traz com ele. Para experimentar um interpretador, execute um script Python ou abra o playground de Python.