Até eu tive o mesmo problema ao entender como CPython, JPython, IronPython, PyPy são diferentes entre si.
Então, estou disposto a esclarecer três coisas antes de começar a explicar:
- Pitão : é uma linguagem, apenas afirma / descreve como se comunicar / se expressar para o intérprete (o programa que aceita seu código python).
- Implementação : trata-se de como o intérprete foi escrito, especificamente, em qual idioma e o que ele acaba fazendo .
- Bytecode : é o código que é processado por um programa, geralmente chamado de máquina virtual, e não pela máquina de computador "real", o processador de hardware.
CPython é a implementação, que foi escrita em linguagem C. Ele acaba produzindo bytecode (conjunto de instruções baseado em máquina de pilha), que é específico do Python e depois o executa. O motivo para converter o código Python em um bytecode é porque é mais fácil implementar um intérprete se parecer com instruções da máquina. Mas, não é necessário produzir algum bytecode antes da execução do código Python (mas o CPython produz).
Se você quiser examinar o bytecode do CPython, poderá. Veja como você pode:
>>> def f(x, y): # line 1
... print("Hello") # line 2
... if x: # line 3
... y += x # line 4
... print(x, y) # line 5
... return x+y # line 6
... # line 7
>>> import dis # line 8
>>> dis.dis(f) # line 9
2 0 LOAD_GLOBAL 0 (print)
2 LOAD_CONST 1 ('Hello')
4 CALL_FUNCTION 1
6 POP_TOP
3 8 LOAD_FAST 0 (x)
10 POP_JUMP_IF_FALSE 20
4 12 LOAD_FAST 1 (y)
14 LOAD_FAST 0 (x)
16 INPLACE_ADD
18 STORE_FAST 1 (y)
5 >> 20 LOAD_GLOBAL 0 (print)
22 LOAD_FAST 0 (x)
24 LOAD_FAST 1 (y)
26 CALL_FUNCTION 2
28 POP_TOP
6 30 LOAD_FAST 0 (x)
32 LOAD_FAST 1 (y)
34 BINARY_ADD
36 RETURN_VALUE
Agora, vamos dar uma olhada no código acima. As linhas 1 a 6 são uma definição de função. Na linha 8, importamos o módulo 'dis' que pode ser usado para visualizar o bytecode intermediário do Python (ou você pode dizer, desmontador do bytecode do Python) gerado pelo CPython (intérprete).
NOTA : Eu obtive o link para esse código no canal #python IRC: https://gist.github.com/nedbat/e89fa710db0edfb9057dc8d18d979f9c
E há o Jython, que é escrito em Java e acaba produzindo código de bytes Java. O código de byte Java é executado no Java Runtime Environment, que é uma implementação da Java Virtual Machine (JVM). Se isso é confuso, suspeito que você não tenha idéia de como o Java funciona. Em termos leigos, o código Java (a linguagem, não o compilador) é obtido pelo compilador Java e gera um arquivo (que é o código de bytes Java) que pode ser executado apenas usando um JRE. Isso é feito para que, uma vez que o código Java seja compilado, ele possa ser portado para outras máquinas no formato de código de bytes Java, que possa ser executado apenas pelo JRE. Se isso ainda é confuso, você pode dar uma olhada nesta página da web .
Aqui, você pode perguntar se o bytecode do CPython é portátil como o Jython, suspeito que não. O bytecode produzido na implementação do CPython foi específico para esse intérprete, facilitando a execução adicional do código (também suspeito que essa produção intermediária de bytecode seja apenas pela facilidade de processamento em muitos outros intérpretes).
Portanto, no Jython, quando você compila seu código Python, você acaba com o código de bytes Java, que pode ser executado em uma JVM.
Da mesma forma, o IronPython (escrito em linguagem C #) compila seu código Python para Common Language Runtime (CLR), que é uma tecnologia semelhante à JVM, desenvolvida pela Microsoft.