Das Nachschlagewerk für alte, neue und exotische Sprachen

Sprachenenzyklopädie: IronPython
Kommentare

Eine kurze Einführung in IronPython könnte wirklich schnell erzählt sein, denn IronPython ist im Grunde einfach Python. Schließlich funktioniert derselbe Quellcode, der beispielsweise für Python 2.7 geschrieben wurde, auch in IronPython. Womit schon alles gesagt wurde und der Artikel hier zu Ende ist. Und nun zu etwas völlig anderem…

Nein, natürlich nicht. Als eine weitere Implementierung des Python-Interpreters ist IronPython mehr. Die Referenzimplementierung CPython wird in der Programmiersprache C geschrieben. Meist wird CPython auch einfach nur Python genannt, weil es der am häufigsten genutzte Python-Interpreter ist. Der Python-Interpreter Jython wird dagegen in Java umgesetzt und PyPy in Python selbst. IronPython wird in der .NET-Sprache C# entwickelt, wodurch es zu einem Python mit .NET-Erweiterungen wurde. So wie CPython selbst auch kein Python ist, ist IronPython der in C# programmierte Interpreter für eine Programmiersprache namens Python.

Sprachenenzyklopädie
Es gibt hunderte Programmiersprachen da draußen. Und während manche allgegenwärtig sind, haben wir die einen fast schon vergessen, andere kennen wir erst vom Hörensagen und manche sind so spezifisch, dass wir vielleicht nie mit ihnen in Berührung kommen werden. Wir wollen einen Blick über den Tellerrand der am weitesten verbreiteten Sprachen wagen, alte Technologien wieder aufleben lassen, neue vorstellen und einen Eindruck davon vermitteln, was selbst die exotischsten Sprachen bieten können.

Ein bisschen Geschichte

Microsoft veröffentlichte 2000 mit .NET eine neue Plattform für objektorientierte Programmierung unter Windows. Von Anfang an war .NET ein sprachunabhängiges Framework, sodass Programmierer in verschiedenen Programmiersprachen wie C#, Visual C++ oder VB.NET Anwendungen entwickeln konnten. Der Quellcode wird mit einem Just-in-Time-Compiler in eine Zwischensprache übersetzt; die Common Intermediate Language (CIL), bevor sie von der Laufzeitumgebung ausgeführt wird. Letztere ist das Herz und die Seele von .NET: die Common Language Runtime (CLR). Noch bevor Version 1.0 der CLR veröffentlicht wurde, rief Microsoft das Project 7 ins Leben, das Unternehmen und akademische Einrichtungen darin unterstützte, Programmiersprachen für .NET zu entwickeln. Eine der Sprachen sollte von Anfang an Python sein, und die Firma ActiveState wollte sie auf die .NET-Plattform bringen. Sie scheiterten allerdings an Performanceproblemen und gaben bekannt, dass .NET für dynamische Sprachen einfach ungeeignet sei [1].

Diese Aussage rief Jim Hugunin auf den Plan, der zuvor JPython, das heute Jython heißt, für die Java Virtual Machine (JVM) entwickelt hatte. Er fragte sich, was Microsoft mit der CLR unter .NET bloß so falsch gemacht haben könne, dass sie mit Python nicht funktionieren solle? Er wollte der Frage ein paar Wochen lang auf den Grund gehen und am Ende das Ergebnis im Artikel „Why the CLR is a terrible platform for dynamic languages“ ausführen. Der Artikel wurde nie geschrieben, denn zu seiner Überraschung stellte er fest, dass sich eine dynamische Sprache wie Python sehr gut für die .NET-Plattform eignet. Daraufhin erschien 2006 die Version 1.0 von IronPython.

Anfangs stand IronPython noch unter Microsofts eigener Open-Source-Lizenz, der Micosoft Public License, ist aber mittlerweile zur Apache-Lizenz 2.0 gewechselt. Beim Namen IronPython könnte man jetzt denken, dass der erste Teil „Iron“ ein Akronym für „It Runs On .NET“ sein könnte. Das passt zwar sehr gut, doch der Name geht auf Hugunins alte Beratungsfirma „Want of a Nail Software“ zurück. Wobei „Want of a Nail“ seinen Ursprung in einem Kinderreim hat. Außerdem waren Alternativen wie Python .NET und Python# schon vergeben und hätten auch nicht so schön geklungen.
Hugunin wurde 2004 von Microsoft eingestellt, um IronPython aktiv weiterzuentwickeln. Nach sechs Jahren wechselte er 2010 schließlich zu Google. Trotzdem geht die Entwicklung von IronPython weiter: Im September 2013 erschien Version 2.7.4 der Sprache. Microsoft fördert außerdem die Arbeit an Python Tools for Visual Studio weiter – hauptsächlich wohl wegen des in Python geschriebenen Web-Frameworks Django, das unter Azure gehostet werden kann.

Was ist das Besondere an IronPython?

IronPython ist sozusagen der .NET-Compiler für eine Programmiersprache namens Python, damit Python-Code von der Laufzeitumgebung CLR ausgeführt wird. Wie in .NET üblich kann man auch unter IronPython auf Bibliotheken zugreifen, die in anderen .NET-Sprachen geschrieben wurden und umgekehrt. Dazu liefert IronPython den Compiler pyc.py für die Kommandozeile mit, um das Python-Skript in eine ausführbare Datei (.exe) oder eine Bibliothek (.dll) – in .NET heißt das dann Assembly – zu verwandeln. Diese Assemblies können in anderen .NET-Projekten weiter verwendet werden, egal in welcher Programmiersprache des Frameworks sie geschrieben wurden. Grundsätzlich lässt sich so alles, was man mit einer .NET-Sprache oder mit der PowerShell erreichen kann, auch mit IronPython umsetzen und genießt dabei alle Vorzüge von Python.

Installation

Die aktuelle IronPython-Version kann für Windows direkt von Codeplex heruntergeladen werden. Die MSI-Datei installiert man einfach durch einen Doppelklick. Danach findet man den Ordner IronPython 2.7 unter Program Files bzw. Program Files (x86) im Dateisystem. Der Pfad fehlt allerdings in der Umgebungsvariable PATH, was man unter SYSTEMSTEUERUNG | SYSTEM | ERWEITERTE SYSTEMEINSTELLUNGEN UND UMGEBUNGSVARIABLEN… ändern kann. Falls ein Modul fehlt und CPython parallel zu IronPython auf dem Rechner installiert ist, kann man die Python-Standardbibliothek einbinden, indem man im IronPython-Verzeichnis im Unterordner Lib die Datei site.py um folgende Zeile ergänzt, wobei man den Pfad zur Python-Installation eventuell noch anpassen muss:

sys.path.append("C:Python27Lib")

Unter Linux oder Mac OS X ist die Installation ein wenig aufwändiger, da IronPython den .NET-Klon Mono benötigt. Zuerst installiert man das komplette Mono-Framework: unter OpenSuse mit dem Befehl zypper in mono-complete, unter Debian und Derivate mit apt-get install mono-complete. Bei anderen Distributionen sollte es ähnlich sein. Für Mac OS X gibt es Mono als Installationspaket. Nach der Installation lädt man das aktuelle IronPython von GitHub herunter:

git clone https://github.com/IronLanguages/main.git IronLanguages
cd IronLanguages/
xbuild Solutions/IronPython.sln /p:Configuration=Release 

Unter Gnu/Linux wirft IronPython allerdings eine Fehlermeldung aus, wenn man versucht, das os-Modul zu importieren:

>>> import os
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ImportError: No module named os

Der Fehler wird durch folgenden Eintrag in der ~/.bashrc behoben:

export IRONPYTHONPATH=~/IronLanguages/External.LCA_RESTRICTED/Languages/IronPython/27/Lib:$IRONPYTHONPATH
alias ipy="mono ~/IronLanguages/bin/Release/ipy.exe"

Der Installationspfad von IronPython liegt in diesem Beispiel im Home-Verzeichnis unter ~/IronLanguages. In der Zeile darunter wurde noch der Alias ipy auf den Aufruf „mono ~/IronLanguages/bin/Release/ipy.exe“ gesetzt, um unnötiges Tippen zu sparen.

Aufmacherbild: Snake von Shutterstock / Urheberrecht: Julien Tromeur

[ header = Seite 2: Hallo Welt! ]

Hallo Welt!

IronPython ist auf jeden Fall für Python-Programmierer interessant, die sich mit .NET beschäftigen wollen oder müssen. Entwickler, die andere .NET-Sprachen bevorzugen, können mit IronPython die Entwicklungsgeschwindigkeit ihrer Anwendungen steigern, weil Code zum Testen von Schnittstellen oder Bibliotheken nicht mehr ständig kompiliert werden muss. Die Lernkurve sollte dabei besonders für C#-Entwickler nicht zu steil sein, wenn man folgenden Code vergleicht:

import System
Uhrzeit = System.DateTime.Now.ToShortTimeString()
HalloWelt = System.String.Format("{0} {1} {2}", "Hallo Welt, es ist", Uhrzeit, "Uhr.")
print HalloWelt

Dasselbe Ergebnis vom obigen IronPython-Code erhält man in C#, wie in Listing 1 zu sehen ist.

using System; 
namespace IronPython.Example
{
  class Program
  {
    static void Main(string[] args)
    {
      string Uhrzeit = System.DateTime.Now.ToShortTimeString();
      string Hallo = String.Format("{0} {1} {2}", "Hallo Welt, es ist", Uhrzeit, "Uhr");
      Console.WriteLine(Hallo); 
    }
  }
}

Natürlich gibt es Unterschiede, aber es stechen auch die Gemeinsamkeiten ins Auge. Der Knackpunkt ist jedoch das Ausführen des Codes: Packt man das Python-Skript in eine Datei, kann man es mit ipy HalloWelt.py sofort starten, während das C#-Programm erst noch kompiliert werden muss. Alternativ kann man auch in der Python-Konsole schnell neue APIs oder Designänderungen testen oder das IronPython-Skript in ein C#-Projekt einfach einbinden (Listing 2).

using System;
using IronPython.Hosting;
using Microsoft.Scripting.Hosting;
public class dynamic_demo
{
  static void Main()
  {
    var ipy = Python.CreateRuntime();
    dynamic test = ipy.UseFile("HalloWelt.py");
  }
}

Beim Kompilieren muss man darauf achten, dass die Bibliotheken IronPython.dll und Microsoft.Scripting.dll referenziert werden, was man entweder in Visual Studio erledigt oder per Hand:

csc.exe /r:"C:Program Files (x86)IronPython 2.7IronPython.dll" /r:"C:Program Files (x86)IronPython 2.7Microsoft.Scripting.dll" TestIronPython.cs

Kleine grafische Anwendungen, die wie native Windows-Anwendungen aussehen, sind auch schnell entwickelt und sofort lauffähig. Dank Mono funktionieren sie auch unter anderen Betriebssystemen wie Gnu/Linux oder Mac OS X. Eine einfache kleine Anwendung mit Windows Forms sieht dann so aus wie in Listing 3.

import clr
clr.AddReference('System.Windows.Forms')
clr.AddReference('System.Drawing')
from System.Windows.Forms import Application, Button, Form
from System.Drawing import Point
x = 0
y = 0
form = Form()
form.Text = "Hallo Welt!"
button = Button(Text="Klick mich...")
form.Controls.Add(button)
def click(sender, event):
    global x, y
    button.Location = Point(x, y)
    x += 5
    y += 5
button.Click += click
Application.Run(form)

Die Anwendung mit Windows Presentation Foundation (WPF) besteht indes aus zwei Dateien: Einmal aus dem Python-Skript HalloWeltWPF.py (Listing 4) und zum anderen aus der XAML-Datei HalloWeltWPF.xaml, in der die grafische Oberfläche beschrieben ist (Listing 5).

import clr
clr.AddReference('PresentationFramework')
clr.AddReference('PresentationCore')

from System.IO import File
from System.Windows.Markup import XamlReader
from System.Windows import Application, Window
from System.Windows.Controls import Label

class HalloWelt(object):
    def __init__(self):
        stream = File.OpenRead("HalloWeltWPF.xaml")
        self.Root = XamlReader.Load(stream)
        self.button = self.Root.FindName('button')
        self.stackPanel = self.Root.FindName('stackPanel')
        self.button.Click += self.onClick

    def onClick(self, sender, event):
        message = Label()
        message.FontSize = 36
        message.Content  = 'Hallo Welt!'
        self.stackPanel.Children.Add(message)

hallo = HalloWelt()

app = Application()
app.Run(hallo.Root)
<Window
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  Title="Welcom to IronPython" Width="550"
  SizeToContent="Height">
  <StackPanel Margin="15" x:Name="stackPanel">
    <Button FontSize="24" Content="Klick mich..." x:Name="button">
      <Button.BitmapEffect>
        <DropShadowBitmapEffect />
      </Button.BitmapEffect>
    </Button>
  </StackPanel>
</Window>

Ein Silberstreif mit Silverlight

IronPython spielt seine Stärken besonders dann aus, wenn es um Technologien von Microsoft selbst geht. So kann man zum Beispiel in Python Applikationen für die Webbrowsererweiterung Silverlight schreiben. Neben IronPython benötigt man dazu noch Silverlight und das Silverlight SDK, beides in Version 5. Die Version vom SDK und der Anwendung selbst sollten gleich sein, da man aus dem SDK die Datei System.Numerics.dll benötigt, die in das Verzeichnis der IronPython-Installation in den Unterordner Silverlightbin kopiert werden muss. Im Unterordner Silverlightscripttemplatespython findet man ein Template mit dem Python-Quellcode in appapp.py. Zusammen mit der Datei app.xaml bilden sie den Einstiegspunkt in die Demo. Die Datei index.html eine Ebene darüber dient zum Sprung in die Silverlight-Anwendung. Für ein erstes „Hallo Welt!“ nimmt man in der Datei app.py folgende kleine Änderungen vor:

from System.Windows import Application
from System.Windows.Controls import UserControl

class App:
  def __init__(self):
    self.root = Application.Current.LoadRootVisual(UserControl(), "app.xaml")
    self.root.Message.Text = "Welcome to Python and Silverlight!"

theApp = App()

Jetzt startet man den Webserver zum Testen aus der Befehlszeile heraus. Dazu wechselt man in der Kommandozeile in das Verzeichnis mit der index.html und gibt folgenden Befehl ein:

......binChiron.exe /b

Daraufhin öffnet sich der Standardbrowser mit einer Baumansicht des aktuellen Verzeichnisses. Nach dem Klick auf die index.html wird die Silverlight-Anwendung ausgeführt und grüßt mit dem Satz: „Welcome to Python and Silverlight!“ Weiter unten sieht man die IronPython REPL Console eingeblendet, was über eine Codezeile in der index.html gesteuert wird, in der der Wert console=true eingetragen wurde. Spannend an der Konsole ist, dass man den Inhalt der Seite, genauer die in XAML definierten UI-Elemente, zur Laufzeit ansteuern und verändern kann, indem man auf das Attribut theApp.root.Message.Text zugreift und ihm einfach einen anderen Wert zuweist:

theApp.root.Message.Text = 'Hallo Welt!'

Das Ergebnis zeigt Abbildung 1.

Abb. 1: Die „Hallo Welt“-Applikation in Silverlight

Fazit

Wer Spaß am Programmieren mit Python hat und sich dazu noch mit .NET auseinandersetzen darf, für den ist IronPython gerade richtig. In IronPython lassen sich leicht grafische Benutzeroberflächen entwickeln, die nicht wie Fremdkörper aussehen und mit Mono auch unter Gnu/Linux oder Mac OS X laufen können. Bibliotheken sind in Python schnell geschrieben und mithilfe des IronPython-Compilers in Assemblies übersetzt, die in anderen .NET-Projekten weiterverwendet werden können. Darüber hinaus ist IronPython für .NET-Entwickler ideal, um Assemblies zu testen. Die Lernkurve ist nicht so steil und Skripte müssen nicht extra kompiliert werden, sondern können gleich ausgeführt werden. Da der Übersetzungsschritt wegfällt, sind kleine Programme für besondere Aufgaben schnell erstellt, um mit Objekten zu spielen, sie auszuprobieren und zu erforschen.

Unsere Redaktion empfiehlt:

Relevante Beiträge

Meinungen zu diesem Beitrag

X
- Gib Deinen Standort ein -
- or -