Python (Programmiersprache)

Python
Basisdaten
Paradigmen:	multiparadigmatisch
Erscheinungsjahr:	1991
Designer:	Guido van Rossum
Entwickler:	Python Software Foundation
Aktuelle Version:	3.4.2, 2.7.8  ((3.4.2) 8. Oktober 2014, (2.7.8) 2. Juli 2014)
Typisierung:	stark, dynamisch („Duck-Typing“)
Wichtige Implementierungen:	CPython, Jython, IronPython, PyPy
Beeinflusst von:	ABC, Algol 60, Modula-3, Icon, C, Perl, LISP, Smalltalk, Tcl, Haskell
Beeinflusste:	Ruby, Boo, Groovy, Cython, Swift
Betriebssystem:	Plattformunabhängig
Lizenz:	Python Software Foundation Lizenz
www.python.org

Python [ˈpaɪθn̩, ˈpaɪθɑn, auf Deutsch auch ˈpyːtɔn] ist eine universelle, üblicherweise interpretierte höhere Programmiersprache. Ihre Entwurfsphilosophie betont Programmlesbarkeit, sodass Python-Code im Vergleich mit anderssprachigem Code teilweise deutlich kürzer ist. Zur Lesbarkeit dient auch der Verzicht auf Klammern zur Bildung von Code-Blöcken, da die Programmstruktur durch Einrückungen gebildet wird.

Python unterstützt mehrere Programmierparadigmen, z. B. die objektorientierte, die aspektorientierte und die funktionale Programmierung. Ferner bietet es eine dynamische Typisierung. Wie viele dynamische Sprachen wird Python oft als Skriptsprache genutzt.

Die Sprache hat ein offenes, gemeinschaftsbasiertes Entwicklungsmodell, das durch die gemeinnützige Python Software Foundation, die de facto die Definition der Sprache in der Referenzumsetzung CPython pflegt, gestützt wird.

Python gilt als einfach zu erlernende Sprache, da sie über eine klare und übersichtliche Syntax verfügt. Ferner besitzt sie eine umfangreiche Programmbibliothek, gerade in Bezug auf Webentwicklungen.

Laut TIOBE-Index ist Python die erfolgreichste Programmiersprache der Jahre 2007 und 2010.

Entwicklungsgeschichte

Guido van Rossum, der Entwickler von Python

Die Sprache wurde Anfang der 1990er Jahre von Guido van Rossum am Centrum Wiskunde & Informatica in Amsterdam als Nachfolger für die Programmier-Lehrsprache ABC entwickelt und war ursprünglich für das verteilte Betriebssystem Amoeba gedacht.

Der Name geht nicht etwa (wie das Logo vermuten ließe) auf die gleichnamige Schlangengattung (Pythons) zurück, sondern bezog sich ursprünglich auf die englische Komikertruppe Monty Python. In der Dokumentation finden sich daher auch einige Anspielungen auf Sketche aus dem Flying Circus. Trotzdem etablierte sich die Assoziation zur Schlange, was sich unter anderem in der Programmiersprache Cobra sowie dem Python-Toolkit „Boa“ äußert.

Über den Ursprung der Sprache schrieb van Rossum rückblickend 1996:

“Over six years ago, in December 1989, I was looking for a "hobby" programming project that would keep me occupied during the week around Christmas. My office ... would be closed, but I had a home computer, and not much else on my hands. I decided to write an interpreter for the new scripting language I had been thinking about lately: a descendant of ABC that would appeal to Unix-/C-Hackers. I chose Python as a working title for the project, being in a slightly irreverent mood (and a big fan of Monty Python's Flying Circus).”

„Vor sechs Jahren, im Dezember 1989, suchte ich nach einem Hobby-Projekt im Bereich der Programmierung, das mich in der Weihnachtswoche beschäftigt hält. Mein Büro würde geschlossen sein, aber ich besaß einen Heimcomputer, ansonsten nicht viel mehr. Ich entschied mich, einen Interpreter für die Skriptsprache zu schreiben, über die ich in letzter Zeit nachgedacht habe: Ein Nachfahre von ABC, das Unix-/C-Programmierern gefallen würde. Ich wählte in einer leicht ehrfurchtslosen Stimmung (und als ein großer Fan von Monty Python's Flying Circus) "Python" als Arbeitstitel.“

Die erste Vollversion erschien unter der Bezeichnung Python 1.0 und wurde im Januar 1994 veröffentlicht. Gegenüber früheren Versionen wurden einige Konzepte der funktionalen Programmierung implementiert, die allerdings später wieder aufgegeben wurden. Von 1995 bis 2000 erschienen Updates, die fortlaufend als Python 1.1, 1.2 etc. bezeichnet wurden.

Python 2.0 erschien am 16. Oktober 2000. Neue Funktionen umfassten eine voll funktionsfähige Automatische Speicherbereinigung und die Unterstützung für den Unicode-Zeichensatz. Bis 2010 erschienen Aktualisierungen, die als 2.1, 2.2 etc. bezeichnet wurden. In Version 2.6 wurde eine Hilfe eingebaut, mit der angezeigt werden kann, welche Code-Sequenzen vom Nachfolger Python 3 nicht mehr unterstützt werden und daher in darauf aufbauenden Versionen nicht mehr lauffähig sind.

Python 3.0 (auch Python 3000) erschien am 3. Dezember 2008 nach längerer Entwicklungszeit. Es beinhaltet einige tiefgreifende Änderung an der Sprache, etwa das Entfernen von Redundanzen bei Befehlssätzen und veralteten Konstrukten. Daher ist Python 3.0 in einigen Teilen inkompatibel zu früheren Versionen. Wesentliche Verbesserungen werden mittels Patches für frühere Python-Versionen umgeschrieben und implementiert.

Die jüngste Veröffentlichung stellt Python 3.4 dar, das am 16. März 2014 veröffentlicht wurde.

Ziele

Python wurde mit dem Ziel entworfen, möglichst einfach und übersichtlich zu sein. Dies wird vor allem durch zwei Maßnahmen erreicht. Zum einen kommt die Sprache mit relativ wenigen Schlüsselwörtern aus. Zum anderen ist die Syntax reduziert und auf Übersichtlichkeit optimiert. Dadurch lassen sich Python-basierte Skripte deutlich knapper formulieren, als dies mit anderen Sprachen möglich wäre.

Van Rossum legte bei der Entwicklung großen Wert darauf, dass die Standardbibliothek von Python überschaubar, dafür aber leicht erweiterbar sei. Gründe dafür finden sich in seiner negativen Erfahrung mit Einschränkungen der Sprache ABC, in der so ziemlich das Gegenteil der Fall ist.

Durch dieses Konzept wurde es auch ermöglicht, Programme in anderen Sprachen als Module einzubetten. Dadurch können Schwächen von Python umgangen werden. Beispielsweise lassen zeitkritische Teile durch in maschinennäheren Sprachen wie z. B. C programmierte Routinen ersetzen. Umgekehrt lassen sich mit Python Module und Plug-ins für andere Programme schreiben, die die entsprechende Unterstützung bieten. Dies ist z. B. bei Blender, Cinema 4D, GIMP, Maya, OpenOffice bzw. LibreOffice, PyMOL, SPSS oder KiCad der Fall.

Python ist eine Multiparadigmensprache. Das bedeutet, Python zwingt den Programmierer nicht zu einem einzigen bestimmten Programmierparadigma, sondern erlaubt es, das für die jeweilige Aufgabe am besten geeignete Paradigma zu wählen. Objektorientierte und strukturierte Programmierung werden vollständig unterstützt, funktionale und aspektorientierte Programmierung werden durch einzelne Elemente der Sprache unterstützt.

Die Datentypen werden dynamisch verwaltet, eine statische Typprüfung wie z. B. bei C++ gibt es nicht. Die Freigabe nicht mehr benutzter Speicherbereiche erfolgt durch automatische Speicherbereinigung (garbage collection), welche wie die Unicode-Unterstützung in der Version 2.0 eingeführt wurde.

Die wesentlichen Ziele und Regeln der Sprache wurden mit einer Reihe kurzer, humorvoller Phrasen unter dem Titel The Zen of Python im Jahr 2004 herausgegeben.

Datentypen und Strukturen

Python besitzt eine größere Anzahl von grundlegenden Datentypen. Neben der herkömmlichen Arithmetik unterstützt es transparent auch beliebig große Ganzzahlen und komplexe Zahlen.

Es verfügt über die übliche Ausstattung an Zeichenkettenoperationen. Zeichenketten sind in Python allerdings unveränderliche Objekte (wie auch in Java). Damit führen Operationen, die das Ändern einer Zeichenkette bewerkstelligen sollen – wie z. B. das Ersetzen von Zeichen – dazu, dass stattdessen eine neue Zeichenkette zurückgegeben wird.

In Python ist alles ein Objekt; Klassen, Typen, Methoden, Module etc. Der Datentyp ist jeweils an das Objekt (den Wert) gebunden und nicht an eine Variable, d. h. Datentypen werden dynamisch vergeben, so wie bei Smalltalk oder LISP – und nicht wie bei Java.

Trotz der dynamischen Typverwaltung enthält Python eine gewisse Typprüfung. Diese ist strenger als bei Perl, aber weniger strikt als etwa bei Objective CAML. Implizite Umwandlungen nach dem Duck-Typing-Prinzip sind unter anderem für numerische Typen definiert, so dass man beispielsweise eine komplexe Zahl mit einer langen Ganzzahl ohne explizite Typumwandlung multiplizieren kann. Anders als bei Perl gibt es allerdings keine implizite Umwandlung zwischen Zahlen und Zeichenketten; in Operationen für Zeichenketten kann also anstelle einer Zeichenkette nicht direkt eine Zahl verwendet werden. Der Operator == überprüft zwei Objekte auf (Wert-)Gleichheit. Der Operator is überprüft die tatsächliche Identität zweier Objekte.

Sammeltypen

Python besitzt mehrere Sammeltypen, darunter Listen, Tupel, Mengen (Sets) und assoziative Arrays. Listen, Tupel und Zeichenketten sind Folgen (Sequenzen, Arrays) und kennen fast alle die gleichen Methoden: Über die Zeichen einer Kette kann man ebenso iterieren wie über die Elemente einer Liste. Außerdem gibt es die unveränderlichen Objekte, die nach ihrer Erzeugung nicht mehr geändert werden können. Listen sind z. B. erweiterbare Felder (Arrays), wohingegen Tupel und Zeichenketten eine feste Länge haben und unveränderlich sind.

Der Zweck solcher Unveränderlichkeit hängt z. B. mit den Wörterbüchern zusammen, einem Datentyp, der auch als assoziatives Array bezeichnet wird. Um die Datenkonsistenz zu sichern, müssen die Schlüssel eines Wörterbuches vom Typ „unveränderlich“ sein. Die ins Wörterbuch eingetragenen Werte können dagegen von beliebigem Typ sein.

Sets sind Mengen von Objekten und in CPython ab Version 2.4 im Standardsprachumfang enthalten. Diese Datenstruktur kann beliebige (paarweise unterschiedliche) Objekte aufnehmen und stellt Mengenoperationen wie beispielsweise Durchschnitt, Differenz und Vereinigung zur Verfügung.

Objektsystem

Das Typsystem von Python ist auf das Klassensystem abgestimmt. Obwohl die eingebauten Datentypen genau genommen keine Klassen sind, können Klassen von einem Typ erben. So kann man die Eigenschaften von Zeichenketten oder Wörterbüchern erweitern – auch von Ganzzahlen. Python unterstützt Mehrfachvererbung.

Die Sprache unterstützt direkt den Umgang mit Typen und Klassen. Typen können ausgelesen (ermittelt) und verglichen werden und verhalten sich wie Objekte – in Wirklichkeit sind die Typen (wie in Smalltalk) selbst ein Objekt. Die Attribute eines Objektes können als Wörterbuch extrahiert werden.

Syntax

Eines der Entwurfsziele für Python war die gute Lesbarkeit des Quellcodes. Die Anweisungen benutzen häufig englische Schlüsselwörter, wo andere Sprachen Symbole einsetzen. Darüber hinaus besitzt Python weniger syntaktische Konstruktionen als viele andere strukturierte Sprachen wie C, Perl oder Pascal:

• zwei Schleifenformen
  • for zur Iteration über die Elemente einer Sequenz
  • while zur Wiederholung einer Schleife, solange ein logischer Ausdruck wahr ist.
• Verzweigungen
  • if … elif … else für Verzweigungen

Beim letzten Punkt bieten andere Programmiersprachen zusätzlich switch und/oder goto. Diese wurden zugunsten der Lesbarkeit in Python weggelassen und müssen durch if-Konstrukte oder andere Verzweigungsmöglichkeiten (Slices, Wörterbücher) abgebildet werden.

Strukturierung durch Einrücken

Python benutzt wie Miranda und Haskell Einrückungen als Strukturierungselement. Diese Idee wurde erstmals von Peter J. Landin vorgeschlagen und von ihm off-side rule („Abseitsregel“) genannt. In den meisten anderen Programmiersprachen werden Blöcke durch Klammern oder Schlüsselwörter markiert, während verschieden große Leerräume außerhalb von Zeichenketten keine spezielle Semantik tragen. Bei diesen Sprachen ist die Einrückung zur optischen Hervorhebung eines Blockes zwar erlaubt und in der Regel auch erwünscht, aber nicht vorgeschrieben. Für Programmierneulinge wird der Zwang zu lesbarem Stil aber als Vorteil gesehen.

Hierzu als Beispiel die Berechnung der Fakultät einer Ganzzahl, einmal in C und einmal in Python:

Fakultätsfunktion in C (mit Einrückung):

int fakultaet(int x) {
    if (x > 1) {
        return x * fakultaet(x - 1);
    } else {
        return 1;
    }
}

Jetzt die gleiche Funktion in Python:

def fakultaet(x):
    if x > 1:
        return x * fakultaet(x - 1)
    else:
        return 1

Es ist jedoch darauf zu achten, die Einrückungen im gesamten Programmtext gleich zu gestalten. Die gemischte Verwendung von Leerzeichen und Tabulatorzeichen kann zu Problemen führen, da der Python-Interpreter Tab-Stops im Abstand von acht Leerzeichen annimmt. Je nach Konfiguration des Editors können Tabulatoren optisch mit weniger als acht Leerzeichen dargestellt werden, was zu Syntaxfehlern oder ungewollter Programmstrukturierung führen kann. Als vorbeugende Maßnahme kann man den Editor Tabulatoren durch eine feste Anzahl von Leerzeichen ersetzen lassen. Die Python-Distribution enthält in der Standardbibliothek das Modul tabnanny, welches die Vermischung von Tabulatoren und Leerzeichen zu erkennen und beheben hilft.

Man kann die Fakultätsfunktion aber auch wie in C in einer Zeile formulieren:

Die Fakultätsfunktion in C (ohne Einrückung):

int fakultaet(int x) { return (x > 1) ? (x * fakultaet(x - 1)) : 1; }

Die Fakultätsfunktion ohne Einrückung in Python:

def fakultaet(x): return x * fakultaet(x - 1) if x > 1 else 1

In diesem Fall endet in Python der "Block" (die Funktion) mit dem Zeilenende.

Funktionales Programmieren

Ausdrucksstarke syntaktische Elemente zur funktionalen Programmierung vereinfachen das Arbeiten mit Listen und anderen Sammeltypen. Eine solche Vereinfachung ist die Listennotation, die aus der funktionalen Programmiersprache Haskell stammt; hier bei der Berechnung der ersten fünf Zweierpotenzen:

zahlen = [1, 2, 3, 4, 5]
zweierpotenzen = [2 ** n for n in zahlen]

Weil in Python Funktionen als Argumente auftreten dürfen, kann man auch ausgeklügeltere Konstruktionen ausdrücken, wie den Continuation-passing style.

Pythons Schlüsselwort lambda könnte manche Anhänger der funktionalen Programmierung fehlleiten. Solche lambda-Blöcke in Python können nur Ausdrücke enthalten, aber keine Anweisungen. Damit sind sie nicht der allgemeinste Weg, um eine Funktion zurückzugeben. Die übliche Vorgehensweise ist stattdessen, den Namen einer lokalen Funktion zurückzugeben. Das folgende Beispiel zeigt dies anhand einer einfachen Funktion nach den Ideen von Haskell Brooks Curry:

def add_and_print_maker(x):
    def temp(y):
        print("{} + {} = {}".format(x, y, x + y))
    return temp

Damit ist auch Currying auf einfache Art möglich, um generische Funktionsobjekte auf problemspezifische herunterzubrechen. Hier ein einfaches Beispiel:

def curry(func, knownargument):
    return lambda unknownargument: func(unknownargument, knownargument)

Wird die curry-Funktion aufgerufen, erwartet diese eine Funktion mit zwei notwendigen Parametern sowie die Parameterbelegung für den zweiten Parameter dieser Funktion. Der Rückgabewert von curry ist eine Funktion, die dasselbe tut wie func aber nur noch einen Parameter benötigt.

Anonyme Namensräume (sog. Closures) sind mit den o. g. Mechanismen in Python ebenfalls einfach möglich. Ein simples Beispiel für einen Stack, intern durch eine Liste repräsentiert:

def stack():
  l = []
  def pop(): return l.pop()
  def push(element): l.append(element)
  def isempty(): return len(l) == 0
  return pop, push, isempty

POP, PUSH, ISEMPTY = stack()

Auf diese Weise erhält man die drei Funktionsobjekte POP, PUSH, ISEMPTY, um den Stack zu modifizieren bzw. auf enthaltene Elemente zu prüfen, ohne l direkt modifizieren zu können.

Ausnahmebehandlung

Python nutzt ausgiebig die Ausnahmebehandlung (engl. exception handling) als ein Mittel, um Fehlerbedingungen zu testen. Dies ist so weit in Python integriert, dass es teilweise sogar möglich ist, Syntaxfehler abzufangen und zur Laufzeit zu behandeln.

Ausnahmen haben einige Vorteile gegenüber anderen beim Programmieren üblichen Verfahren der Fehlerbehandlung (wie z. B. Fehler-Rückgabewerte und globale Statusvariablen). Sie sind Thread-sicher und können leicht bis in die höchste Programmebene weitergegeben oder an einer beliebigen anderen Ebene der Funktionsaufruffolge behandelt werden. Der korrekte Einsatz von Ausnahmebehandlungen beim Zugriff auf dynamische Ressourcen erleichtert es zudem, bestimmte auf Race Conditions basierende Sicherheitslücken zu vermeiden, die entstehen können, wenn Zugriffe auf bereits veralteten Statusabfragen basieren.

Der Python-Ansatz legt den Einsatz von Ausnahmen nahe, wann immer eine Fehlerbedingung entstehen könnte. Nützlich ist dieses Prinzip beispielsweise bei der Konstruktion robuster Eingabeaufforderungen:

while True:
    num = raw_input("Eine Zahl eingeben: ")
    try:
        num = int(num)
        break
    except ValueError:
        print("Eine _Zahl_, bitte!")

Dieser Code wird den Benutzer so lange nach einer Nummer fragen, bis dieser eine Zeichenfolge eingibt, die sich per int() in eine Ganzzahl konvertieren lässt. Durch die Ausnahmebehandlung wird hier vermieden, dass eine Fehleingabe zu einem Laufzeitfehler führt, der das Programm zur Beendigung zwingt.

Ebenso kann auch das hier nicht berücksichtigte Interrupt-Signal (SIGINT, häufig Strg+C) mittels Ausnahmebehandlung in Python abgefangen und behandelt werden (except KeyboardInterrupt: …).

Standardbibliothek

Python verfügt über eine große Standardbibliothek, wodurch es sich für viele Anwendungen gut eignet. Sie ist eine der größten Stärken von Python. Der überwiegende Teil davon ist plattformunabhängig, so dass auch größere Python-Programme oft auf Unix, Windows, Mac OS X und anderen Plattformen ohne Änderung laufen. Die Module der Standardbibliothek können mit in C oder Python selbst geschriebenen Modulen ergänzt werden.

Die Standardbibliothek ist besonders auf Internet-Anwendungen zugeschnitten, mit der Unterstützung einer großen Anzahl von Standardformaten und -Protokollen (wie MIME und HTTP). Module zur Schaffung grafischer Schnittstellen, zur Verbindung mit relationalen Datenbanken und zur Manipulation regulärer Ausdrücke sind ebenfalls enthalten.

Mit Hilfe des mitgelieferten Moduls Tkinter kann in Python (wie in Perl und Tcl) schnell eine grafische Oberfläche (GUI) mit Tk erzeugt werden. Es gibt darüber hinaus eine Vielzahl von weiteren Wrappern von anderen Anbietern. Sie stellen Anbindungen (engl. language bindings) zu GUI-Bibliotheken wie z. B. PyGTK, PyQt, PyKDE, wxPython, PyObjC und PyFLTK zur Verfügung.

Beispiel

Als nicht triviales Beispiel sei hier der kompakte Sortieralgorithmus Quicksort angegeben:

def quicksort(liste):
    if len(liste) <= 1:
        return liste
    pivotelement = liste.pop()
    links  = [element for element in liste if element < pivotelement]
    rechts = [element for element in liste if element >= pivotelement]
    return quicksort(links) + [pivotelement] + quicksort(rechts)

Hier ermöglicht insbesondere die Listennotation für die Variablen links und rechts eine kompakte Darstellung. Zum Vergleich eine iterative Formulierung dieser zwei Zeilen:

...
    links, rechts = [], [] # Leere Listen links und rechts
    pivotelement = liste.pop() # Das letzte Element aus der Liste nehmen
    for element in liste: # Die verkürzte Liste durchlaufen
        if element < pivotelement:
            links.append(element) # wenn < dann an linke Liste anhängen
        else:
            rechts.append(element) # wenn nicht < (also >=) dann an rechte Liste anhängen
...

Interaktive Benutzung

So wie LISP, Ruby, Groovy und Perl unterstützt der Python-Interpreter auch einen interaktiven Modus, in dem Ausdrücke am Terminal eingegeben und die Ergebnisse sofort betrachtet werden können. Das ist nicht nur für Neulinge angenehm, die die Sprache lernen, sondern auch für erfahrene Programmierer: Code-Stückchen können interaktiv ausgiebig getestet werden, bevor man sie in ein geeignetes Programm aufnimmt.

Darüber hinaus steht mit Python Shell ein Kommandozeileninterpreter für verschiedene unixoide Computer-Betriebssysteme zur Verfügung, der neben klassischen Unix-Shellkommandos auch direkte Eingaben in Python-Form verarbeiten kann.

Implementierungen

Mit Cython steht ein Compiler zur Verfügung, mit dem Python-Code in effiziente C-Erweiterungen übersetzt oder externer C-Code angebunden werden kann. Ferner gibt es einen in Java implementierten Python-Interpreter namens Jython, mit dem die Bibliothek des Java Runtime Environments für Python verfügbar gemacht wird. Ebenso existiert eine Python-Implementierung (IronPython) für die .NET- bzw. Mono-Plattform. Um Python als Skriptsprache für Programme in C++ zu nutzen, setzt sich vermehrt die Boost.Python-Bibliothek durch. Ein Python-Parser für Parrot und ein in Python geschriebener Interpreter für Python, PyPy, welcher von der EU gefördert wurde, sind ebenfalls in Entwicklung. Es existiert ein Python-Interpreter für Mikrocontroller namens PyMite.

Entwicklungsumgebung

Neben IDLE, das oft mit Python installiert wird und im Wesentlichen aus einer Textumgebung und einer Shell besteht und der ähnlichen, aber um zahlreiche Funktionen erweiterten Umgebung IPython, wurden auch einige vollwertige Entwicklungsumgebungen (IDEs) für Python entwickelt, beispielsweise Eric Python IDE oder PyCharm. Des Weiteren existieren Plugins für größere IDEs wie Eclipse, Visual Studio und NetBeans. Texteditoren für Programmierer wie Vim und Emacs lassen sich gegebenenfalls auch für Python anpassen. Allerdings ist keine IDE notwendig, da Pythoncode nicht kompiliert werden muss, sodass sich Skripte grundsätzlich auch mit einem beliebigen Texteditor schreiben lassen.

Für die verschiedenen GUI-Frameworks, wie z. B. Tkinter (GUI-Builder), WxPython (wxGlade), PyQt (Qt Designer), PySide, PyGTK (Glade), Kivy oder PyFLTK gibt es teils eigene Editoren, mit denen sich grafische Benutzeroberflächen auf vergleichsweise einfache Art aufbauen lassen.

Verbreitung und Einsatz

Python ist für die meisten gängigen Betriebssysteme frei erhältlich und eine der drei Sprachen, die häufig in einer LAMP-Umgebung eingesetzt werden. Um Python in den Webserver einzubinden, wurde Mod Python entwickelt, das die Ausführung im Vergleich zu CGI wesentlich beschleunigt und Daten persistent speichern kann. Als Alternative stellt WSGI eine universelle Schnittstelle zwischen Webserver und Python(-Framework) zur Verfügung.

Eine Reihe von Web-Application-Frameworks nutzt Python, darunter Django, Pylons, SQLAlchemy, TurboGears, web2py, Flask oder Zope. Ferner gibt es einen Python-Interpreter für das Symbian-Betriebssystem, so dass Python auf verschiedenen Mobiltelefonen verfügbar ist. In der Version 2.5.1 ist Python ein Bestandteil von AmigaOS 4.0. Außerdem basieren mehrere bekannte kommerzielle Projekte, etwa Google und YouTube in Teilen auf Python. Auch in der Spieleindustrie findet die Sprache bisweilen Einsatz, etwa in EVE Online, World in Conflict und Civilization IV.

Im Rahmen des Projektes 100-Dollar-Laptop wird Python als Standardsprache der Benutzeroberfläche verwendet. Da der 100-Dollar-Laptop für die Schulausbildung von Kindern konzipiert ist, soll bei Benutzung der dafür gestalteten grafischen Benutzeroberfläche „Sugar“ auf Knopfdruck der gerade laufende Python-Quellcode angezeigt werden. Damit soll Kindern die Möglichkeit gegeben werden, die dahinter liegende Informationstechnologie real zu erleben und nach Belieben „hinter die Kulissen“ zu schauen.

Kritik

Bei der Definition (aber nicht beim Aufruf) von Methoden muss der Parameter self, der der Instanz entspricht, dessen Methode aufgerufen wird, explizit angegeben werden. Dies wird oft als unelegant und nicht objektorientiert empfunden. Es ist aber nötig, um bestimmte wichtige Konstrukte zu ermöglichen; außerdem entspricht es dem Python-Grundsatz „Explicit is better than implicit“.

In einer Methodendefinition erfordert der Aufruf der Basisklassenversion derselben Methode die explizite Angabe der Klasse und Instanz. Dies wird als Verletzung des DRY-Prinzips („Don’t repeat yourself“) gesehen und behindert Umbenennungen. In Python 3.0 wurde dieser Punkt aber behoben.

Einige in anderen Sprachen gebräuchliche Kontrollstrukturen sind in Python nicht vorhanden und müssen daher mithilfe von Ersatzstrukturen nachgeahmt werden.

Auf Multiprozessor-Systemen behindert der sogenannte Global Interpreter Lock (GIL) von CPython die Effizienz von Python-Anwendungen, die softwareseitiges Multithreading benutzen. Diese Beschränkung existiert unter Jython oder IronPython allerdings nicht. Bislang ist von offizieller Seite nicht geplant, den GIL zu ersetzen. Stattdessen wird empfohlen, mehrere miteinander kommunizierende Prozesse anstelle von Threads zu verwenden.

In den aktuell vorherrschenden Implementationen ist die Geschwindigkeit niedriger als bei vielen kompilierbaren Sprachen, aber ähnlich wie bei Perl, PHP oder Smalltalk und höher als bei Ruby. Das liegt zum Teil daran, dass bei der Entwicklung von CPython der Klarheit des Codes gegenüber der Geschwindigkeit Vorrang eingeräumt wird. Man beruft sich dabei auf Autoritäten wie Donald Knuth und Tony Hoare, die von verfrühter Optimierung abraten. Wenn Performanceprobleme auftreten, die nicht durch Optimierung des Python-Codes gelöst werden können, werden stattdessen JIT-Compiler wie PyPy verwendet oder zeitkritische Funktionen in maschinennähere Sprachen wie C oder gar Assembler (CorePy) ausgelagert.

Literatur

Für den Einstieg

• Hans Petter Langtangen: A Primer on Scientific Programming with Python. Springer 2014. ISBN 978-3-642-54958-8
• Mark Pilgrim: Dive Into Python. Springer, New York 2004. ISBN 1-59059-356-1 (Download verfügbar)
• Mark Pilgrim: Dive Into Python 3. Springer, New York 2009. ISBN 1-4302-2415-0 (Download verfügbar)
• Mark Pilgrim, Florian Wollenschein: Python 3 – Intensivkurs Springer, Berlin 2010. ISBN 978-3-642-04376-5 (Deutsche Übersetzung von Dive Into Python 3) (das Buch bei google-books)
• C H. Swaroop: A byte of Python. (Download verfügbar)
• Thomas Theis: Einstieg in Python, Galileo Press, Bonn 2011, 3. Auflage. ISBN 978-3-8362-1738-5
• Thomas Theis: Einstieg in Python 3, Galileo Press, Bonn 2009. ISBN 978-3-8362-1406-3
• Mark Lutz, David Ascher: Einführung in Python, O’Reilly, Cambridge 2000. ISBN 3-89721-129-7
• Martin Uzák: Python 2.x. Das Einsteigerseminar, bhv, Bonn 2002. ISBN 3-8266-7206-2
• Peter Walerowski: Python – Grundlagen und Praxis, Addison-Wesley, München 2008. ISBN 3-8273-2517-X
• Ivan van Laningham: Jetzt lerne ich Python, Markt+Technik, München 2000. ISBN 3-8272-5843-X

Referenzen

• Martin von Löwis, Nils Fischbeck: Python 2 – Einführung und Referenz der objektorientierten Skriptsprache, Addison-Wesley, ISBN 3-8273-1691-X
• Michael Weigend: Python GE-PACKT, mitp-Verlag, ISBN 3-8266-0724-4
• Michael Lauer: Python und GUI-Toolkits, mitp-Verlag, ISBN 3-8266-0844-5

Weiterführendes

• Peter Kaiser, Johannes Ernesti: Python – Das umfassende Handbuch – Aktuell zu Python 2.5, Galileo Press, ISBN 978-3-8362-1110-9, Download verfügbar
• Farid Hajji: Das Python-Praxisbuch, Addison-Wesley, ISBN 978-3-8273-2543-3
• Stefan Schwarzer: Python Workshop, Addison-Wesley, ISBN 3-8273-1880-7
• Michael Weigend: Objektorientierte Programmierung mit Python, mitp-Verlag, ISBN 3-8266-0966-2
• Hans P. Langtangen: Python Scripting for Computational Science, Springer, ISBN 3-540-43508-5
• Thomas W. Christopher: Python Programming Patterns, Prentice Hall, ISBN 0-13-040956-1
• Gregor Lingl: Python für Kids, mitp-Verlag, ISBN 3-8266-0951-4
• Jason R. Briggs: Snake Wrangling for Kids – Learning to Program with Python, engl.. Für achtjährige und ältere Kinder, Creative Commons Lizenz.
• Schlangengerangel für Kinder – Programmieren Lernen für Kinder Deutsche Version von Snake Wrangling for Kids. Für achtjährige und ältere Kinder, Creative Commons Lizenz.
• David Goodger, Code Like a Pythonista: Idiomatic Python (Abruf 19. November 2011)

Weblinks

Commons: Python – Sammlung von Bildern, Videos und Audiodateien

Wikibooks: Python 2 unter Linux – Lern- und Lehrmaterialien

• Offizielle Website (englisch)
• Das deutsche Python-Forum
• Python-Kurs.eu – Online-Kurs und Tutorials für Python 2 und 3
• Eric S. Raymond über seine Erfahrungen mit Python (englisch)
• Automatisierung von Windows-Anwendungen mit Python und COM (englisch)