História Pessoal - parte 1, CWI

Publicação original: http://python-history.blogspot.com/2009/01/personal-history-part-1-cwi.html
Autor original: Guido van Rossum

O desenvolvimento inicial de Python começou em instituto de pesquisa em Amsterdam chamado CWI, uma sigla holandesa para uma frase que se traduz em português como Centro para Matemática e Ciência da Computação. CWI era um local interessante; financiado pelo Departamento de Educação do governo holandês e outros fundos de pesquisa, conduzia pesquisa acadêmica em ciência da computação e matemática. Em qualquer época havia vários estudantes de doutorado andando pelo local e veteranos na profissão ainda devem lembrar do nome original, o Centro de Matemática. Sob esse nome, provavelmente o centro ganhou fama pela invenção de Algol 68.

Comecei a trabalhar no CWI no final de 1982, recém saído da universidade, como um programador do grupo ABC liderado por Lambert Meertens e Steven Pemberton. Depois de 4 ou 5 anos, o projeto ABC foi encerrado devido à óbvia falta de sucesso e eu fui para o grupo Amoeba liderado por Sape Mullender. Amoeba era um sistema distribuído baseado em microkernel desenvolvido conjuntamente pelo CWI e Vrije Universiteit de Amsterdam, sob liderança de Andrew Tanenbaum. Em 1991, Sape deixou o CWI para lecionar na Universidade de Twente e eu terminei no recentemente formado grupo de multimídia do CWI liderado por Dick Bulterman.

Python é um produto direto da minha experiência no CWI. Como explicarei depois, ABC me deu a inspiração crucial para Python, Amoeba a motivação imediata e o grupo de multimídia fomentou seu crescimento. Entretanto, pelo que eu sei, nenhum fundo no CWI foi oficialmente reservado para seu desenvolvimento. Em vez disso, Python meramente se desenvolveu como uma ferramenta importante tanto para o grupo Amoeba quanto para o grupo multimídia.

Minha motivação para a criação de Python foi a percepção da necessidade de uma linguagem de alto nível no projeto Amoeba. Percebi que o desenvolvimento de utilitários para administração de sistema em C estava tomando muito tempo. E fazê-los no shell Bourne não funcionaria por diversas razões. O mais importante foi que, sendo um sistema distribuído de microkernel, as operações primitivas do Amoeba eram bem diferentes (e refinadas) que as operações primitivas disponíveis no shell Bourne. Portanto, havia necessidade de uma linguagem que "preencheria o vazio entre C e o shell". Por um tempo longo, esse foi o principal lema de Python.

Nesse ponto, você poderia perguntar "por que não adaptar uma linguagem existente?" No meu ponto de vista, não havia linguagens adequadas à época. Eu era familiar com Perl 3, mas essa estava ainda mais ligada ao Unix que o shell Bourne. Eu também não gostava da sintaxe de Perl -- meu gosto por sintaxes de linguagens de programação foram fortemente influenciadas por linguagens como Algol 60, Pascal, Algol 68 (todas eu havia aprendido anteriormente), e finalmente, ABC, na qual eu passei quatro anos da minha vida. Portanto, decidi projetar uma linguagem por mim mesmo a qual poderia pegar tudo que gostei de ABC enquanto, ao mesmo tempo, consertar todos seus problemas (como os percebia).

O primeiro problema que decidi consertar foi o nome! Da forma que ocorreu, o time ABC teve alguns problemas ao escolher um nome para a linguagem. O nome original, B, teve que ser abandonado por causa de ma confusão com outra linguagem chamada B, que era mais velha e melhor conhecida. De qualquer modo, a ideia era usar B como título de projeto apenas (a piada era que B era o nome da variável contendo o nome da linguagem -- daí o itálico). A equipe lançou uma competição pública para escolher o novo nome, mas nenhuma das submissões levou e, no fim, a segunda opção interna prevaleceu. O nome era para transmitir a ideia de uma linguagem que faria programação "tão simples quanto ABC", mas nunca me convenceu a tanto.

Portando, em vez de analisar demasiadamente o problema de nomenclatura, decidi subanalisá-lo. Escolhi a primeira coisa que me veio à cabeça, que foi Monty Python’s Flying Circus, um dos meus grupos de comédia favoritos. A referência era convenientemente irreverente para o que era essencialmente um "projeto skunkworks" (N.T.: diz-se de um projeto desenvolvido por um grupo fracamente estruturado e com alto grau de autonomia, sem equivalente em português). A palavra "Python" também era cativante, um pouco irritante e, ao mesmo tempo, encaixava na tradição de nomear linguagens em homenagens a pessoas famosas, como Pascal, Ada e Eiffel. O grupo Monty Python pode não ser famoso pelos avanços em ciência ou tecnologia, mas certamente é um favorito dos geeks. Também se encaixou na tradição do grupo Amoeba no CWI de batizar programas com nomes de programas de TV.

Por muitos anos eu resisti à tentação de associas a linguagem com cobras. Finalmente desisti quando O'Reilly queria colocar uma cobra na capa de seu primeiro livro de Python "Programming Python". Era tradição da O'Reilly usar imagens de animais e, se deveria ser um animal, que fosse uma cobra.

Com o problema do nome resolvido, eu comecei a trabalhar em Python no fim de dezembo de 1989 e tinha uma versão operacional nos primeiros meses de 1990. Eu não anotava, mas lembro vividademente que o primeiro trecho de código que escrevi para implementação de Python era um simples gerador de parser LL(1) que chamei de "pgen". Esse gerador de parser ainda é parte do código-fonte de Python e provavelmente o menos modificado em todo o código. Essa versão inicial foi usada por uma pequena quantidade de pessoas no CWI, mas não exclusivamente pelo grupo Amoeba em 1990. Desenvolvedores chave além de mim eram meus colegas de escritório, os programadores Sjoerd Mullender (irmão mais novo de Sape) e Jack Jansen (que permaneceu um dos desenvolvedores líderes da versão para Macintosh vários anos depois que eu saí do CWI).

Em 20 de fevereiro de 1991, eu liberei Python para o mundo pela primeira no grupo de notícias (N.T.: newsgroup, no original) alt.sources (em 21 partes codificadas com uuencode que deveriam ser reuniadas e decodificadas com uudecode para compor um arquivo tar comprimido). Essa versão foi numerada como 0.9.0 e liberada sob uma licença que era quase uma cópia exata da licença MIT usada pelo projeto X11 na época, substituindo "Stichting Mathematisch Centrum", organização pai do CWI, como entidade legal responsável. Então, como quase tudo que eu escrevi, Python era de código aberto (N.T.: open source, no original) antes que o termo fosse inventado por Eric Raymond e Bruce Perens ao final de 1997.

Imediatamente houve muito retorno e com esse encorajamento eu mantive um fluxo constante de lançamentos pelos próximos anos. Comecei a usar CVS para rastrear mudanças e facilitar compartilhamento de responsabilidades sobre a codificação com Sjoerd e Jack (coincidentemente, CVS foi originalmente desenvolvido como um conjunto de scripts shell por Dick Grune, que era um membro anterior do grupo ABC). Eu escrevi um FAQ, que era regularmento publicado em algum grupo de notícias, como era costume para FAQs naqueles dias antes da web, iniciei uma lista de discussão por e-mail e em março de 1993 o grupo comp.lang.python foi criado com meu encorajamento, mas sem meu envolvimento direto. O grupo e a lista de e-mails foram unificados através de um gateway bidirecional que ainda existe, embora atualmente implementado como uma funcionalidade do mailman - o gerenciador de listas dominante de código aberto, escrito em Python.

No verão de 1994, o grupo estava agitado com uma discussão entitulada "Se Guido fosse atingido por um ônibus?" sobre a dependência da crescente comunidade de Python em relação às minhas contribuições pessoais. Isso culminou em um convite por Michael McLay para que eu passasse dois meses como pesquisador convidado no NIST, o Instituto Nacional de Padrões e Tecnologias dos EUA, anteriormente o Escritório Nacional de Padrões (N.T.: National Bureau of Standards, no original), em Gaithersburg, Maryland. Michael possuía uma certa quantidade de "clientes" no NIST que estavam interessado em usar Python para vários projetos relacionados a padrões e os fundos para minha estadia foram motivados pela necessidade de ajudá-los a melhorar as habilidades com Python, bem como melhorar Python para suas necessidades.

O primeiro workshop de Python ocorreu enquanto eu estava lá em novembro de 1994, com o programador do NIST Ken Manheimer provendo assistência e encorajamento importantes. De aproximadamente 20 participantes, por volta da metade ainda são participantes ativos na comunidade Python e uns poucos se tornaram grandes líderes de projetos de código aberto (Jim Fulton do Zope e Barry Warsaw do GNU mailman). Com o suport do NIST eu também dei uma palestra para aproximadamente 400 pessoas na conferência Usenix Little Languages em Santa Fe, organizada por Tom Christiansen, um adovgado de Perl de mente aberta que me apresentou ao criador de Perl, Larry Wall, e ao autor de Tcl/Tk, John Ousterhout.

Próxima parte: como obtive um emprego nos EUA...

N.T.: peço desculpas à comunidade pela demora na tradução.

Breve linha do tempo de Python

Publicação original: http://python-history.blogspot.com/2009/01/brief-timeline-of-python.html
Autor original: Guido van Rossum

O desenvolvimento de Python ocorreu na mesma época em que várias outras linguagens de programação dinâmicas (e open-source), tais como Tcl, Perl e (muito depois) Ruby, também estavam em desenvolvimento ativo e aumentando popularidade. Para ajudar a colocar Python em sua própria perspectiva histórica, a lista abaixo mostra o histórico de lançamentos de versões de Python. As datas iniciais são aproximadas, já que eu não me recordo consistentemente de todos os eventos:

Data de lançamento	Versão
Dezembro de 1989	Início da implementação
1990	Lançamento interno ao CWI (N.T.: Centro de Matemática e Ciência da Computação)
20 de fevereiro de 1991	0.9.0 (lançado em alt.sources)
Fevereiro de 1991	0.9.1
Outono de 1991	0.9.2
24 de dezembro de 1991	0.9.4
02 de janeiro de 1992	0.9.5 (somente para Macintosh)
06 de abril de 1992	0.9.6
1992 (mês desconhecido)	0.9.7 beta
09 de janeiro de 1993	0.9.8
29 de julho de 1993	0.9.9
26 de janeiro de 1994	1.0.0
15 de fevereiro de 1994	1.0.2
04 de maio de 1994	1.0.3
14 de julho de1994	1.0.4
11 de outubro de 1994	1.1
10 de novembro de 1994	1.1.1
13 de abril de 1995	1.2
13 de outubro de 1995	1.3
25 de outubro de 1996	1.4
03 de janeiro de 1998	1.5
31 de outubro de 1998	1.5.1
13 de abril de 1999	1.5.2
05 de setembro de 2000	1.6
16 de outubro de 2000	2.0
17 de abril de 2001	2.1
21 de dezembro de 2001	2.2
29 de julho de 2003	2.3
30 de novembro de 2004	2.4
16 de setembro de 2006	2.5
01 de outubro de 2008	2.6
03 de dezembro de 2008	3.0

Adicionei hyperlinks para as versões que ainda são exibidas em python.org atualmente. Observe que algumas versões foram seguidas por várias micro-versões, por exemplo, 2.0.1; não me importei em adicioná-las à tabela, pois essa se tornaria muito extensa.
Código-fonte de versões bem antigas ainda estão acessíveis aqui: http://www.python.org/ftp/python/src/. Vários binários antigos e outros artefatos históricos ainda podem ser encontrados subindo um nível a partir desse link.

Filosofia do Python

Publicação original: http://python-history.blogspot.com/2009/01/pythons-design-philosophy.html
Autor original: Guido van Rossum

As próximas entradas nesse blog aprofundarão detalhes da história do Python. Entretanto, antes que eu o faça, gostaria de apresentar a linha filosófica que me ajudou a tomar decisões enquanto projetava e implementava Python.

Primeiro, Python fora originalmente concebida como um projeto experimental de uma pessoa - não havia orçamento oficial e eu desejava resultados rápidos, em parte porque assim poderia convencer a gerência a suportar o projeto (tarefa a qual obtive sucesso moderado). Isso me levou a algumas regras que economizam tempo:

• Tome emprestadas idéias de qualquer lugar, desde que elas façam sentido.
• "As coisas devem ser as mais simples possíveis, mas não mais simples." - Einstein
• Faça uma única coisa bem (A "filosofia Unix").
• Não se preocupe muito sobre desempenho -- planeje otimizar depois, quando necessário.
• Não reme contra a maré -- siga o fluxo.
• Não tente ser perfeccionista. "Bom o suficiente" frequentemente é isso.
• (Portanto) Tudo bem economizar às vezes, principalmente se puder fazer corretamente mais tarde.

Outros princípios não tinham intenção de economizar tempo. Às vezes ocorria justamente o oposto:

• A implementação de Python não deve estar atada a uma plataforma em particular. Tudo bem se determinada funcionalidade não estiver disponível sempre, mas o núcleo da linguagem deve funcionar em todo lugar.
• Não incomode o usuário com detalhes que a máquina pode cuidar (nem sempre segui essa regra e algumas consequências desastrosas estão descritas em seções posteriores).
• Suporte e encorage código independente de plataforma, mas não remova o acesso a propriedades ou capacidades da plataforma (isso é um contraste gritante em relação a Java).
• Um sistema grande e complexo deveria ter vários níveis de extensibilidade. Esse fato maximiza a oportunidade para que usuários, sofisticados ou não, se ajudem.
• Erros não devem ser fatais. Ou seja, códigos dos usuários devem ser capazes de se recuperar de condições de erro, desde que a máquina virtual permaneça funcional.
• Por outro lado, erros não devem passar desapercebidos (esses dois últimos itens levaram ao uso de exceções durante a implementação).
• Nunca um bug no código do usuário deve levar a comportamentos indefinidos no interpretador de Python; um core dump nunca é falha do usuário.

Finalmente, eu tive várias idéias sobre um bom projeto de linguagem, que fora vastamente enraizado em mim pelo grupo de ABC onde tive minha primeira experiência real com projeto e implementação de linguagem. Essas idéias são difíceis de expressar, já que basicamente são sobre elegância, simplicidade e legibilidade.

Embora eu vá discutir mais sobre influência da ABC posteriormente, gostaria de mencionar uma regra específica sobre legibilidade: caracteres de pontuação deveriam ser usados conservadoramente, alinhados com seu uso comum em inglês ou álgebra. Exceções são feitas quando uma notação particular já é tradicional em linguagens de programação, como "x*y" para multiplicação, "a[i]" para indexação de vetores, ou "x.foo" para seleção de atributo, mas Python não usa "$" para indicar variáveis, nem "!" para indicar operações com efeitos colaterais.

Tim Peters, um usuário de Python de longa data e que eventualmente tornou-se um dos mais prolíficos e tenazes desenvolvedores, capturou meu princípio de design não documentado no que ele chama "O Zen de Python."
Cito aqui em sua totalidade:

• Belo é melhor que feio.
• Explícito é melhor que implícito.
• Simples é melhor que complexo.
• Complexo é melhor que complicado.
• Plano é melhor que aninhado.
• Esparso é melhor que denso.
• Legibilidade conta.
• Casos especiais não são especiais o suficiente para violar as regras.
• Embora praticidade vença pureza.
• Erros não devem passar silenciosamente.
• A não ser que sejam explicitamente silenciados.
• Em caso de ambiguidade, resista à tentação de adivinhar.
• Deve haver um - e somente um - jeito óbvio de fazer.
• Embora tal jeito não seja tão óbvio no à primeira vista a não ser que você seja holandês.
• Agora é melhor que nunca.
• Embora nunca é frequentemente melhor que exatamente agora.
• Se a implementação é difícil de explicar, a ideia é ruim.
• Se a implementação é fácil de explicar, talvez a ideia seja boa.
• Espaços de nomes são uma ideia estupenda - vamos fazer mais deles!

Embora minha experiência com ABC tenha fortemente influenciado Python, o grupo de ABC tinha alguns princípios de design que eram radicalmente diferentes dos princípios de Python. Em muitas maneiras, Python é uma fuga consciente destes:

• O grupo ABC se empenhava pela perfeição. Por exemplo, eles usavam algoritmos para estrutura de dados baseadas em árvores que haviam sido demonstrados ótimos para entradas assintoticamente grandes (mas não eram tão boas para entradas pequenas).
• O grupo ABC queria isolar o usuário, tão completamente quanto possível, do "grande e mal mundo dos computadores." Não apenas não deveria haver limites para faixa de valores de números, comprimento de cadeias de caracteres ou tamanho de coleções (a não ser quantidade de memória disponível), bem como os usuários não deveriam ser solicitados a lidar com arquivos, "salvamento" ou outros programas. ABC deveria ser a única ferramenta da qual eles precisariam. Esse desejo levou o grupo ABC a criar um ambiente de edição completo, único à ABC (havia uma forma de escapar do ambiente ABC, claro, mas foi sobretudo uma idéia posterior e não acessível diretamente a partir da linguagem.)
• O grupo ABC assumia que os usuários não tinham experiência prévia com computadores (ou desejavam esquecê-la). Portanto, terminologia alternativa, mais amigável para iniciantes, foi introduzida em vez do jargão padrão de programação. Por exemplo, procedimentos eram chamados "how-tos" (NT: como fazer) e variáveis, "locations" (NT: locais).
• O grupo ABC projetou ABC sem uma linha evolucionária em mente e sem esperar participação do usuário no projeto da linguagem. ABC foi criada como um sistema fechado, tão sem falhas quanto seus projetistas poderiam torná-la. Usuários não eram encorajados a ver os detalhes internos da implementação. Embora tenha se falado em abrir parte da implementação para usuários avançados em estágios posteriores do projeto, isso nunca foi feito.

De certa forma, a filosofia de projeto que usei quando criei Python é provavelmente uma das principais razões para seu sucesso estrondoso. Em vez de almejar pela perfeição, os primeiros usuários consideraram que ela era "boa o suficiente" para seus propósitos. À medida que a base de usuários cresceu, sugestões de melhorias foram gradualmente incorporadas à linguagem. Como veremos em seções futuras, muitas dessas melhorias involveram mudanças substanciais e reconstrução de partes importantes da linguagem. Ainda hoje, Python continua a evoluir.

Introdução e Visão Geral

Publicação original: http://python-history.blogspot.com/2009/01/introduction-and-overview.html
Autor original: Guido van Rossum

Introdução

Python é atualmente uma das mais populares linguagens dinâmicas de programação, junto a Perl, Tcl, PHP e a novata Ruby. Embora frequentemente vista como linguagem de "scripts", é, na verdade, uma linguagem de programação de propósito geral, na mesma linha de Lisp ou Smalltalk (assim como outras linguagens, por assim dizer).
Hoje, Python é usada para tudo, desde scripts simples de uso único a grandes e escaláveis servidores web que proveem serviço ininterrupto 24x7. É usada em GUI (interfaces gráficas de usuário) e programação para banco de dados, programação web tanto no lado cliente quanto servidor e teste de aplicações. É usada por cientistas escrevendo programas para os supercomputadores mais velozes e por crianças aprendendo a programar.
Neste blog, focarei na história de Python. Em particular, como Python foi desenvolvida, as grandes influências em seu design, erros cometidos, lições aprendidas e próximos passos para a linguagem.

Agradecimento: Estou em dívida com Dave Beazley por muitas das melhores idéias neste blog. (Para ler mais sobre as origens deste blog, veja meu outro blog.)


Uma visão geral do Python

Quando alguém é exposto pela primeira vez ao Python, geralmente a pessoa se sente atordoada pelo modo como código escrito em Python se parece, pelo menos superficialmente, com código escrito em outras linguagens convencionais como C ou Pascal. Isso não é acidente, a sintaxe do Python é fortemente influenciada por C. Por exemplo, muitas das palavras chave reservadas (if, else, while, for, etc.) são as mesmas em C, identificadores em Python seguem a mesma regra de nomenclatura que C e muitos dos operadores possuem o mesmo significado dos operadores em C.
É claro, Python obviamente não é C e uma das maiores áreas onde as linguagens diferem é no uso de indentação em vez de chaves para agrupamento de comandos. Por exemplo, em vez de escrever comandos em C como

if (a < b) {
    max = b;
} else {
    max = a;
}

Python simplesmente dispensa as chaves (além de ponto-e-vírgula ao fim dos comandos) e usa a seguinte estrutura

if a < b:
    max = b
else:
    max = a

Outra grande área onde Python difere de linguagens semelhantes a C reside o uso de tipagem dinâmica. Em C, variáveis devem ser declaradas explicitamente e atribuídas a certo tipo de dados, como int ou double. Essa informação é usada para realizar verificações estáticas em tempo de compilação bem como para alocação de memória usada para armazenar os valores das variáveis. Em Python, variáves simplesmente são nomes que se referem a objetos. Não há necessidade de declarar variáveis antes que elas sejam atribuídas e elas podem até mudar de tipo no meio do programa. Assim como outras linguagens dinâmicas, toda verificação de tipo é realizada em tempo de execução por um interpretador em vez de ser realizada durante uma fase separada de compilação.

Os tipos internos primitivos de Python incluem Booleanos, números (inteiros do tamanho da palavra da máquina, inteiros de precisão arbitrária, e números de ponto flutuante reais e complexos) e cadeias de caracteres (8 bits e Unicode). Todos são tipos imutáveis, o que significa que os valores são representados por objetos que não podem ser modificados após a criação. Tipos internos compostos incluem tuplas (vetores imutáveis), listas (vetores redimensionáveis) e dicionários (tabelas de espalhamento, ou hash).

Para fins de organização, Python suporta pacotes (grupos de módulos e/ou outros pacotes), módulos (códigos relacionados agrupados em um único arquivo), classes, métodos e funções. Para controle de fluxo, Python provê if/else, while e um comando for de alto nível que percorre objetos “iteráveis”. Para tratamento de erros, Python usa exceções (não-continuáveis). O comando raise lança uma exceção e os comandos try/except/finally especificam os tratamentos de exceção. Operações internas lançam exceções quando condições de erro são atingidas.

Em Python, todos os objetos nomeáveis são considerados de "primeira classe." Isso significa que funções, classes, métodos, módulos e todos outros objetos nomeados podem ser facilmente referenciados, inspecionados e alocados em várias estruturas de dados (por exemplo, listas ou dicionários) em tempo de execução. Por falar em objetos, Python também fornece suporte à programação orientada a objetos, incluindo classes definidas pelo usuário, herança e ligação de métodos em tempo de execução.

Python possui uma ampla biblioteca, o que é um dos principais motivos para sua popularidade. A biblioteca padrão possui mais de 100 módulos e está em evolução constante. Alguns desses módulos incluem expressões regulares, funções matemáticas, threads, interface com sistema operacional, programação em rede, protocolos para internet (HTTP, FTP, SMTP, etc), manipulação de e-mail, processamento de XML, processamento de HTML e um kit para interface gráfica de usuário (Tcl/Tk).

Além disso, há um amplo suprimento de módulos e pacotes de terceiros, a maioria dos quais também de código aberto. Dentre esses, pode-se encontrar frameworks para web (há muitos para serem listados!), mais kits de interface, bibliotecas numéricas eficientes (incluindo empacotadores para vários pacotes populares em Fortran), interface com bancos de dados relacionais (Oracle, MySQL e outros), SWIG (uma ferramente para disponibilizar bibliotecas arbitrárias em C++ como módulos Python) e muito mais.

Um tópico atraente de Python (e outras linguagens dinâmicas por assim dizer) é o fato de que tarefas aparentemente complicadas podem ser frequentemente expressas com pouco código. Como exemplo, este é um script simples em Python que baixa uma página da web, a examina em busca de URLs e imprime as 10 primeiras referências.

# Examina a página web procurando por referências a URLs

import re
import urllib

regex = re.compile(r'href="([^"]+)"')

def matcher(url, max=10):
    "Imprime as primeiras referências a URLs em uma URL fornecida."
    data = urllib.urlopen(url).read()
    hits = regex.findall(data)
    for hit in hits[:max]:
        print urllib.basejoin(url, hit)

matcher("http://python.org")

Esse programa pode ser modificado facilmente para se criar um indexador web e, de fato, Scott Hassan me disse que escrevera o primeiro indexador do Google em Python. Hoje, Google emprega milhões de linhas de código em Python para gerenciar vários aspectos de suas operações, desde automação a gerenciamento de propagandas. (Aviso legal: atualmente sou um funcionário do Google.)

Debaixo dos panos, Python tipicamente é implementado usando uma combinação de compilador para bytecode e um interpretador. A compilação é executada implicitamente assim que módulos são carregados e várias primitivas requerem que o compilador esteja disponível em tempo de execução.
Embora a implementação de-facto seja escrita em C e esteja disponível para toda plataforma de hardware/software imaginável, várias outras implementações tornaram-se populares. Jython é uma versão que roda sobre uma máquina virtual Java e apresenta forte integração com Java. IronPython é uma versão para a plataforma Microsoft.NET e apresenta integração similar com linguagens rodando sobre .NET. PyPy é um compilador/interpretador otimizado escrito em Python (ainda um projeto de pesquisa sendo desenvolvido sob financiamento da União Européia). Também há o Stackless Python, uma variação da implementação em C que reduz a dependência na pilha para chamada de funções em C, para permitir co-rotinas, continuações e microthreads.

[Editado: adicionada uma frase que não foi traduzida. (2013-03-20)]