Pitão é incrível.

Surpreendentemente, essa é uma afirmação bastante ambígua. O que quero dizer com ‘Python’? Quero dizer Python, o abstrato interface ? Quero dizer CPython, o Python comum implementação (e não deve ser confundido com o Cython com o mesmo nome)? Ou quero dizer algo completamente diferente? Talvez eu esteja me referindo indiretamente a Jython, ou IronPython ou PyPy. Ou talvez eu realmente tenha ido ao fundo do poço e estou falando sobre RPython ou RubyPython (que são coisas muito, muito diferentes).

Enquanto as tecnologias mencionadas acima são comumente nomeadas e comumente referenciadas, algumas delas têm finalidades completamente diferentes (ou, pelo menos, operam de maneiras completamente diferentes).

Ao longo do meu tempo trabalhando com as interfaces Python, eu encontrei toneladas dessas ferramentas. * Ython. Mas só recentemente tive tempo para entender o que são, como funcionam e por que são necessários (em seus próprios caminhos).

comunicação gráfica e design gráfico

Neste tutorial, vou começar do zero e percorrer as várias implementações de Python, concluindo com uma introdução completa ao PyPy, que acredito ser o futuro da linguagem.

Tudo começa com a compreensão do que realmente é 'Python'.

Se você tem um bom conhecimento de código de máquina, máquinas virtuais e similares, sinta-se à vontade para pular adiante .

“O Python é interpretado ou compilado?”

Este é um ponto comum de confusão para iniciantes em Python .

A primeira coisa a perceber ao fazer uma comparação é que 'Python' é um interface . Há um especificação de que Python devemos fazer e como devemos se comportar (como em qualquer interface). E há vários implementações (como em qualquer interface).

A segunda coisa a perceber é que 'interpretado' e 'compilado' são propriedades de um implementação , não um interface .

Portanto, a pergunta em si não é muito bem formulada.

O Python é interpretado ou compilado? A questão não está bem formulada.

Dito isso, para a implementação Python mais comum (CPython: escrito em C, muitas vezes referido simplesmente como ‘Python’, e certamente o que você está usando se não tem ideia do que estou falando), a resposta é: interpretado , com alguns compilação. CPython compila * Código-fonte Python para bytecode, e então interpreta este bytecode, executando-o à medida que avança.

* Nota: isto não é 'compilação' no sentido tradicional da palavra. Normalmente, diríamos que 'compilação' é pegar uma linguagem de alto nível e convertê-la em código de máquina. Mas é uma espécie de 'compilação'.

Vamos examinar essa resposta mais de perto, pois ela nos ajudará a entender alguns dos conceitos que surgirão posteriormente na postagem.

Bytecode vs. Código de Máquina

É muito importante entender a diferença entre bytecode e código de máquina (também conhecido como código nativo), talvez melhor ilustrado por um exemplo:

• C compila em código de máquina, que então é executado diretamente em seu processador. Cada instrução instrui sua CPU a mover as coisas.
• Java compila em bytecode, que é então executado na Java Virtual Machine (JVM), uma abstração de um computador que executa programas. Cada instrução é então tratada pela JVM, que interage com o seu computador.

Em termos muito breves: o código de máquina é muito mais rápido, mas o bytecode é mais portátil e seguro .

O código de máquina parece diferente dependendo da sua máquina, mas o bytecode parece o mesmo em todas as máquinas. Pode-se dizer que o código de máquina é otimizado para sua configuração.

Voltando à implementação do CPython, o processo da cadeia de ferramentas é o seguinte:

1. CPython compila seu código-fonte Python em bytecode.
2. Esse bytecode é então executado na máquina virtual CPython.

Os iniciantes geralmente presumem que o Python é compilado por causa dos arquivos .pyc. Há alguma verdade nisso: o arquivo .pyc é o bytecode compilado, que é então interpretado. Portanto, se você já executou seu código Python antes e tem o arquivo .pyc à mão, ele será executado mais rápido na segunda vez, pois não é necessário recompilar o bytecode.

VMs alternativas: Jython, IronPython e mais

Como mencionei anteriormente, Python tem de várias implementações. Novamente, como mencionado anteriormente, o mais comum é o CPython, mas há outros que devem ser mencionados para fins deste guia de comparação. Esta é uma implementação Python escrita em C e considerada a implementação 'padrão'.

Mas e as implementações alternativas do Python? Um dos mais proeminentes é Jython , uma implementação Python escrita em Java que utiliza o JVM. Enquanto CPython produz bytecode para ser executado na VM CPython, Jython produz Bytecode Java para ser executado no JVM (é o mesmo que é produzido quando você compila um programa Java).

“Por que você usaria uma implementação alternativa?”, Você pode perguntar. Bem, por um lado, estes diferentes implementações de Python funcionam bem com diferentes pilhas de tecnologia .

CPython torna muito fácil escrever extensões C para o seu código Python porque no final ele é executado por um interpretador C. Jython, por outro lado, torna muito fácil trabalhar com outros programas Java: você pode importar qualquer Classes Java sem nenhum esforço adicional, convocando e utilizando suas classes Java de seus programas Jython. (À parte: se você não pensou sobre isso de perto, isso é realmente loucura. Estamos no ponto em que você pode misturar e misturar diferentes linguagens e compilá-las todas na mesma substância. (Como mencionado por Rostin , programas que misturam código Fortran e C já existem há algum tempo. Então, é claro, isso não é necessariamente novo. Mas ainda é legal.))

Por exemplo, este é um código Jython válido:

[Java HotSpot(TM) 64-Bit Server VM (Apple Inc.)] on java1.6.0_51 >>> from java.util import HashSet >>> s = HashSet(5) >>> s.add('Foo') >>> s.add('Bar') >>> s [Foo, Bar]

IronPython é outra implementação Python popular, escrita inteiramente em C # e visando a pilha .NET. Em particular, ele é executado no que você pode chamar de Máquina Virtual .NET, a Common Language Runtime (CLR) , comparável ao JVM.

Você pode dizer que Jython: Java :: IronPython: C # . Eles são executados nas mesmas VMs respectivas, você pode importar classes C # de seu código IronPython e classes Java de seu código Jython, etc.

É totalmente possível sobreviver sem nunca tocar em uma implementação Python não CPython. Mas há vantagens na troca, muitas das quais dependem de sua pilha de tecnologia. Usando muitas linguagens baseadas em JVM? Jython pode ser para você. Tudo sobre a pilha .NET? Talvez você devesse experimentar IronPython (e talvez já tenha).

melhor lugar para aprender c ++

A propósito: embora isso não seja um razão para usar uma implementação diferente, observe que essas implementações realmente diferem no comportamento, além de como tratam seu código-fonte Python. No entanto, essas diferenças são normalmente menores e se dissolvem ou surgem com o tempo, conforme essas implementações estão em desenvolvimento ativo. Por exemplo, IronPython usa strings Unicode por padrão ; CPython, no entanto, o padrão é ASCII para as versões 2.x (falha com UnicodeEncodeError para caracteres não ASCII), mas oferece suporte Strings Unicode por padrão para 3.x .

Compilação Just-in-Time: PyPy e o Futuro

Portanto, temos uma implementação Python escrita em C, uma em Java e outra em C #. A próxima etapa lógica: uma implementação Python escrita em ... Pitão . (O leitor instruído notará que isso é um pouco enganador.)

É aqui que as coisas podem ficar confusas. Primeiro, vamos discutir a compilação just-in-time (JIT).

JIT: Por que e como

Lembre-se de que o código de máquina nativo é muito mais rápido do que o bytecode. Bem, e se pudéssemos compilar alguns de nossos bytes e executá-los como código nativo? Teríamos que pagar algum preço para compilar o bytecode (ou seja, tempo), mas se o resultado final fosse mais rápido, seria ótimo! Essa é a motivação da compilação JIT, uma técnica híbrida que combina os benefícios de interpretadores e compiladores. Em termos básicos, o JIT deseja utilizar a compilação para acelerar um sistema interpretado.

Por exemplo, uma abordagem comum adotada por JITs:

1. Identifique o bytecode que é executado com freqüência.
2. Compile-o para o código de máquina nativo.
3. Armazene o resultado em cache.
4. Sempre que o mesmo bytecode é definido para ser executado, em vez disso, pegue o código de máquina pré-compilado e colha os benefícios (ou seja, aumentos de velocidade).

É disso que se trata a implementação de PyPy: trazer JIT para Python (consulte o Apêndice para esforços anteriores). Existem, é claro, outros objetivos: o PyPy tem como objetivo ser compatível com várias plataformas, com memória leve e sem pilha. Mas o JIT é realmente seu ponto de venda. Como uma média de vários testes de tempo, é dito que melhora o desempenho por um fator de 6,27 . Para obter uma análise, consulte este gráfico do PyPy Speed ​​Center :

PyPy é difícil de entender

PyPy tem um potencial enorme e, neste ponto, é altamente compatível com CPython (então pode executar Flask, Django , etc.).

Mas há muita confusão em torno do PyPy (veja, por exemplo, esta proposta absurda de criar um PyPyPy ... ) Na minha opinião, isso ocorre principalmente porque PyPy é na verdade duas coisas:

1. Um interpretador Python escrito em RPython (não Python (eu menti antes)). RPython é um subconjunto do Python com tipagem estática. Em Python, é “Quase impossível” raciocinar rigorosamente sobre os tipos (por que é tão difícil? Considere o fato de que:

   x = random.choice([1, 'foo'])

   seria um código Python válido (crédito para Gesto ) Qual é o tipo de x? Como podemos raciocinar sobre os tipos de variáveis ​​quando os tipos nem mesmo são estritamente impostos?). Com RPython, você sacrifica alguma flexibilidade, mas ao invés disso torna muito, muito mais fácil raciocinar sobre gerenciamento de memória e outros enfeites, o que permite otimizações.

2. Um compilador que compila o código RPython para vários destinos e adiciona JIT. A plataforma padrão é C, ou seja, um compilador RPython-para-C, mas você também pode direcionar o JVM e outros.

Apenas para maior clareza neste guia de comparação Python, vou me referir a eles como PyPy (1) e PyPy (2).

Por que você precisaria dessas duas coisas e por que sob o mesmo teto? Pense desta forma: PyPy (1) é um interpretador escrito em RPython. Portanto, ele pega o código Python do usuário e o compila em bytecode. Mas o próprio interpretador (escrito em RPython) deve ser interpretado por outra implementação Python para ser executado, certo?

Bem, poderíamos apenas usar CPython para executar o intérprete. Mas isso não seria muito rápido.

padrão em princípios de design

Em vez disso, a ideia é usar PyPy (2) (referido como o conjunto de ferramentas RPython) para compilar o interpretador de PyPy para o código de outra plataforma (por exemplo, C, JVM ou CLI) para executar em nossa máquina, adicionando JIT como bem. É mágico: PyPy adiciona dinamicamente JIT a um intérprete, gerando seu próprio compilador! ( Novamente, isso é loucura: estamos compilando um interpretador, adicionando outro compilador independente e separado. )

No final, o resultado é um executável autônomo que interpreta o código-fonte Python e explora otimizações JIT. Que é exatamente o que queríamos! É um bocado, mas talvez este diagrama ajude:

Para reiterar, a verdadeira beleza do PyPy é que poderíamos escrever um monte de interpretadores Python diferentes em RPython sem nos preocupar com JIT. PyPy, então, implementaria o JIT para nós usando o RPython Toolchain / PyPy (2).

Na verdade, se formos ainda mais abstratos, você poderia teoricamente escrever um intérprete para qualquer idioma, alimente-o para PyPy e obtenha um JIT para esse idioma. Isso ocorre porque o PyPy se concentra na otimização do intérprete real, em vez dos detalhes da linguagem que está interpretando.

Você poderia teoricamente escrever um intérprete para qualquer linguagem, alimentá-lo para PyPy e obter um JIT para essa linguagem.

Como uma breve digressão, gostaria de mencionar que o JIT em si é absolutamente fascinante. Ele usa uma técnica chamada rastreamento, que executa do seguinte modo :

1. Execute o interpretador e interprete tudo (sem adicionar JIT).
2. Faça alguns perfis leves do código interpretado.
3. Identifique as operações que você já realizou.
4. Compile esses bits de código até o código de máquina.

Para mais, este papel é altamente acessível e muito interessante.

Para encerrar: usamos o compilador RPython-to-C do PyPy (ou outra plataforma de destino) para compilar o interpretador implementado por RPython do PyPy.

Empacotando

Após uma longa comparação das implementações do Python, tenho que me perguntar: por que isso é tão bom? Por que vale a pena perseguir essa ideia maluca? eu acho que Alex Gaynor coloque bem no dele Blog : “[PyPy é o futuro] porque [ele] oferece melhor velocidade, mais flexibilidade e é uma plataforma melhor para o crescimento do Python.”

Em resumo:

vazou números de cartão de crédito com dinheiro

• É rápido porque compila o código-fonte para o código nativo (usando JIT).
• É flexível porque adiciona o JIT ao seu intérprete com muito pouco trabalho adicional.
• É flexível (novamente) porque você pode escrever seus interpretadores em RPython , que é mais fácil de estender do que, digamos, C (na verdade, é tão fácil que há um tutorial para escrever seus próprios intérpretes )

Apêndice: Outros nomes Python que você pode ter ouvido

• Python 3000 (Py3k) : um nome alternativo para Python 3.0, um major, incompatível com versões anteriores Versão do Python que chegou ao palco em 2008 . A equipe Py3k previu que levaria cerca de cinco anos para que esta nova versão seja totalmente adotada. E enquanto a maioria (aviso: afirmação anedótica) Os desenvolvedores Python continuam a usar o Python 2.x, as pessoas estão cada vez mais conscientes do Py3k.

• Cython : um superconjunto do Python que inclui ligações para chamar funções C.
  • Objetivo: permitir que você escreva extensões C para o seu código Python.
  • Também permite adicionar digitação estática ao seu código Python existente, permitindo que ele seja compilado e alcance um desempenho semelhante ao do C.
  • É semelhante ao PyPy, mas não é o mesmo. Nesse caso, você está impondo a digitação do código do usuário antes de passá-lo para um compilador. Com o PyPy, você escreve Python antigo e simples, e o compilador lida com todas as otimizações.
    
    

• Numba : um 'compilador especializado just-in-time' que adiciona JIT para anotado Código Python. Em termos mais básicos, você dá algumas dicas e acelera partes do seu código. Numba vem como parte do Anaconda distribuição, um conjunto de pacotes para análise e gerenciamento de dados.

• IPython : muito diferente de tudo o mais discutido. Um ambiente de computação para Python. Interativo com suporte para kits de ferramentas GUI e experiência de navegador, etc.

• Psyco : para Módulo de extensão Python , e um dos primeiros esforços do Python JIT. No entanto, desde então foi marcado como “Sem manutenção e morto” . Na verdade, o desenvolvedor líder do Psyco, Armin Rigo, agora trabalha no PyPy .

Ligações de linguagem Python

• RubyPython : uma ponte entre as VMs Ruby e Python. Permite incorporar código Python em seu código Ruby. Você define onde o Python começa e para, e o RubyPython organiza os dados entre as VMs.

• PyObjc : vínculos de linguagem entre Python e Objective-C, atuando como uma ponte entre eles. Praticamente, isso significa que você pode utilizar bibliotecas Objective-C (incluindo tudo que você precisa para criar aplicativos OS X) de seu código Python e módulos Python de seu código Objective-C. Nesse caso, é conveniente que CPython seja escrito em C, que é um subconjunto de Objective-C.

• PyQt : enquanto PyObjc oferece vinculação para os componentes OS X GUI, PyQt faz o mesmo para a estrutura de aplicativo Qt, permitindo criar interfaces gráficas ricas, acessar bancos de dados SQL, etc. Outra ferramenta destinada a trazer a simplicidade do Python para outros frameworks .

Frameworks JavaScript

• pijamas : uma estrutura para criar aplicativos da web e de desktop em Python. Inclui um compilador Python para JavaScript, um conjunto de widgets e mais algumas ferramentas.

• Brython : uma VM Python escrita em JavaScript para permitir que o código Py3k seja executado no navegador.