Melhor resposta
CPython é a implementação de referência de Python escrita na linguagem de programação C. Existem várias outras implementações, incluindo algumas outras em C. Mas o CPython é o mais amplamente usado e aquele contra todos os outros são comparados.
Python é uma especificação de linguagem. Se alguém se referir a detalhes de implementação com a especificação de qualquer implementação particular, então a suposição razoável será que é uma referência à versão CPython.
Você pode pesquisar por implementações, mas os resultados provavelmente serão um tanto confusos. Nem todas as implementações estão completas, nem todas são executadas em sistemas “normais” ou em ambientes convencionais de execução de programa (como uma janela de terminal ou console de texto).
Por exemplo MicroPython é um derivado reduzido do CPython voltado para micro controladores. Jython é escrito em Java e é executado no JVM (Java Virtual Machine) e inclui recursos para importar Java nativo e interoperar com ele (incluindo introspecção). IronPython é escrito em C # da Microsoft e direcionado para ser executado dentro do CLR (Common Language Runtime) da estrutura .NET. PyPy é uma versão do Python que é principalmente escrita em Python, mas envolvida em um núcleo que implementa um subconjunto restrito da linguagem e fornece JIT (Just-In- Compilação dinâmica / tempo de execução). (Esse subconjunto é denominado RPython e destina-se a oferecer suporte a mais do que apenas Python).
Veja o que quero dizer sobre confusão?
Existem pelo menos duas implementações diferentes de Python que são escritas em JavaScript e projetadas para serem executadas em um navegador normal (no DOM … ou Documenr Modelo de objeto … ambiente). Esses são Brython e Skulpt . Além disso, existem vários “transpilers” ou compiladores de Python para Javascript, incluindo Transcrypt, e pyjs – (formalmente pijamas) e talvez até RapydScript (embora seja mais como um híbrido de Python com JS).
Como você pode ver , se você se aprofundar o suficiente no assunto, ficará cada vez mais difícil categorizar diferentes projetos e ferramentas como “implementações”.
Por exemplo, há Cython que é uma ferramenta para pegar código semelhante ao Python com anotações especiais e compilá-lo em módulos carregáveis (binários / nativos) que podem ser importados para Python e usados como qualquer outra extensão compilada nativamente para o interpretador. Não é realmente considerado uma “implementação” de Python, mas sim uma ferramenta para otimizar trechos selecionados de código Python em extensões binárias para o interpretador CPython. (Se você estivesse trabalhando em Jython, poderia reescrever partes de seu código em Java e usar os recursos de interoperação e introspecção do Jython para usar esse código. Só por analogia).
Há também Numba que é uma ferramenta para compilar de forma transparente um subconjunto de Python e código NumPy em LLVM e integrando o suporte de tempo de execução LLVM ao mecanismo de execução do interpretador Python. Isso é descrito mais como um JIT do que o paradigma distinto de módulo / extensão da Cython. Ainda assim, é mais uma ferramenta do que uma “implementação” de toda a linguagem.
Mas então, se você olhar para Nuitka , verá um projeto ambicioso para compilar programas Python inteiros. Portanto, isso pode ser mais uma implementação.
Ainda outro projeto (que parece ser aquele em que Guido van Rossum, o criador do Python, tem trabalhado) é mypy – Python com tipagem estática opcional e alguma inferência de tipo local. Esta não seria uma nova implementação. Parece ser uma espécie de frontend que processa Python (com anotações de tipo opcionais) e leva o Python (não anotado) de volta ao mecanismo de tempo de execução do CPython (interpretador).
Se você quiser mergulhar em ainda mais implementações e os links olham para: PythonImplementations – Python Wiki .
Observação: cobri muitos deles aqui e tentei explicar como eles se relacionam até certo ponto. Essa página wiki é mais um saco de surpresas, com menos exposição e alguns links para projetos mortos ou não mantidos.
Resposta
Até eu tive o mesmo problema para entender como são CPython, JPython , IronPython, PyPy são diferentes uns dos outros.
Portanto, estou disposto a esclarecer três coisas antes de começar a explicar:
- Python : É uma linguagem, apenas declara / 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 referido como uma máquina virtual, ao invés da 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 então o executa. A razão para converter o código Python em um bytecode é porque é mais fácil implementar um interpretador se ele se parecer com instruções de máquina. Mas, não é necessário produzir algum bytecode antes da execução (mas o CPython produz).
Se você deseja ver o bytecode do CPython, pode. 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)
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 Python intermediário (ou você pode dizer, desmontador para bytecode Python) que é gerado pelo CPython (interpretador).
OBSERVAÇÃO : obtive o link para este código no canal de IRC #python: https://gist.github.com/nedbat/e89fa710db0edfb9057dc8d18d979f9c
E então, 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 ideia 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 byte 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 byte Java, que só pode ser executado por JRE. Se ainda estiver confuso, você pode querer dar uma olhada nesta página da web .
Aqui, você pode perguntar se o CPython ” s bytecode é portátil como Jython, eu suspeito que não. O bytecode produzido na implementação de CPython era específico para esse interpretador para torná-lo fácil para execução posterior de código (eu também suspeite que, tal produção de bytecode intermediário, apenas para a facilidade de processamento é feito em muitos outros interpretadores). Se você está se perguntando como é fácil executar o bytecode como mostrado acima no código (após a linha 9 até o final ), então, pense nisso. Temos uma pilha (estrutura de dados) e cada linha no bytecode faz alguma operação de pilha, modificando a pilha de acordo. Essa pilha modificada é usada pelo CPython (o interpretador) para produzir a saída final do código .
Então, em Jython, quando você compila seu código Python, acaba com um código de bytes Java, que pode ser executado em uma JVM.
Da mesma forma, IronPyt hon (escrito em linguagem C #) compila seu código Python para Common Language Runtime (CLR), que é uma tecnologia semelhante em comparação com JVM, desenvolvida pela Microsoft.