IronPython - IronPython

IronPython
Ironpython-logo.png
Autor (es) original (is) Jim Hugunin , Microsoft
Desenvolvedor (s) Dino Viehland,
.NET Foundation
lançamento inicial 5 de setembro de 2006 ; 15 anos atrás ( 05/09/2006 )
Versão estável
2.7.11  Edite isso no Wikidata / 17 de novembro de 2020 ; 11 meses atrás ( 17 de novembro de 2020 )
Versão de visualização
3.4.0-alpha1 / 20 de abril de 2021 ; 5 meses atrás ( 2021-04-20 )
Repositório
Escrito em C #
Sistema operacional Windows , Linux , macOS
Plataforma .NET Framework , .NET , Mono
Modelo Implementação da linguagem de programação Python
Licença Licença Apache 2.0
Local na rede Internet ironpython .net Edite isso no Wikidata

IronPython é uma implementação da linguagem de programação Python voltada para .NET Framework e Mono . Jim Hugunin criou o projeto e contribuiu ativamente com ele até a versão 1.0, que foi lançada em 5 de setembro de 2006. IronPython 2.0 foi lançado em 10 de dezembro de 2008. Após a versão 1.0, ele foi mantido por uma pequena equipe da Microsoft até o 2.7 Beta 1 liberar. A Microsoft abandonou o IronPython (e seu projeto irmão, o IronRuby ) no final de 2010, após o que Hugunin saiu para trabalhar no Google. O projeto é mantido atualmente por um grupo de voluntários no GitHub . É um software gratuito e de código aberto e pode ser implementado com Python Tools for Visual Studio, que é uma extensão gratuita e de código aberto para o Visual Studio IDE da Microsoft .

IronPython é escrito inteiramente em C # , embora parte de seu código seja gerado automaticamente por um gerador de código escrito em Python.

IronPython é implementado em cima do Dynamic Language Runtime (DLR), uma biblioteca rodando em cima da Common Language Infrastructure que fornece tipagem dinâmica e despacho de método dinâmico, entre outras coisas, para linguagens dinâmicas. O DLR é parte do .NET Framework 4.0 e também faz parte do Mono desde a versão 2.4 de 2009. O DLR também pode ser usado como uma biblioteca em implementações CLI mais antigas.

Status e roteiro

  • A versão 2.0, lançada em 10 de dezembro de 2008 e atualizada como 2.0.3 em 23 de outubro de 2009, tem como alvo o CPython 2.5. IronPython 2.0.3 só é compatível com o .NET Framework 3.5.
  • A versão 2.6, lançada em 11 de dezembro de 2009 e atualizada em 12 de abril de 2010, tem como alvo o CPython 2.6. As versões do IronPython 2.6.1 são binárias compatíveis apenas com o .NET Framework 4.0. IronPython 2.6.1 deve ser compilado de fontes para rodar no .NET Framework 3.5. IronPython 2.6.2, lançado em 21 de outubro de 2010, é binário compatível com .NET Framework 4.0 e .NET Framework 3.5.
  • A versão 2.7 foi lançada em 12 de março de 2011 e tem como alvo o CPython 2.7.
  • A versão 2.7.1 foi lançada em 21 de outubro de 2011 e tem como alvo o CPython 2.7.
  • A versão 2.7.2.1 foi lançada em 13 de março de 2012. Ela permite o suporte para bibliotecas de formato de arquivo ZIP , SQLite e executáveis ​​compilados.
  • A versão 2.7.4 foi lançada em 7 de setembro de 2013.
  • A versão 2.7.5 foi lançada em 6 de dezembro de 2014 e consiste principalmente em correções de bugs.
  • A versão 2.7.6 foi lançada em 21 de agosto de 2016 e consiste apenas em correções de bugs.
  • A versão 2.7.7 foi lançada em 7 de dezembro de 2016 e consiste apenas em correções de bugs.
  • A versão 2.7.8 foi lançada em 16 de fevereiro de 2018 e consiste em correções de bugs, código reorganizado e uma infraestrutura de teste atualizada (incluindo testes significativos no Linux no Mono ). É também a primeira versão a oferecer suporte ao .NET Core .
  • A versão 2.7.9 foi lançada em 9 de outubro de 2018 e consiste em correções de bugs e código reorganizado. Pretende ser o último lançamento antes do IronPython 3.
  • A versão 2.7.10 foi lançada em 27 de abril de 2020 e adiciona suporte ao .NET Core 3.1.
  • A versão 2.7.11 foi lançada em 17 de novembro de 2020 e resolve problemas durante a execução no .NET 5 .

Diferenças com CPython

Existem algumas diferenças entre a implementação de referência do Python, CPython e IronPython. Alguns projetos construídos sobre o IronPython são conhecidos por não funcionarem no CPython. Por outro lado, os aplicativos CPython que dependem de extensões para a linguagem que são implementados em C não são compatíveis com IronPython, a menos que sejam implementados em uma interoperabilidade .NET. Por exemplo, o NumPy foi desenvolvido pela Microsoft em 2011, permitindo que o código e as bibliotecas dependentes dele fossem executados diretamente do .NET Framework.

luz cinza

O IronPython é compatível com o Silverlight (que foi descontinuado pela Microsoft e já perdeu o suporte na maioria dos navegadores da web, exceto para o Internet Explorer 11, que encerrará o suporte em outubro de 2021). Ele pode ser usado como um mecanismo de script no navegador, assim como o mecanismo JavaScript . Os scripts IronPython são passados ​​como scripts JavaScript simples do lado do cliente em <script>-tags. Então, também é possível modificar a marcação XAML incorporada .

A tecnologia por trás disso é chamada Gestalt. 

// DLR initialization script.
<script src="http://gestalt.ironpython.net/dlr-latest.js" type="text/javascript"></script>

// Client-side script passed to IronPython and Silverlight.
<script type="text/python">
    window.Alert("Hello from Python")
</script>

O mesmo funciona para IronRuby .

Licença

Até a versão 0.6, o IronPython foi lançado sob os termos da Licença Pública Comum . Após o recrutamento do líder do projeto em agosto de 2004, o IronPython foi disponibilizado como parte da iniciativa Shared Source da Microsoft . Esta licença não é aprovada pela OSI, mas os autores afirmam que ela atende à definição de código aberto. Com o lançamento 2.0 alpha, a licença foi alterada para a Licença Pública da Microsoft , que foi aprovada pelo OSI. As versões mais recentes são lançadas sob os termos da Licença Apache 2.0 .

Extensibilidade da interface

Uma das principais vantagens do IronPython está em sua função como uma camada de extensibilidade para estruturas de aplicativos escritas em uma linguagem .NET. É relativamente simples integrar um interpretador IronPython em uma estrutura de aplicativo .NET existente. Uma vez implementados, os desenvolvedores de downstream podem usar scripts escritos em IronPython que interagem com objetos .NET no framework, estendendo assim a funcionalidade na interface do framework, sem ter que alterar a base de código do framework.

IronPython faz uso extensivo de reflexão . Quando passado em uma referência a um objeto .NET, ele importará automaticamente os tipos e métodos disponíveis para aquele objeto. Isso resulta em uma experiência altamente intuitiva ao trabalhar com objetos .NET a partir de um script IronPython.

Exemplos

O script IronPython a seguir manipula objetos .NET Framework. Esse script pode ser fornecido por um desenvolvedor de aplicativos do lado do cliente de terceiros e passado para a estrutura do lado do servidor por meio de uma interface. Observe que nem a interface, nem o código do lado do servidor são modificados para suportar a análise exigida pelo aplicativo cliente. 

from BookService import BookDictionary
 
booksWrittenByBookerPrizeWinners = [book.Title for book in BookDictionary.GetAllBooks() 
                                    if "Booker Prize" in book.Author.MajorAwards]

Nesse caso, suponha que o .NET Framework implemente uma classe, BookDictionary , em um módulo chamado BookService , e publique uma interface na qual os scripts IronPython podem ser enviados e executados.

Este script, quando enviado para essa interface, irá iterar sobre toda a lista de livros mantida pela estrutura e escolher aqueles escritos por autores vencedores do Prêmio Booker.

O que é interessante é que a responsabilidade de escrever a análise real é do desenvolvedor do lado do cliente. As demandas do desenvolvedor do lado do servidor são mínimas, basicamente fornecendo acesso aos dados mantidos pelo servidor. Esse padrão de design simplifica muito a implementação e manutenção de estruturas de aplicativos complexas.

O script a seguir usa o .NET Framework para criar uma mensagem Hello World simples. 

import clr
clr.AddReference("System.Windows.Forms")

from System.Windows.Forms import MessageBox
MessageBox.Show("Hello World")

atuação

As características de desempenho do IronPython em comparação com o CPython , a implementação de referência do Python, dependem do benchmark exato usado. IronPython tem desempenho pior do que CPython na maioria dos benchmarks feitos com o script PyStone, mas melhor em outros benchmarks. O IronPython pode ter um desempenho melhor em programas Python que usam threads ou múltiplos núcleos, pois possui um compilador JIT e também porque não possui o Global Interpreter Lock .

Veja também

Referências

links externos