Python ([ˈpʰaɪθn̩], [ˈpʰaɪθɑn], auf Deutsch auch [ˈpʰyːtɔn]) ist eine universelle, üblicherweise interpretierte, höhere Programmiersprache. Sie hat den Anspruch, einen gut lesbaren, knappen Programmierstil zu fördern. So werden beispielsweise Blöcke nicht durch geschweifte Klammern, sondern durch Einrückungen strukturiert.

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 weist ein offenes, gemeinschaftsbasiertes Entwicklungsmodell auf, das durch die gemeinnützige Python Software Foundation gestützt wird, die die Definition der Sprache in der Referenzumsetzung CPython pflegt.

Entwicklungsgeschichte

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, wie das Logo vermuten lässt, auf die gleichnamige Schlangengattung Python zurück, sondern bezog sich ursprünglich auf die englische Komikergruppe 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. Die erste Vollversion erschien im Januar 1994 unter der Bezeichnung Python 1.0. Gegenüber früheren Versionen wurden einige Konzepte der funktionalen Programmierung implementiert, die allerdings später wieder aufgegeben wurden. Von 1995 bis 2000 erschienen neue Versionen, 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 Garbage Collection (automatische Speicherbereinigung) und die Unterstützung für den Unicode-Zeichensatz. 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 Änderungen an der Sprache, etwa das Entfernen von Redundanzen bei Befehlssätzen und veralteten Konstrukten. Da Python 3.0 hierdurch teilweise inkompatibel zu früheren Versionen ist, beschloss die Python Software Foundation, Python 2.7 parallel zu Python 3 bis Ende 2019 weiter mit neuen Versionen zu unterstützen (für Hinweise zur letzten 2er-Versionen, dem Support-Ende und Hilfe zur Migration siehe Abschnitt Ende von Python 2).

Versionen

Ziele

Python wurde mit dem Ziel größter Einfachheit und Übersichtlichkeit entworfen. 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 in anderen Sprachen.

Van Rossum legte bei der Entwicklung großen Wert auf eine Standardbibliothek, die überschaubar und leicht erweiterbar ist. Dies war Ergebnis seiner schlechten Erfahrung mit der Sprache ABC, in der das Gegenteil der Fall ist. Dieses Konzept ermöglicht, in Python Module aufzurufen, die in anderen Programmiersprachen geschrieben wurden, etwa um Schwächen von Python auszugleichen. Beispielsweise können für zeitkritische Teile in maschinennäheren Sprachen wie C implementierte Routinen aufgerufen werden. Umgekehrt lassen sich mit Python Module und Plug-ins für andere Programme schreiben, die die entsprechende Unterstützung bieten. Dies ist unter anderem bei Blender, Cinema 4D, GIMP, Maya, OpenOffice bzw. LibreOffice, PyMOL, SPSS, QGIS oder KiCad der Fall.

Python ist eine Multiparadigmensprache. Das bedeutet, Python zwingt den Programmierer nicht zu einem einzigen Programmierstil, sondern erlaubt, 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 Freigabe nicht mehr benutzter Speicherbereiche erfolgt durch Referenzzählung. Datentypen werden dynamisch verwaltet, eine automatische statische Typprüfung wie z. B. bei C++ gibt es nicht. Jedoch unterstützt Python ab Version 3.5 optionale Typ-Annotationen, um eine statische Typprüfung mithilfe externer Software, wie zum Beispiel Mypy, zu vereinfachen.

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.

Die üblichen Zeichenkettenoperationen werden unterstützt. Zeichenketten sind in Python allerdings unveränderliche Objekte (wie auch in Java). Daher geben Operationen, die eine Zeichenkette verändern sollen – wie z. B. durch Ersetzen von Zeichen – immer eine neue Zeichenkette zurück.

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.

Mit dem Format-Operator % gibt es eine implizite Umwandlung eines Objekts in eine Zeichenkette. Der Operator == überprüft zwei Objekte auf (Wert-)Gleichheit. Der Operator is überprüft die tatsächliche Identität zweier Objekte.

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 (z. B. or statt ||). Für strukturierte Programmierung besitzt Python die folgenden Elemente:

• Schleifen (wiederholte Ausführung):
  • for … else zur Iteration über die Elemente einer Sequenz
  • while … else zur Wiederholung, solange ein Ausdruck den Boolean-Wert True hat
• Verzweigungen (bedingte Ausführung):
  • if … elif … else für bedingte Verzweigungen
  • match … case … if für strukturiertes Pattern Matching
• Exceptions (Ausführung im Fehlerfall):
  • try … except … else … finally für Ausnahmebehandlungen
  • with zum Ausführen eines Blocks mit einem Kontext-Manager

Im Gegensatz zu vielen anderen Sprachen können for- und while-Schleifen einen else-Zweig haben. Dieser wird nur ausgeführt, wenn die Schleife vollständig durchlaufen und nicht mittels break, return oder eines Ausnahmefehlers abgebrochen wurde.

int factorial(int x) {
    if (x <= 1)
        return 1;

    return x * factorial(x - 1);
}

def factorial(x):
    if x <= 1:
        return 1

    return x * factorial(x - 1)

int factorial(int x) {
    return x <= 1 ? 1 : x * factorial(x - 1);
}

def factorial(x):
    return 1 if x <= 1 else x * factorial(x - 1)

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

def add_and_print_maker(x):
    def temp(y):
        print(f'{x} + {y} = {x + y}')

    return temp

def curry(func, known_argument):
    return lambda unknown_argument: func(unknown_argument, known_argument)

def stack():
    l = []

    def pop():
        if not is_empty():
            return l.pop()

    def push(element):
        l.append(element)

    def is_empty():
        return len(l) == 0

    return pop, push, is_empty

pop, push, is_empty = stack()

while True:
    num = input("Eine ganze Zahl eingeben: ")

    try:
        num = int(num)
    except ValueError:
        print("Eine _Zahl_, bitte!")
    else:
        break

Standardbibliothek

Die mächtige Standardbibliothek ist eine der größten Stärken von Python, wodurch es sich für viele Anwendungen eignet. Der überwiegende Teil davon ist plattformunabhängig, so dass auch größere Python-Programme oft auf Unix, Windows, macOS 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 Internetanwendungen zugeschnitten, mit der Unterstützung einer großen Anzahl von Standardformaten und -protokollen (wie MIME und HTTP). Module zur Schaffung grafischer Benutzeroberflächen, zur Verbindung mit relationalen Datenbanken und zur Manipulation regulärer Ausdrücke sind ebenfalls enthalten.

Grafische Benutzeroberflächen (GUI)

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

Neben Tkinter wird auch ein Modul zum Zeichnen von Turtle-Grafiken mitgeliefert.

from tkinter import *

fenster = Tk()
fenster.geometry("200x100")
label = Label(fenster, text="Hallo Welt!")
label.pack()

def befehl():
    fenster.destroy()

button = Button(fenster, text="OK", command=befehl)
button.pack()
fenster.mainloop()

import turtle
from turtle import speed, reset, goto

reset()
speed(0)
turtle.x = -200
turtle.y = 200

while turtle.y != -200:
    goto(turtle.x, turtle.y)
    turtle.x = - turtle.x
    turtle.y = - turtle.y
    goto(turtle.x, turtle.y)
    goto(0, 0)
    turtle.y = - turtle.y
    turtle.x = - turtle.x
    turtle.y -= 5

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 für links und rechts anlegen
    pivotelement = liste.pop()      # das letzte Element aus der Liste nehmen als Referenz

    for element in liste:           # die restlichen Elemente der Liste durchlaufen ...
        if element < pivotelement:  # ... und mit dem Pivot-Element vergleichen
            links.append(element)   # wenn kleiner, dann an linke Liste anhängen
        else:
            rechts.append(element)  # ansonsten, wenn nicht kleiner, dann an rechte Liste anhängen
...

Dies ist nur ein Beispiel für die gesparte Schreibarbeit durch die Listennotation. Tatsächlich ist in diesem Fall die iterative Formulierung die schnellere, da pro Durchgang nur einmal über das Feld „liste“ iteriert wird und nicht zweimal wie in der Listennotation.

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. IPython ist eine populäre interaktive Python-Shell mit stark erweiterter Funktionalität.

Implementierungen

Interpreter

CPython ist die offizielle oder Referenzimplementierung der Programmiersprache Python und deren Interpreter.

Daneben gibt es einen in Java implementierten Python-Interpreter namens Jython, mit dem die Bibliothek der Java-Laufzeitumgebung für Python verfügbar gemacht wird.

Compiler

Außer den oben genannten Interpretern existieren Compiler, die Python-Code in eine andere Programmiersprache übersetzen.

Mit Cython kann Python-Code in effiziente C-Erweiterungen übersetzt oder externer C++- oder C-Code angebunden werden.

Ebenso existiert der Compiler IronPython für die .Net-Framework- bzw. Mono-Plattform.

Um Python als Skriptsprache für Programme in C++ zu nutzen, werden zumeist die Boost-Python-Bibliothek oder (in neueren Projekten) Cython verwendet.

Ein Python-Parser für Parrot und ein in Python geschriebener Just-in-time-Compiler für Python, PyPy, welcher von der EU gefördert wurde, sind ebenfalls in Entwicklung.

Auch die Python-Variante Pyston verwendet Just-in-time-Compilierung und beschleunigt so die Ausführung von Python-Programmen.

Außerdem existiert ein Python-Interpreter für Mikrocontroller namens MicroPython.

Entwicklungsumgebung

Neben IDLE, das oft mit Python installiert wird und hauptsächlich aus einer Textumgebung und einer Shell besteht, wurden auch einige vollwertige Entwicklungsumgebungen (IDEs) für Python entwickelt, beispielsweise Eric Python IDE, Spyder oder PyCharm. Weiterhin gibt es Plug-ins für größere IDEs wie Eclipse, Visual Studio, IntelliJ IDEA und NetBeans. Texteditoren für Programmierer wie Vim und Emacs lassen sich auch für Python anpassen: Ein einfacher Python-Mode ist bereits integriert, und komfortablere Erweiterungen können hinzugefügt werden.

Für die verschiedenen GUI-Toolkits, 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.

Paketverwaltung

Python unterstützt die Erstellung von Paketen; dabei helfen distutils und setuptools. Die Pakete werden auf PyPI, dem Python Package Index, gespeichert und von dort zur Installation abgerufen. Als Paketmanager wird üblicherweise pip oder auf alten Systemen auch easy_install eingesetzt. Paketversionen der Anaconda (Python-Distribution) werden von der Paketverwaltung conda verwaltet.

Verbreitung und Einsatz

Python ist für die meisten gängigen Betriebssysteme frei erhältlich und bei den meisten Linux-Distributionen im Standardumfang enthalten. Um Python in Webserver einzubinden, wird Webserver-umgreifend WSGI verwendet, welches die Nachteile von CGI umgeht. WSGI stellt 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 und 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.

Ende von Python 2

Die Unterstützung für Python 2 ist beendet. Die letzte 2er-Version war die 2.7.18 vom 20. April 2020; seit diesem Datum wird Python 2 nicht mehr unterstützt. Es gibt aber vielfältige und umfangreiche Dokumentationen zum Umstieg und auch Tools, die bei der Migration helfen oder es ermöglichen, Code zu schreiben, der mit Python 2 und 3 funktioniert.

Kritik

Bei der Definition von Methoden muss der Parameter self, der der Instanz entspricht, deren Methode aufgerufen wird, explizit als Parameter angegeben werden. Dies wird von Andrew Kuchling, Autor und langjähriger Python-Entwickler, als unelegant und nicht objektorientiert empfunden. Python-Schöpfer van Rossum verweist hingegen darauf, dass es nötig sei, um bestimmte wichtige Konstrukte zu ermöglichen. Einer der Python-Grundsätze lautet zudem „Explicit is better than implicit“.

Bis zur Version 3.0 wurde kritisiert, dass in einer Methodendefinition der Aufruf der Basisklassenversion derselben Methode die explizite Angabe der Klasse und Instanz erfordert. Dies wurde als Verletzung des DRY-Prinzips („Don’t repeat yourself“) gesehen; außerdem behinderte es Umbenennungen. In Python 3.0 wurde dieser Kritikpunkt behoben.

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 vorherrschenden Implementationen ist die Ausführungsgeschwindigkeit niedriger als bei vielen kompilierbaren Sprachen, aber ähnlich wie bei Perl, PHP, Dart und 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 Geschwindigkeitsprobleme 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 Cython ausgelagert.

Literatur

Für den Einstieg

• Allen B. Downey: Programmieren lernen mit Python. 2. Auflage. O’Reilly, Köln (u. a.) 2014, ISBN 978-3-95561-806-3, S. 297. 
• Bernd Klein: Einführung in Python 3. Für Ein- und Umsteiger. 2., überarb. und erw. Auflage. Hanser, München 2014, ISBN 978-3-446-44133-0, S. 494 (Inhaltsverzeichnis). 
• Thomas Theis: Einstieg in Python. Ideal für Programmieranfänger geeignet. 4., akt. u. erw. Auflage. Galileo Press, Bonn 2014, ISBN 978-3-8362-2861-9, S. 478 (Inhaltsverzeichnis). 
• Mark Lutz: Learning Python. 5. Auflage. O’Reilly, Sebastopol (u. a.) 2013, ISBN 978-1-4493-5573-9, S. 1540 (Inhaltsverzeichnis [PDF]). 
• Hans Petter Langtangen: A Primer on Scientific Programming with Python. .4. Auflage. Springer, 2014, ISBN 978-3-642-54958-8
• Mark Pilgrim, Florian Wollenschein: Python 3 – Intensivkurs. 1. Auflage. Springer, 2010, ISBN 978-3-642-04376-5
  (Deutsche Übersetzung von Dive Into Python 3 google-books)
• Mark Pilgrim: Dive Into Python 3. 2. Auflage. Springer, 2009, ISBN 1-4302-2415-0 (Download verfügbar)
• John Paul Mueller: Python programmieren lernen für Dummies. 1. Auflage. Wiley, Weinheim 2015, ISBN 978-3-527-71148-2, S. 379 (bei der Deutschen Nationalbibliothek). 
• Martina Glöde (Hrsg.): Programmieren supereasy. Einfacher Einstieg in Scratch und Python. Dorling Kindersley, München 2015, ISBN 978-3-8310-2700-2, S. 224. 
• Warren D. Sande; Carter Sande: Hello World! Programmieren für Kids und andere Anfänger. 2., akt. u. erw. Auflage. Hanser, München 2014, ISBN 978-3-446-43806-4, S. 475. 
• Michael Bonacina: Python 3 Programmieren für Einsteiger: Der leichte Weg zum Python-Experten, 2. Auflage. BMU Verlag, Landshut 2019, ISBN 978-3-96645-007-2.

Referenzen

• Michael Weigend: Python ge-packt. 6. Auflage. mitp, Frechen 2015, ISBN 978-3-8266-8726-6, S. 644. 
• Johannes Ernesti; Peter Kaiser: Python 3. Das umfassende Handbuch. 5., aktualisierte Auflage. Rheinwerk, Bonn 2017, ISBN 978-3-8362-5864-7 (rheinwerk-verlag.de – OpenBook beim Verlag). 
• Mark Lutz: Python. Kurz & gut. 5. Auflage. O’Reilly, Köln u. a. 2014, ISBN 978-3-95561-770-7, S. 270. 

Weiterführendes

• Luciano Ramalho: Fluent Python. Clear, concise, and effective programming. 1. Auflage. O’Reilly, Sebastopol CA u. a. 2015, ISBN 978-1-4919-4600-8, S. 744 (Inhaltsverzeichnis [PDF]). 
• Gregor Lingl: Python für Kids. 4. Auflage. bhv, 2010, ISBN 3-8266-8673-X.
• Farid Hajji: Das Python-Praxisbuch. 1. Auflage. Addison-Wesley, 2008, ISBN 978-3-8273-2543-3.
• Hans P. Langtangen: Python Scripting for Computational Science. 3. Auflage. Springer, 2008, ISBN 3-540-43508-5.
• Michael Weigend: Objektorientierte Programmierung mit Python. mitp-Verlag, 1. Auflage 2006, ISBN 3-8266-0966-2.
• Felix Bittmann: Praxishandbuch Python 3. Konzepte der Programmierung verstehen und anwenden. 1. Auflage. Books on Demand, Norderstedt 2020, ISBN 978-3-7519-0058-4, S. 240 (Inhaltsverzeichnis). 

Weblinks

• python.org (englisch)

Einzelnachweise