Python kurz & gut

Python kurz & gut

Mark Lutz

Stefan Fröhlich

Inhalt

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

Kapitel 1. Python – kurz & gut

Einführung

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.

Typografische Konventionen

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.

Anmerkung

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.

Verwendung der Python-Befehlszeile

Mit Befehlszeilen können Sie Python-Programme von einer System-Shell aus starten. Befehlszeilen haben das folgende Format:

python [optionen*]
  [ skriptdatei | -c befehl | -m modul | - ] [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).

Python-Optionen

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.

Angabe des Programms

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.

Befehlsoptionen in Python 2.X

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 in Python

Umgebungsvariablen (auch als Shell-Variablen bekannt), sind systemweite, programmübergreifende Einstellungen, die für die globale Konfiguration verwendet werden.

Operationale Variablen

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).

Befehlszeilen-Optionsvariablen

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.)

Verwendung des Python Launchers unter Windows

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.

Dateidirektiven des Launchers

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.

Launcher-Befehlszeilen

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:

−2          Neueste installierte 2.X-Version starten
-3          Neueste installierte 3.X-Version starten
-X.Y        Angegebene Version starten (X ist 2 oder 3)
-X.Y−32     Angegebene 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).

Launcher-Umgebungsvariablen

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.

Integrierte Typen und Operatoren

Operatoren und Vorrang

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.

Atomare Terme und Dynamische Typisierung

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

yield X

Generatorfunktionsergebnis (liefert send()-Wert)

lambda args1: X

Erzeugt eine anonyme Funktion (liefert beim Aufruf X zurück)

X if Y else Z

Ternäre Auswahl (X wird nur ausgewertet, wenn Y wahr ist)

X or Y

Logisches OR: Y wird nur ausgewertet, wenn X nicht wahr ist

X and Y

Logisches AND: Y wird nur ausgewertet, wenn X wahr ist

not X

Logische Negation

X in Y, X not in Y

Enthaltensein: iterierbare Objekte, Sets

X is Y, X is not Y

Objektidentität testen

X < Y, X <= Y, X > Y, X >= Y

Größenvergleich, Teilmengen und Obermengen von Sets

X == Y, X != Y

Gleichheitsoperatoren

X | Y

Bitweises OR, Vereinigungsmenge von Sets

X ^ Y

Bitweises exklusives OR, Symmetrische Differenz von Sets

X & Y

Bitweises AND, Schnittmenge von Sets

X << Y, X >> Y

Schiebt X um Y Bits nach links bzw. rechts

X + Y, X − Y

Addition/Verkettung, Subtraktion/Set-Differenz

X * Y, X % Y,

X / Y, X // Y

Multiplikation/Wiederholung, Rest/Formatieren, Division, restlose Division

-X, +X

Unäre Negation, Identität

˜X

Bitweises NOT-Komplement (Umkehrung)

X ** Y

Potenzierung

X[i]

Indizierung (Sequenzen, Mappings, andere)

X[i:j:k]

Slicing (alle drei Grenzen optional)

X(args2)

Aufruf (Funktion, Methode, Klasse und andere aufrufbare Objekte)

X.attr

Attributreferenz

(....)

Tupel, Ausdruck, Generatorausdruck

[....]

Liste, Listenkomprehension

{....}

Dictionary, Set, Dictionary- und Set-Komprehension

Hinweise zum Gebrauch von Operatoren

  • 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“.

Operationen nach Kategorien

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

X < Y

Streng kleiner als[a]

X <= Y

Kleiner oder gleich

X > Y

Streng größer als

X >= Y

Größer oder gleich

X == Y

Gleich (gleicher Wert)

X != Y

Ungleich (nur in Python 2.X gleichbedeutend mit X<>Y)[b]

X is Y

Objektgleichheit

X is not Y

Negierte Objektgleichheit

X < Y < Z

Verkettete Vergleiche

not X

Wenn X falsch ist, dann True; ansonsten False

X or Y

Wenn X falsch ist Y; ansonsten X

X and Y

Wenn X falsch ist X; ansonsten Y

[a] Für die Implementierung von Vergleichsausdrücken siehe die Klassen für spezielle Vergleiche (z.B. __lt__ für <) in 3.X und 2.X sowie die Methode __cmp__ in 2.X für allgemeine Vergleiche im „Methoden zur Operatorüberladung“.

[b] != und <> bedeuten in 2.X Wertungleichheit. Aber != ist in 2.X die bevorzugte und in 3.X die einzige zulässige Syntax. is führt eine Identitätsprüfung durch, == testet auf Wertgleicheit und ist deshalb in der Regel wesentlich nützlicher.

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

X in S

X not in S

Enthalten in

__contains__,

__iter__,

__getitem__[a]

S1 + S2

Verkettung

__add__

S * N, N * S

Wiederholung

__mul__

S[i]

Indizierung nach Position

__getitem__

S[i:j], S[i:j:k]

Slicing: Elemente in S ab Position i bis j−1 mit optionalen Schritten k

__getitem__[b]

len(S)

Länge

__len__

min(S), max(S)

Minimum, Maximum der Elemente

__iter__,

__getitem__

iter(S)

Iterator-Protokoll

__iter__

for X in S:,

[expr for X in S],

map(func, S) usw.

Iteration (alle Kontexte)

__iter__,

__getitem__

[a] Siehe auch „Das Iterationsprotokoll“, für weitere Informationen zu diesen Methoden und ihrem Zusammenspiel. Wenn __contains__ definiert ist, hat es Vorrang vor __iter__, und __iter__ hat Vorrang vor __getitem__.

[b] In Python 2.X können Sie auch __getslice__, __setslice__ und __delslice__ definieren, um Slicing-Operationen abzuwickeln. In 3.X wurden diese Methoden entfernt. Stattdessen sollen Slice-Objekte an ihre elementbasierten Indizierungsgegenstücke übergeben werden. Slice-Objekte können in Indexausdrücken anstatt der Grenzen i:j:k explizit angegeben werden.

Tabelle 1.4 Operationen für veränderbare Sequenzen (Listen, Bytearray)

Operation

Beschreibung

Klassenmethode

S[i] = X

Zuweisung am Index: Ändert das Element am Index i so, dass es auf X verweist.

__setitem__

S[i:j] = I,

S[i:j:k] = I

Slice-Zuweisung: S wird von i bis j−1 mit einer optionalen Schrittweite k (darf leer sein) durch alle Elemente der interierbaren Sequenz I ersetzt.

__setitem__

del S[i]

Eintrag am Index löschen

__delitem__

del S[i:j],

del S[i:j:k]

Slice löschen

__delitem__

Tabelle 1.5 Operationen mit Mappings (Dictionaries)

Operation

Beschreibung

Klassenmethode

D[k]

Indizierung über Schlüssel

__getitem__

D[k] = X

Zuweisung über Schlüssel: Eintrag für Schlüssel k erstellen oder so ändern, dass er auf X verweist.

__setitem__

del D[k]

Eintrag über Schlüssel löschen

__delitem__

len(D)

Länge (Anzahl der Schlüssel)

__len__

k in D

Prüft, ob Schlüssel enthalten ist.[a]

Wie in Tabelle 1.3

k not in D

Umkehrung von k in D

Wie inTabelle 1.3

iter(D)

Iteratorobjekt für die Schlüssel von D

Wie inTabelle 1.3

for k in D: usw.

Iteration durch die Schlüssel in D (alle Iterationskontexte)

Wie inTabelle 1.3

[a] In Python 2.X kann das Vorhandensein von Schlüsseln auch mit D.has_key(k)programmiert werden. In Python 3.X wurde diese Methode zu Gunsten des in-Ausdrucks entfernt, der auch in 2.X generell vorzuziehen ist. Siehe „Dictionaries“.

Tabelle 1.6 Numerische Operationen (alle numerischen Typen)

Operation

Beschreibung

Klassenmethode

X + Y, X − Y

Addition, Subtraktion

__add__, __sub__

X * Y, X / Y,

X // Y, X % Y

Multiplikation, Division, restlose Division, Rest

__mul__, __truediv__[a],

__floordiv__, __mod__

−X, +X

Negativ, Identität

__neg__, __pos__

X | Y, X & Y,

X ^ Y

Bitweises ODER, UND, exklusives ODER (Integer)

__or__, __and__, __xor__

X << N, X >> N

Bitweises Verschieben nach links bzw. rechts (Integer)

__lshift__, __rshift__

˜X

Bitweises Invertieren (Integer)

__invert__

X ** Y

X hoch Y

__pow__

abs(X)

Betrag

__abs__

int(X)

Konvertierung in Integer[b]

__int__

float(X)

Konvertierung in Float

__float__

complex(X), complex(re,im)

Erstellt einen komplexen Wert

__complex__

divmod(X, Y)

Tupel: (X / Y, X % Y)

__divmod__

pow(X, Y [,Z])

X in die Y. Potenz erheben

__pow__

[a] Der Operator / ruft in Python 3.X__truediv__ auf, in Python 2.X dagegen __div__, außer die echte Division ist aktiviert. Weitere Informationen zur Divisionssemantik finden Sie im „Hinweise zum Gebrauch von Operatoren“.

[b] In Python 2.X ruft die integrierte Funktion long() die Klassenmethode __long__ auf. In Python 3.X subsumiert der Typ int den Typ long, weshalb dieser entfernt wurde.

Hinweise zu Operationen für Sequenzen

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 ).