1. Python – kurz & gut
Einführung
Typografische Konventionen
Verwendung der Python-Befehlszeile
Python-Optionen
Angabe des Programms
Befehlsoptionen in Python 2.X
Umgebungsvariablen in Python
Operationale Variablen
Befehlszeilen-Optionsvariablen
Verwendung des Python Launchers unter Windows
Dateidirektiven des Launchers
Launcher-Befehlszeilen
Launcher-Umgebungsvariablen
Integrierte Typen und Operatoren
Operatoren und Vorrang
Atomare Terme und Dynamische Typisierung
Hinweise zum Gebrauch von Operatoren
Operationen nach Kategorien
Hinweise zu Operationen für Sequenzen
Besondere integrierte Typen
Zahlen
Literale und Erstellung
Operationen
Decimal und Fraction
Andere numerische Typen
Strings
Literale und Erstellung
Operationen
String-Formatierung
String-Formatierungsausdrücke
Syntax des Formatierungsausdrucks
String-Formatierungsmethode
Syntax der Formatierungsmethode
Template-String-Substitution
String-Methoden
byte- und bytearray Methoden
Suchmethoden
Methoden zum Aufteilen und Zusammenfügen
Formatierungsmethoden
Inhaltsprüfungen
Ursprüngliches string-Modul
Unicode-Strings
Unicode-Unterstützung in Python 3.X
bytes- und bytearray-Strings
Unicode-Unterstützung in Python 2.X
Listen
Literale und Erstellung
Operationen
Listenkomprehensionsausdrücke
Das Iterationsprotokoll
Generatorausdrücke
Andere Komprehensionsausdrücke
Dictionaries
Literale und Erstellung
Operationen
Tupel
Literale und Erstellung
Operationen
Dateien
Eingabedateien
Ausgabedateien
Alle Dateien
Andere file-Attribute (manche nur lesbar)
Dateikontextmanager
Hinweise zur Verwendung von Dateien
Sets
Literale und Erstellung
Operationen
Andere Typen und Konvertierungen
Boolesche Werte
Typkonvertierung
Anweisungen und Syntax
Syntaxregeln
Namensregeln
Namensformat
Namenskonventionen
Spezifische Anweisungen
Zuweisungsanweisungen
Erweiterte Zuweisung
Herkömmliche Sequenzzuweisung
Erweiterte Sequenzzuweisung (3.X)
Ausdrucksanweisungen
Aufrufsyntax
Aufrufsyntax für beliebige Anzahl Argumente
print-Anweisungen
print-Anweisungen in Python 2.X
Die if-Anweisung
Die while-Anweisung
Die for-Anweisung
Die pass-Anweisung
Die break-Anweisung
Die continue-Anweisung
Die del-Anweisung
Die def-Anweisung
Nur Schlüsselwortargumente in Python 3.X
Funktionsannotationen in Python 3.X
lambda-Ausdrücke
Funktionsstandardwerte und Attribute
Funktions- und Methodendekoratoren
Die return-Anweisung
Die yield-Anweisung
Änderungen bei Generatorfunktion in Python 3.3
Die global-Anweisung
Die nonlocal-Anweisung
Die import-Anweisung
Import von Paketen
Namensraumpakete ab Python 3.3
Importalgorithmus
Die from-Anweisung
Paketrelative import-Syntax
Die class-Anweisung
Klassendekoratoren in Python 3.X, 2.6 und 2.7
Metaklassen
Die try-Anweisung
try-Anweisungen in Python 2.X
Die raise-Anweisung
Verkettete Ausnahmen in Python 3.X
Klassenausnahmen
raise-Anweisungen in Python 2.X
Die assert-Anweisung
Die with-Anweisung
Mehrere Kontextmanager in Python 3.1 und 2.7
Kontextmanager-Protokoll
Python 2.X-Anweisungen
Namensraum und Gültigkeitsregeln
Qualifizierte Namen: Namensräume von Objekten
Unqualifizierte Namen: lexikalische Gültigkeitsbereiche
Verschachtelte Gültigkeitsbereiche und Funktionsabschlüsse
Umgebende Gültigkeitsbereiche und Standardwerte
Objektorientierte Programmierung
Klassen und Instanzen
Klassenobjekte bieten Standardverhalten
Instanzobjekte werden aus Klassen erzeugt
Vererbungsregeln
Pseudoprivate Attribute
Private Daten in Modulen
Private Daten in Klassen
Klassen neuen Stils
Formale Vererbungsregeln
Klassische Klassen: DFLR
Klassen neuen Stils: MRO
Beispiel: Keine Rautenform
Beispiel: Raute
Vererbungsalgorithmus neuen Stils
Vorrang und Kontext im neuen Stil
Methoden zur Operatorüberladung
Methoden für alle Typen
Methoden für Sammlungen (Sequenzen, Mappings)
Methoden für Zahlen (binäre Operatoren)
Grundlegende binäre Methoden
Rechtsseitige binäre Methoden
Erweiterte binäre Methoden
Methoden für Zahlen (andere Operationen)
Methoden für Deskriptoren
Methoden für Kontextmanager
Methoden zur Operatorüberladung in Python 2.X
Methoden in Python 3.X
Methoden in Python 2.X
Integrierte Funktionen
Integrierte Funktionen in Python 2.X
Integrierte Python 3.X-Funktionen, die Python 2.X nicht unterstützt
Integrierte Python 2.X-Funktionen, die Python 3.X nicht unterstützt
Integrierte Ausnahmen
Superklassen: Kategorien
Spezifische Ausnahmen
Spezifische OSError-Ausnahmen
Ausnahmen aus der Kategorie Warnungen
Warning Framework
Integrierte Ausnahmen in Python 3.2
Integrierte Ausnahmen in Python 2.X
Integrierte Attribute
Module der Standardbibliothek
Modul sys
Modul string
Funktionen und Klassen
Konstanten
Systemmodul os
Administrationswerkzeuge
Portierbarkeitskonstanten
Shell-Befehle
Umgebungswerkzeuge
Dateideskriptorwerkzeuge
Dateipfadwerkzeuge
Prozesssteuerung
Modul os.path
Mustervergleichsmodul re
Modulfunktionen
Pattern-Objekte
Match-Objekte
Muster-Syntax
Module für die Persistenz von Objekten
Module shelve und dbm
Dateien öffnen
Dateioperationen
Modul pickle
Pickling-Schnittstellen
Unpickling-Schnittstellen
Hinweise zum Gebrauch von pickle
tkinter - GUI-Modul und Tools
tkinter-Beispiel
Wichtige tkinter-Widgets
Allgemeine Dialogaufrufe
Modul tkinter.messagebox (tkMessageBox in Python 2.X)
Modul tkinter.simpledialog (tkSimpleDialog in Python 2.X)
Modul tkinter.colorchooser (tkColorChooser in Python 2.X)
Modul tkinter.filedialog (tkFileDialog in Python 2.X)
Zusätzliche tkinter-Klassen und Tools
Zuordnung Tcl/Tk zu Python/tkinter
Internetmodule und Tools
Andere Module der Standardbibliothek
Modul math
Modul time
Modul timeit
Modul datetime
Modul random
Modul json
Modul subprocess
Modul enum
Modul struct
Thread-Module
Pythons SQL-Datenbank-API
Anwendungsbeispiele zur API
Modulschnittstelle
Verbindungsobjekte
Cursor-Objekte
Typobjekte und Konstruktoren
Weitere Tipps und Idiome
Tipps zum Sprachkern
Tipps zur Umgebung
Tipps zur Benutzung
Sonstige Hinweise
Stichwortverzeichnis
Python ist eine universelle Programmiersprache, die mehrere Programmierparadigmen unterstützt: sowohl objektorientierte, funktionale als auch prozedurale Codestrukturen. Python wird sowohl für eigenständige Programme als auch für Skripten in den verschiedensten Anwendungsbereichen eingesetzt und gilt generell als eine der am weitesten verbreiteten Programmiersprachen der Welt.
Zu den wichtigsten Merkmalen von Python gehören der Fokus auf lesbaren Code und die Verwendung von Bibliotheken sowie ein Design, das die Produktivität der Entwickler, die Qualität der Software, die Portierbarkeit von Programmen und die Integration von Komponenten optimiert. Python-Programme laufen auf den meisten üblichen Plattformen, darunter Unix und Linux, Windows und Macintosh, Java und .NET, Android und iOS und andere.
Diese Taschenreferenz fasst Python-Typen und -Anweisungen, spezielle Methodennamen, integrierte Funktionen und Ausnahmen, häufig verwendete Module der Standardbibliothek und andere wichtige Python-Tools zusammen. Sie ist als kompakte Referenz für Entwickler und als Begleiter zu anderen Büchern gedacht, die Tutorien, Code, Beispiele und anderes Lehrmaterial liefern.
Die vorliegende fünfte Auflage behandelt gleichermaßen Python 3.X und 2.X. Sie befasst sich in erster Linie mit Python 3.X, dokumentiert aber auch die Unterschiede zu Version 2.X. Diese Auflage wurde auf den Stand der aktuellen Python-Versionen 3.4 und 2.7 aktualisiert. Der Inhalt dieses Buchs gilt aber größtenteils auch für ältere Versionen der Python-Zweige 3.X und 2.X.
Diese Ausgabe bezieht sich außerdem auf alle wichtigen Implementierungen von Python – einschließlich CPython, PyPy, Jython, IronPython und Stackless – und wurde den neuesten Änderungen entsprechend hinsichtlich Sprache, Bibliotheken und bewährten Arbeitsweisen aktualisiert und erweitert. Dazu gehören die neuen Abschnitte zu MRO und super()
, formalen Vererbungsalgorithmen, Importen, Kontextmanagern, der Einrückung von Codeblöcken sowie häufig verwendeten Bibliotheksmodulen und Tools einschließlich json
, timeit
, random
, subprocess
, enum
sowie zum Python Launcher für Windows.
In diesem Buch werden folgende Auszeichnungskonventionen verwendet:
[]
Eckige Klammern kennzeichnen in Syntaxformaten optionale Elemente, sind aber soweit angegeben auch Teil der Syntax (z.B. in Listen).
*
In Syntaxformaten werden Elemente, hinter denen ein Sternchen steht, null oder mehrmals wiederholt. Das Sternchen wird teilweise aber auch in der Syntax von Python verwendet (z.B. für die Multiplikation).
a
|
b
Alternativen werden in Syntaxformaten mit vertikale Balken gekennzeichnet. Der vertikalen Balken wird teilweise auch in der Syntax von Python verwendet (z.B. für die Vereinigung).
Kursivschrift
Wird für Dateinamen, URLs und zur Hervorhebung neuer Begriffe verwendet.
Nichtproportionalschrift
Kennzeichnet Code, Befehle, Befehlszeilenoptionen, Namen von Modulen, Funktionen, Attributen, Variablen und Klassen.
Nichtproportionalschrift kursiv
Wird für zu ersetzende Parameternamen in der Syntax für Kommandozeilen, Ausdrücke, Funktionen und Klassen verwendet.
Funktion()
Soweit nicht anders angegeben, werden aufrufbare Funktionen und Klassen mit zwei darauf folgenden runden Klammern gekennzeichnet, um sie von anderen Attributtypen zu unterscheiden.
Siehe »Abschnittsüberschrift«
Verweise auf andere Abschnitte dieses Buchs werden mit der jeweiligen Abschnitssüberschrift in Anführungszeichen angegeben.
In diesem Buch bedeuten »3.X« und »2.X«, dass sich ein Thema auf alle gebräuchlichen Versionen des entsprechenden Python-Zweigs bezieht. Genauere Versionsnummern zeigen, dass ein Thema nur für bestimmte Versionen gilt (z.B. bezieht sich »2.7« nur auf Version 2.7). Da sich die Gültigkeit durch Änderungen in künftigen Python-Versionen ändern kann, sollten Sie auch immer einen Blick auf die »What’s New«-Dokumente werfen, die momentan für die nach diesem Buch veröffentlichten Pythons unter http://docs.python.org/3/whatsnew/index.html gepflegt werden.
Mit Befehlszeilen können Sie Python-Programme von einer System-Shell aus starten. Befehlszeilen haben das folgende Format:
python
[optionen
*] [skriptdatei
| -cbefehl
| -mmodul
| - ] [arg
*]
In diesem Format steht python
für die ausführbare Datei des Python-Interpreters – entweder mit dem vollständigen Verzeichnispfad oder nur das Wort python
, das von der System-Shell ausgelöst wird (z.B. über die PATH
-Einstellung). Für Python selbst gedachte Befehlszeilenoptionen (optionen
) stehen vor dem Namen des auszuführenden Programmcodes. Argumente für den auszuführenden Code kommen danach (arg
).
Die Elemente von optionen
in
Befehlszeilen werden von Python selbst verwendet. In Python 3.X gibt es folgende Optionen
(siehe „Befehlsoptionen in Python 2.X“ für die Unterschiede zu 2.X):
-b
Setzt eine Warnung ab,
wenn str()
mit einem bytes
- oder bytearray
-Objekt, aber ohne Kodierungsargument aufgerufen oder ein bytes
- oder bytearray
-Objekt mit einem str
verglichen wird. Die Option -bb
meldet stattdessen einen Fehler.
-B
Keine .pyc- oder .pyo-Bytecode-Dateien für Importe schreiben.
-d
Schaltet die Debugging-Ausgabe für den Parser an (für Entwickler des Python-Core).
-E
Ignoriert die weiter unten beschriebenen
Umgebungsvariablen von Python (wie z.B. PYTHONPATH
).
-h
Gibt eine Hilfemeldung aus und beendet dann die Ausführung.
-i
Wechselt nach der Ausführung eines Skripts in den
interaktiven Modus. Tipp: nützlich für die Postmortem-Fehlersuche; siehe auch pdb.pm()
, wie in den Python Library-Handbüchern beschrieben.
-O
Optimiert den erzeugten Bytecode (erzeugt und verwendet .pyo-Bytecode-Dateien). Bringt momentan eine leichte Leistungssteigerung.
-OO
Wie -O
, entfernt aber außerdem
Docstrings aus dem Bytecode.
-q
Unterdrückt beim interaktiven Start die Ausgabe der Versions- und Urheberrechtsinformationen (ab Python 3.2).
-s
Das User-Siteverzeichnis
nicht zum Modulsuchpfad sys.path
hinzufügen.
-S
Unterdrückt »import site« bei der Initialisierung.
-u
Erzwingt, dass stdout und stderr ungepuffert und binär arbeiten.
-v
Gibt bei jeder Initialisierung eines Moduls eine Meldung aus, von wo das Modul geladen wurde. Wiederholen Sie diese Option für ausführlichere Meldungen.
-V
Gibt die Python-Versionsnummer aus
und beendet die Ausführung (alternativ können Sie auch --version
eingeben).
-W
arg
Warnungssteuerung: arg
hat die Form Aktion
:
Meldung
:
Kategorie
:
Modul
:
Zeilennummer
.
Siehe auch „Warning Framework“ und „Ausnahmen aus der Kategorie Warnungen“ weiter unten sowie die Dokumentation zum Modul warnings
in der Python Library Reference (unter http://www.python.org/doc/).
-x
Überspringt die erste Zeile des Quellcodes,
wodurch Sie auch Unix-fremde Schreibweisen von #!
cmd
verwenden können.
-X
option
Legt eine implementationsspezifische
Option fest (ab Python 3.2). Zulässige
Werte für option
finden Sie in der Implementierungsdokumentation.
Der auszuführende Code und dafür zu übergebende Befehlszeilenargumente werden in Python-Befehlszeilen folgendermaßen angegeben:
skriptdatei
Name der
Python-Skriptdatei, die als Hauptdatei eines Programms ausgeführt werden soll (z.B. führt python
main.py
den Code in main.py
aus). Der Name des Skripts kann ein absoluter oder relativer Dateipfad sein (relativ zu ».«) und wird in sys.argv[0]
zur Verfügung gestellt. Auf manchen Plattformen können Sie die Komponente python
auch weglassen, wenn Sie die Befehlszeile mit dem Namen der Skriptdatei beginnen und keine Optionen an Python selbst übergeben möchten.
-c
befehl
Gibt den auszuführenden
Python-Code (als String) an (z.B. führt python
-c "print('spam' * 8)"
eine print-Anweisung in Python aus). sys.argv[0]
enthält den Wert '-c'
.
-m
modul
Führt ein Modul als
Skript aus: Sucht nach modul
in sys.path
und führt dieses als Hauptdatei aus (zum Beispiel führt python
-m pdb s.py
das Python-Debugger-Modul pdb
aus dem Standardbibliotheksverzeichnis mit dem Argument s.py
aus). modul
darf auch der Name eines Pakets sein (z.B. idlelib.idle
). sys.argv[0]
enthält den vollständigen Pfad des Moduls.
−
Liest Python-Befehle aus dem
Standardeingabestream stdin (Standard) und wechselt in den interaktiven Modus, falls es sich bei stdin um ein »tty« (interaktives Gerät) handelt. sys.argv[0]
erhält den Wert '−'
.
arg
*
Gibt an, dass
der Rest der Befehlszeile an die Skriptdatei oder den Befehl übergeben und in der internen String-Liste sys.argv[1:]
erscheint.
Wenn skriptdatei
, befehl
oder modul
nicht angegeben werden, wechselt Python in den interaktiven Modus, nimmt Befehle vom stdin entgegen (unter Verwendung von GNU readline für die Eingabe falls installiert) und legt sys.argv[0]
auf den Wert ''
fest (Leerstring) – außer wenn die in dieser Liste erklärte Option »–«
angegeben wird.
Außer über herkömmliche Befehlszeilen an der Eingabeaufforderung einer System-Shell können Sie Python-Programme üblicherweise auch folgendermaßen ausführen:
Indem Sie in einem grafischen Dateibrowser auf den jeweiligen Dateinamen klicken; indem Sie Funktionen der Python-Standardbibliothek aufrufen (z.B. os.popen()
); über Programmstart-Menüoptionen in IDEs wie IDLE, Komodo, Eclipse, NetBeans usw.
Python 2.X unterstützt dasselbe Befehlszeilenformat,
aber nicht die Option -b
, die sich auf Änderungen des String-Typs in Python 3.X bezieht, ebenso wenig wie die in 3.X neu hinzugekommenen Optionen –q
und –X
. In den Versionen
2.6 und 2.7 werden dagegen zusätzlich folgende Optionen unterstützt (teilweise auch in früheren Versionen):
-t
und -tt
-t
gibt Warnmeldungen für
inkonsistente Mischungen von Tabs und Leerzeichen in Einrückungen aus. Die Option -tt
gibt statt Warnungen Fehlermeldungen aus. Python 3.X behandelt solche Mischungen immer als Syntaxfehler (siehe auch „Syntaxregeln“).
-Q
Divisionsbezogene Optionen:
-Qold
(Standard), -Qwarn
, -Qwarnall
und –Qnew
. Diese Optionen wurden in Python 3.X durch die echte Division subsumiert (siehe auch „Hinweise zum Gebrauch von Operatoren“).
-3
Gibt Warnmeldungen für jegliche Python 3.X-Inkompatibilitäten im Code aus, die das Tool 2to3 der Python-Standardinstallation nicht auf einfache Weise beheben kann.
-R
Aktiviert ein Pseudozufalls-Salt, um vorhersehbare Hash-Werte verschiedener Typen zwischen separaten Aufrufen des Interpreters zum Schutz vor Denial-of-Service-Angriffen zu verhindern. Neu ab Python 2.6.8. Diese Option gibt es im 3.X-Zweig aus Kompatibilitätsgründen ab Version 3.2.3. Die Zufallserzeugung von Hash-Werten ist ab Version 3.3 Standard.
Umgebungsvariablen (auch als Shell-Variablen bekannt), sind systemweite, programmübergreifende Einstellungen, die für die globale Konfiguration verwendet werden.
Die folgenden wichtigen, vom Benutzer konfigurierbaren Umgebungsvariablen beeinflussen das Verhalten von Skripten:
PYTHONPATH
Erweitert den Standardsuchpfad für importierte Moduldateien.
Das Format dieses Variablenwerts ist dasselbe wie für die Shell-Einstellung PATH
: Verzeichnispfade, die durch Doppelpunkte voneinander getrennt sind (Semikola unter Windows). Wenn diese Umgebungsvariable definiert ist, werden bei Modulimporten die importierten Dateien oder Verzeichnisse von links nach rechts in jedem in PYTHONPATH
aufgeführten Verzeichnis gesucht. Steht in sys.path
(dem vollständigen Modulsuchpfad für die am weitesten links stehenden Komponenten in absoluten Importen) nach dem Verzeichnis des Skripts und vor den Verzeichnissen der Standardbibliotheken. Siehe auch sys.path
im „Modul sys“, und im „Die import-Anweisung“.
PYTHONSTARTUP
Wenn diese Variable den Namen einer lesbaren Datei enthält, werden die Python-Befehle in dieser Datei ausgeführt, bevor die erste Eingabeaufforderung im interaktiven Modus angezeigt wird (nützlich für die Definition häufig verwendeter Tools).
PYTHONHOME
Wenn dieser Wert festgelegt ist,
wird er als alternatives Präfixverzeichnis für die Bibliotheksmodule (oder sys.prefix
, sys.exec_prefix
) verwendet. Der Standard-Modulsuchpfad nutzt sys.prefix/lib
.
PYTHONCASEOK
Wenn dieser Wert festgelegt ist, wird die Groß-/Kleinschreibung in import-Anweisungen ignoriert (derzeit nur unter Windows und OS X).
PYTHONIOENCODING
Weisen Sie den String Kodierung
[:
Fehler-Handler
] zu, um die
standardmäßige Unicode-Kodierung (und einen optionalen Fehler-Handler) für Textübertragungen zu den Streams stdin, stdout und stderr zu überschreiben. Diese Einstellung kann in manchen Shells für Nicht-ASCII-Texte erforderlich sein (versuchen Sie beispielsweise die Einstellung utf8
oder eine andere, falls die Ausgabe nicht korrekt erfolgt).
PYTHONHASHSEED
Bei Angabe von »random«
wird beim Seeden der Hash-Werte für str
-, bytes
- und datetime
-Objekte ein Zufallswert verwendet. Als Wert ist auch ein Integer im Bereich 0
...4.294.967.295
zulässig, um Hash-Werte mit einem vorhersehbaren Seed zu erhalten (ab Python 3.2.3 bzw. 2.6.8).
PYTHONFAULTHANDLER
Falls diese Variable gesetzt ist, registriert Python
beim Start Handler, um bei unbehebbaren Fehlern einen Traceback auszugeben (ab Python 3.3, entspricht -X faulthandler
).
Die folgenden Umgebungsvariablen sind gleichbedeutend mit einigen Befehlszeilenoptionen von Python (siehe „Python-Optionen“):
PYTHONDEBUG
Wenn nicht leer,
gleichbedeutend mit Option -d
.
PYTHONDONTWRITEBYTECODE
Wenn nicht leer,
gleichbedeutend mit Option -B
.
PYTHONINSPECT
Wenn nicht leer,
gleichbedeutend mit Option -i
.
PYTHONNOUSERSITE
Wenn nicht leer,
gleichbedeutend mit Option -s
.
PYTHONOPTIMIZE
Wenn nicht leer,
gleichbedeutend mit Option -O
.
PYTHONUNBUFFERED
Wenn nicht leer,
gleichbedeutend mit Option -u
.
PYTHONVERBOSE
Wenn nicht leer,
gleichbedeutend mit Option -v
.
PYTHONWARNINGS
Wenn nicht leer,
gleichbedeutend mit Option -W
, selber Wert. Akzeptiert auch einen durch Kommata getrennten String als Äquivalent für mehrere -W
-Optionen.
(Ab Python 3.2 und 2.7.)
Unter Windows (und nur unter Windows),
installieren Python 3.3 und spätere Versionen einen Skript-Launcher, der für frühere Versionen auch separat verfügbar ist. Dieser Launcher besteht aus den ausführbaren Dateien py.exe
(Konsole) und pyw.exe
(Fenster), die ohne PATH
-Einstellungen aufgerufen werden können, durch Dateinamenszuordnung für die Ausführung von Python-Dateien registriert sind und drei Möglichkeiten zur Auswahl der Python-Version bieten: mit Unix-artigen »#!«-Direktiven oben im Skript, Befehlszeilenargumenten und konfigurierbaren Standardwerten.
Der Launcher
erkennt »#!«-Zeilen im oberen Teil von Skriptdateien, die Python-Versionen in einer der folgenden Formen zitieren. Dabei ist *
entweder: leer, um die Standardversion zu verwenden (aktuell 2
, falls installiert, ähnlich wie ohne »#!«-Zeile); eine Major-Versionsnummer (z.B. 3
), um die neueste installierte Version dieses Zweigs zu starten; oder eine vollständige Versionsangabe von Major
.
Minor
, optional gefolgt von −32
, falls Sie eine 32-Bit-Installation bevorzugen (z.B. 3.1–32
):
#!/usr/bin/env python* #!/usr/bin/python* #!/usr/local/bin/python* #!python*
Am Zeilenende können Sie beliebige Argumente für Python (python.exe
) angeben. Python 3.4 und später suchen unter Umständen in PATH
nach »#!«-Zeilen, die python
ohne explizite Versionsnummer angeben.
Der Launcher kann auch von einer System-Shell aus über Befehlszeilen der folgenden Form aufgerufen werden:
py [pyarg
] [pythonarg
*]skript.py
[skriptarg
*]
Allgemeiner ausgedrückt kann alles, was in einem python
-Befehl nach der Komponente python
stehen kann, auch nach dem optionalen pyarg
in einem py
-Befehl stehen und wird Wort für Wort an das gestartete Python übergeben. Das gilt auch für die Angaben -m
, -c
und -
, siehe „Verwendung der Python-Befehlszeile“.
Der Launcher akzeptiert für das optionale pyarg
folgende Argumentformen, die dem Teil mit dem *
am Ende der »#!«-Zeile entsprechen:
−2Neueste installierte 2.X-Version starten
-3Neueste installierte 3.X
-Version starten -X
.Y
Angegebene Version starten (X ist 2 oder 3)
-X
.Y
−32Angegebene 32-Bit-Version starten
Falls beide Angaben vorhanden sind, haben die Befehlszeilenargumente vor anderen, in den »#!«-Zeilen definierten Werten Vorrang. Bei einer Standardinstallation werden »#!«-Zeilen unter Umständen auf mehr Kontexte angewandt (z.B. Klicks auf Symbole).
Auch der Launcher
kennt optionale Umgebungsvariablen, mit deren Hilfe die Versionswahl generell oder in bestimmten Fällen angepasst werden kann (z.B. fehlendes »#!«, nur Major-Angabe oder py
-Befehlsargument):
PY_PYTHON Version für Standardfälle (sonst 2) PY_PYTHON3 Version für 3-Partials (z.B. 3.2) PY_PYTHON2 Version für 2-Partials (z.B. 2.6)
Diese Einstellungen werden nur bei der Ausführung von Dateien über den Launcher verwendet, nicht wenn python
direkt aufgerufen wird.
Tabelle 1.1 zeigt die Ausdrucksoperatoren in Python. Die Operatoren in den unteren Zellen dieser Tabelle haben einen höheren Vorrang (also eine stärkere Bindung), wenn sie ohne Klammern mit anderen Operatoren gemischt werden.
In Tabelle 1.1 können die
ersetzbaren Ausdruckselemente X
, Y
, Z
, i
, j
und k
Folgendes sein:
Variablennnamen, die durch den zuletzt zugewiesenen Wert ersetzt werden
Literale, definiert im „Besondere integrierte Typen“
Verschachtelte Ausdrücke aus einer beliebigen Zeile dieser Tabelle, möglicherweise in Klammern
Python-Variablen folgen einem dynamischen Typisierungsmodell – sie werden nicht deklariert und erst bei Zuweisung eines Wertes angelegt. Variablen haben Objektverweise als Wert und können auf einem beliebigen Objekttyp verweisen. Außerdem müssen Variablen zugewiesen werden, bevor sie in einem Ausdruck verwendet werden können, und haben keinen Standardwert. Bei Variablennnamen kommt es immer auf die Groß-/Kleinschreibung an (siehe „Namensregeln“). Die Objekte, auf die Variablen verweisen, werden automatisch erzeugt und automatisch vom Garbage Collector (verwendet Referenzzähler in CPython) von Python zurückgefordert, wenn sie nicht mehr verwendet werden.
Außerdem muss in Tabelle 1.1 attr
der literale Name eines Attributs (ohne Anführungszeichen) sein. args1
ist eine formale Argumentenliste wie im „Die def-Anweisung“, definiert. args2
ist eine Eingabeargumentliste, wie im „Ausdrucksanweisungen“, definiert. Und das Literal ...
qualifiziert in 3.X (und nur da) als atomarer Ausdruck.
Die Syntax für Komprehensionen und Datenstrukturliterale (Tupel, Liste, Dictionary und Set), die in den letzten drei Zeilen von Tabelle 1.1 abstrakt dargestellt wird, wird im „Besondere integrierte Typen“, definiert.
Tabelle 1.1 Python 3.X: Ausdrucksoperatoren und deren Vorrang
Operator |
Beschreibung |
---|---|
|
Generatorfunktionsergebnis (liefert |
|
Erzeugt eine anonyme Funktion (liefert beim Aufruf |
|
Ternäre Auswahl ( |
|
Logisches |
|
Logisches |
|
Logische Negation |
|
Enthaltensein: iterierbare Objekte, Sets |
|
Objektidentität testen |
|
Größenvergleich, Teilmengen und Obermengen von Sets |
|
Gleichheitsoperatoren |
|
Bitweises |
|
Bitweises exklusives |
|
Bitweises |
|
Schiebt |
|
Addition/Verkettung, Subtraktion/Set-Differenz |
|
Multiplikation/Wiederholung, Rest/Formatieren, Division, restlose Division |
|
Unäre Negation, Identität |
|
Bitweises NOT-Komplement (Umkehrung) |
|
Potenzierung |
|
Indizierung (Sequenzen, Mappings, andere) |
|
Slicing (alle drei Grenzen optional) |
|
Aufruf (Funktion, Methode, Klasse und andere aufrufbare Objekte) |
|
Attributreferenz |
|
Tupel, Ausdruck, Generatorausdruck |
|
Liste, Listenkomprehension |
|
Dictionary, Set, Dictionary- und Set-Komprehension |
Nur in Python 2.X
kann Wertungleichheit entweder als X
!=
Y
oder X
<>
Y
geschrieben werden. In Python 3.X
wurde die zweite Option wegen Redundanz entfernt.
Nur in Python 2.X ist ein Ausdruck mit Backticks `
X
`
gleichbedeutend mit repr(
X
)
und wandelt Objekte für die Anzeige in Strings um. In Python 3.X verwenden Sie stattdessen die besser lesbaren integrierten Funktionen str()
und repr()
.
Sowohl in Python 3.X als auch in 2.X schneidet die restlose Division X
//
Y
die Restbruchteile immer ab und liefert als Ergebnis eine ganze Zahl.
Der Ausdruck X
/
Y
führt in 3.X eine echte Division durch (die ein Fließkommaergebnis zurückliefert, wobei der Rest erhalten bleibt). In Python 2.X führt dieser Ausdruck dagegen eine klassische Division durch (bei der für ganze Zahlen der Rest abgeschnitten wird), außer die echte Division aus 3.X ist über from __future__ import division
oder die Python-Option -Qnew
aktiviert.
Die Syntax [....]
wird sowohl für Listenliterale als auch für Listenkomprehensionsausdrücke verwendet. Letztere durchlaufen eine implizite Schleife und sammeln die Ergebnisse der Ausdrücke in einer neuen Liste.
Die Syntax (....)
wird für Tupel, Ausdrücke und Generatorausdrücke verwendet – eine Form der Listenkomprehension, die Ergebnisse auf Anfrage liefert, anstatt eine Ergebnisliste aufzubauen. In allen drei Konstruktionen können Klammern manchmal ausgelassen werden.
Die Syntax {....}
wird für Dictionary-Literale benutzt. In Python 3.X und 2.7
dient sie auch für Set-Literale und Dictionary- sowie Set-Komprehensionen. In 2.6 und früheren Versionen verwenden Sie set()
und Schleifenanweisungen.
.
yield
und der ternäre Auswahlausdruck if
/else
stehen ab Python 2.5 zur Verfügung.
yield
liefert send()
-Argumente in Generatoren. if/else
ist die Kurzschreibweise für eine mehrzeilige if
-Anweisung. Für yield
sind Klammern erforderlich, wenn der Ausdruck auf der rechten Seite einer Zuweisungsanweisungen nicht alleine steht.
Vergleichsoperatoren können verkettet werden: X
<
Y
<
Z
liefert dieselbe Ergebnis wie X
<
Y
and
Y
<
Z
, jedoch wird Y
in der verketteten Form nur einmal ausgewertet.
Der Slice-Ausdruck X
[
i
:
j
:
k
]
entspricht der Indizierung mit einem Slice-Objekt: X
[slice(
i
,
j
,
k
)]
.
In Python 2.X sind Größenvergleiche unterschiedlicher Typen zulässig – Zahlen werden in einen gemeinsamen Typ konvertiert, andere gemischte Typen werden nach dem Typnamen geordnet. In Python 3.X sind Größenvergleiche nicht-numerischer gemischter Typen nicht zulässig und lösen Ausnahmen aus, einschließlich der Sortierung über Proxy-Objekte.
Größenvergleiche für Dictionaries werden in Python 3.X (im Gegensatz zu Gleichheitsprüfungen) nicht mehr unterstützt. Ein möglicher Ersatz in 3.X ist der Vergleich von sorted(
adict
.items())
.
Aufrufausdrücke unterstützen Positions- und Schlüsselwortargumente sowie eine beliebig große Anzahl beider Arten, siehe „Ausdrucksanweisungen“, und „Die def-Anweisung“, für die Aufrufsyntax.
Python 3.X gestattet die Verwendung von Ellipsen ( ...
, intern bekannt unter dem Namen Ellipsis
) als atomare Ausdrücke an beliebigen Stellen im Quellcode. In manchen Kontexten (z.B. Funktion-Stubs, typenunabhängige Variableninitialisierung) können sie als Alternative zu pass
oder None
verwendet werden.
Es war zwar noch ungewiss, als dieses Buch geschrieben wurde: Es kann aber sein, dass
in Python 3.5 oder einer späteren Version unter Umständen die Syntax *
X
und **
X
so verallgemeinert wird, so dass sie auch in Datenstrukturliteralen und Komprehensionen verwendet werden kann, um Sammlungen in einzelne Elemente zu entpacken – ähnlich wie derzeit in Funktionsaufrufen. Weitere Informationen dazu finden Sie im „Zuweisungsanweisungen“.
In diesem Abschnitt
werden abschließende Klammern der Einfachheit halber bei Methodennamen der Form __
X
__
weggelassen. Im Wesentlichen unterstützen alle integrierten Typen die in Tabelle 1.2 genannten Vergleichs- und Booleschen Operationen (jedoch unterstützt Python 3.X keine Größenvergleiche für Dictionaries oder gemischte nicht-numerische Typen).
Der Boolesche Wert true bedeutet eine beliebige Zahl ungleich null oder ein beliebiges nicht leeres Sammlungsobjekt (Liste, Dictionary etc.).
Alle Objekte haben einen Booleschen Wert. Die integrierten Namen True
und False
sind den Wahrheitswerten »wahr« und »falsch« zugeordnet und verhalten sich wie die Integer 1
und 0
mit einem eigenen Anzeigeformat. Das besondere Objekt None
hat den Wert »falsch« und kommt in verschiedenen Python-Kontexten vor.
Vergleiche
liefern True
oder False
und werden in zusammengesetzten Objekten automatisch rekursiv angewandt, um ein Ergebnis zu ermitteln.
Die Auswertung der Booleschen Operatoren and
und or
wird abgebrochen (Kurzschluss), sobald ein Ergebnis bekannt ist, und liefert das Operandenobjekt zurück – der Wert links oder rechts vom Operator – dessen Boolescher Wert zum Ergebnis führt.
Tabelle 1.2 Vergleiche und Boolesche Operationen
Operator |
Beschreibung |
---|---|
|
Streng kleiner als[a] |
|
Kleiner oder gleich |
|
Streng größer als |
|
Größer oder gleich |
|
Gleich (gleicher Wert) |
|
Ungleich (nur in Python 2.X gleichbedeutend mit |
|
Objektgleichheit |
|
Negierte Objektgleichheit |
|
Verkettete Vergleiche |
|
Wenn |
|
Wenn |
|
Wenn |
[a] Für die Implementierung von Vergleichsausdrücken siehe die Klassen für spezielle Vergleiche (z.B. [b] |
Die 1.3 mit 1.6 definieren gemeinsame Operationen für die drei wichtigsten Typkategorien – Sequenz (positionell geordnet), Mapping (Zugriff über Schlüssel) und Zahl (alle numerischen Typen) – sowie die für veränderbare Typen in Python verfügbaren Operationen. Die meisten Typen exportieren außerdem zusätzliche typenspezifische Operationen (z.B. Klassen), wie im „Besondere integrierte Typen“, beschrieben.
Tabelle 1.3 Operationen für Sequenzen (Strings, Listen, Tupel, Bytes, Bytearray)
Operation |
Beschreibung |
Klassenmethode |
---|---|---|
|
Enthalten in |
|
|
Verkettung |
|
|
Wiederholung |
|
|
Indizierung nach Position |
|
|
Slicing: Elemente in |
|
|
Länge |
|
|
Minimum, Maximum der Elemente |
|
|
Iterator-Protokoll |
|
|
Iteration (alle Kontexte) |
|
[a] Siehe auch „Das Iterationsprotokoll“, für weitere Informationen zu diesen Methoden und ihrem Zusammenspiel. Wenn [b] In Python 2.X können Sie auch |
Tabelle 1.4 Operationen für veränderbare Sequenzen (Listen, Bytearray)
Operation |
Beschreibung |
Klassenmethode |
---|---|---|
|
Zuweisung am Index:
Ändert das Element am Index |
|
|
Slice-Zuweisung: |
|
|
Eintrag am Index löschen |
|
|
Slice löschen |
|
Tabelle 1.5 Operationen mit Mappings (Dictionaries)
Operation |
Beschreibung |
Klassenmethode |
---|---|---|
|
Indizierung über Schlüssel |
|
|
Zuweisung über Schlüssel: Eintrag für Schlüssel |
|
|
Eintrag über Schlüssel löschen |
|
|
Länge (Anzahl der Schlüssel) |
|
|
Prüft, ob Schlüssel enthalten ist.[a] |
Wie in Tabelle 1.3 |
|
Umkehrung von |
Wie inTabelle 1.3 |
|
Iteratorobjekt für die Schlüssel von |
Wie inTabelle 1.3 |
|
Iteration durch die Schlüssel in |
Wie inTabelle 1.3 |
[a] In Python 2.X kann das Vorhandensein von Schlüsseln auch mit |
Tabelle 1.6 Numerische Operationen (alle numerischen Typen)
Operation |
Beschreibung |
Klassenmethode |
---|---|---|
|
Addition, Subtraktion |
|
|
Multiplikation, Division, restlose Division, Rest |
|
|
Negativ, Identität |
|
|
Bitweises |
|
|
Bitweises Verschieben nach links bzw. rechts (Integer) |
|
|
Bitweises Invertieren (Integer) |
|
|
|
|
|
Betrag |
|
|
Konvertierung in Integer[b] |
|
|
Konvertierung in Float |
|
|
Erstellt einen komplexen Wert |
|
|
Tupel: |
|
|
X in die Y. Potenz erheben |
|
[a] Der Operator [b] In Python 2.X ruft die integrierte Funktion |
Beispiele und Hinweise zu ausgewählten Operationen für Sequenzen in Tabelle 1.3 und Tabelle 1.4:
Indizierung: S[i]
Ruft Komponenten an Positionen ab
(erstes Element befindet sich an Position 0
).
Negative Indices werden vom Ende rückwärts gezählt (das letzte Element befindet sich an Position −1
).
S
[0]
ruft das erste Element ab, S
[1]
das zweite Element.
S
[−2]
ruft das vorletzte Element ab (gleichbedeutend mit S
[len(
S
) − 2]
).
Slicing: S[i:j]
Extrahiert zusammenhängende
Abschnitte aus einer Sequenz, von i
bis einschließlich j
−1
.
Standardmäßig entsprechen die Slice-Grenzen i
und j
dem Wert 0
und der Länge der Sequenz len(
S
)
.
S
[1:3]
ruft den Bereich von 1
bis ausschließlich 3
ab.
S
[1:]
ruft den Bereich von 1
bis zum Ende (len(
S
)-1
) ab.
S
[:−1]
ruft den Bereich von 0
bis zum Ende ab, allerdings ausschließlich des letzten Elementes.
S
[:]
erzeugt eine flache Kopie der obersten Ebene des Sequenzobjekts S
.
Erweitertes Slicing: S[i:j:k]
Das dritte Element k
ist die Schrittweite (Standard 1
), die zur Position jedes extrahierten Elementes addiert wird.
S
[::2]
entspricht jedem zweiten Element der Sequenz S
.
S
[::−1]
liefert die Umkehrung der Sequenz S
.
S
[4:1:−1]
liefert die Elemente ab Position 4
bis Position 1
(nicht eingeschlossen) in umgekehrter Reihenfolge.
Slice-Zuweisung: S[i:j:k] = I
Die Slice-Zuweisung funktioniert ähnlich, wie wenn Sie Elemente löschen und anschließend im gelöschten Bereich einfügen.
Iterierbare Objekte, die einfachen Slices S
[
i
:
j
]
zugewiesen werden, müssen nicht die passende Länge haben.
Iterierbare Objekte, die erweiterten Slices S
[
i
:
j
:
k
]
zugewiesen werden, müssen eine entsprechende Länge haben.
Andere
Verkettung, Wiederholung und Slicing liefern neue Objekte zurück (bei Tupeln nicht immer ).