Das Python-Tutorial¶

Aufrufen des Interpreters¶

Sofern der Python-Interpreter auf einem Rechner installiert ist, findet man ihn normalerweise unter /usr/local/bin/python/python3.3. Wenn man /usr/local/bin in den Suchpfad der Unix-Shell setzt, kann man den Interpreter aufrufen durch [1]:

python3.3

Die Auswahl des Installationspfades für den Interpreter ist eine Installationsoption, so dass auch eine Installation an anderer Stelle möglich ist. Das ist mit dem örtlichen Python-Guru oder dem Systemadministrator zu klären. (Eine populäre Alternative ist etwa /usr/local/python)

Auf Windows-Rechnern befindet sich die Pythoninstallation meist unter C:\Python33, auch wenn man das während des Installationsvorgangs ändern kann. Um dieses Verzeichnis zum Suchpfad hinzuzufügen, kann man folgendes Kommando in die DOS-Eingabeaufforderung eingeben:

set path=%path%;C:\python33

Durch Eingabe eines End-Of-File-Zeichens (EOF; Strg-D unter Unix, Strg-Z unter Windows) in der Eingabeaufforderung des Interpreters wird der Interpreter mit dem Rückgabewert Null beendet. Falls er das nicht tut, kann man den Interpreter durch folgende Befehlszeile beenden: quit().

Die Möglichkeiten des Interpreters hinsichtlich des Editierens der Eingabe sind ziemlich beschränkt, lassen sich aber durch Einsatz der GNU-readline-Bibliothek erweitern. Ob diese erweiterten Möglichkeiten verfügbar sind, lässt sich überprüfen, indem man ein Strg-P in die Eingabeaufforderung tippt. Wenn es piepst, ist die “readline”-Unterstützung vorhanden. In diesem Fall findet man im Anhang Interaktive Eingabe-Bearbeitung und Ersetzung des Verlaufs eine Einführung zu den einzelnen Tasten. Falls kein Piepton zu hören ist oder ^P erscheint, ist keine “readline”-Unterstützung vorhanden und die einzige Möglichkeit zum Editieren ist die Verwendung der Rücktaste (Backspace), um Zeichen in der aktuellen Eingabezeile zu entfernen.

Grundsätzlich ist der Interpreter ähnlich zu bedienen wie eine Unix-Shell: Wird er mit einem tty-Gerät als Standardeingabe aufgerufen, liest und führt er interaktiv Befehle aus. Wird er mit einem Dateinamen als Argument oder mit einer Datei als Standardeingabe aufgerufen, liest und führt es ein Skript von dieser Datei aus.

Eine zweite Möglichkeit zum Starten des Python-Interpreters ist python -c Befehl [arg] ..., wodurch die Anweisung(en) in diesem Befehl ausgeführt werden, analog zur -c-Option der Shell. Da Python-Anweisungen oft Leerzeichen oder sonstige Zeichen enthält, die von der Shell besonders behandelt werden, sollte man den kompletten Befehl in einfache Anführungszeichen setzen.

Einige Python-Module sind auch als Skripte nützlich und können mit python -m Modul [arg] ... aufgerufen werden. Dadurch wird der Quelltext von Modul ausgeführt, so als hätte man den vollständigen Namen in die Kommandozeile eingegeben.

Achtung: Es gibt einen Unterschied zwischen python Datei und python < Datei! Im zweiten Fall werden Eingabeanfragen des Programms, wie beispielsweise der Aufruf sys.stdin.read(), von Datei erledigt. Da diese Datei aber schon vom Parser bis zum Ende gelesen wurde, bevor mit der Ausführung begonnen wird, trifft das Programm sofort auf ein End-Of-File. In ersterem Fall passiert das, was man normalerweise erwartet: Die Eingabeanfragen werden durch diejenige Datei oder das Gerät erledigt, die bzw. das als Standardeingabe zur Verfügung steht.

Wenn eine Skriptdatei verwendet wird, ist es oft hilfreich, das Skript auszuführen und danach in den interaktiven Modus zu wechseln. Dies erreicht man durch die Option -i vor dem Skript.

$ python3.3
Python 3.3 (py3k, Apr 1 2010, 13:37:42)
[GCC 4.4.1] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>>

>>> the_world_is_flat = True
>>> if the_world_is_flat:
...     print("Be careful not to fall off!")
...
Be careful not to fall off!

Der Interpreter und seine Umgebung¶

#!/usr/bin/env python3.3

$ chmod +x myscript.py

# -*- coding: Kodierung -*-

# -*- coding: cp-1252 -*-

import os
filename = os.environ.get('PYTHONSTARTUP')
if filename and os.path.isfile(filename):
    exec(open(filename).read())

>>> import site
>>> site.getusersitepackages()
'/home/user/.local/lib/python3.2/site-packages'

Benutzung von Python als Taschenrechner¶

Wir wollen ein paar einfache Python-Befehle ausprobieren: Starte den Interpreter und warte auf die primäre Eingabeaufforderung, >>>.

>>> 2 + 2
4
>>> # Dies ist ein Kommentar
... 2 + 2
4
>>> 2 + 2  # und dies ist ein Kommentar in derselben Zeile wie Code
4
>>> (50 - 5 * 6) / 4
5.0
>>> 8 / 5 # Brüche gehen nicht verloren, wenn man Ganzzahlen teilt
1.6

>>> # Ganzzahldivision gibt ein abgerundetes Ergebnis zurück:
... 7 // 3
2
>>> 7 // -3
-3

>>> width = 20
>>> height = 5 * 9
>>> width * height
900

>>> x = y = z = 0  # Null für x, y und z
>>> x
0
>>> y
0
>>> z
0

>>> # Versuche eine undefinierte Variable abzurufen
... n
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
NameError: name 'n' is not defined

>>> 3 * 3.75 / 1.5
7.5
>>> 7.0 / 2
3.5

>>> 1j * 1J
(-1+0j)
>>> 1j * complex(0, 1)
(-1+0j)
>>> 3 + 1j * 3
(3+3j)
>>> (3 + 1j) * 3
(9+3j)
>>> (1 + 2j) / (1 + 1j)
(1.5+0.5j)

>>> a = 1.5 + 0.5j
>>> a.real
1.5
>>> a.imag
0.5

>>> a = 3.0 + 4.0j
>>> float(a)
Traceback (most recent call last):
 File "<stdin>", line 1, in ?
TypeError: can't convert complex to float; use abs(z)
>>> a.real
3.0
>>> a.imag
4.0
>>> abs(a)  # sqrt(a.real**2 + a.imag**2)
5.0
>>>

>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
12.5625
>>> price + _
113.0625
>>> round(_, 2)
113.06
>>>

>>> 'spam eggs'
'spam eggs'
>>> 'doesn\'t'
"doesn't"
>>> "doesn't"
"doesn't"
>>> '"Ja,", hat er gesagt.'
'"Ja,", hat er gesagt.'
>>> "\"Ja,\", hat er gesagt."
'"Ja,", hat er gesagt.'
>>> '"Isses nich\',", sagte sie.'
'"Isses nich\',", sagte sie.

hello = "Dies ist eine ziemlich lange Zeichenkette,\n\
die mehrere Zeilen Text enthält und wie man sie auch in C schreiben würde.\n\
    Achtung: Leerzeichen am Anfang haben eine Bedeutung\
für die Darstellung."

print(hello)

Dies ist eine ziemlich lange Zeichenkette,
die mehrere Zeilen Text enthält und wie man sie auch in C schreiben würde.
    Achtung: Leerzeichen am Anfang haben eine Bedeutung für die Darstellung.

print("""\
Usage: thingy [OPTIONS]
     -h                        Display this usage message
     -H hostname               Hostname to connect to
""")

Usage: thingy [OPTIONS]
     -h                        Display this usage message
     -H hostname               Hostname to connect to

hello = r"Dies ist eine ziemlich lange Zeichenkette,\n\
die mehrere Zeilen Text enthält und wie man sie auch in C schreiben würde."

print(hello)

Dies ist eine ziemlich lange Zeichenkette,\n\
die mehrere Zeilen Text enthält und wie man sie auch in C schreiben würde.

>>> word = 'Help' + 'A'
>>> word
'HelpA'
>>> '<' + word*5 + '>'
'<HelpAHelpAHelpAHelpAHelpA>'

>>> 'str' 'ing'             #Das ist ok
'string'
>>> 'str'.strip() + 'ing'   #Das ist ok
'string'
>>> 'str'.strip() 'ing'     #Das ist ungültig
 File "<stdin>", line 1, in ?
   'str'.strip() 'ing'
                     ^
SyntaxError: invalid syntax

>>> word[4]
'A'
>>> word[0:2]
'He'
>>> word[2:4]
'lp'

>>> word[:2]    # Die ersten beiden Zeichen
'He'
>>> word[2:]    # Alles außer den ersten beiden Zeichen
'lpA'

>>> word[0] = 'x'
Traceback (most recent call last):
 File "<stdin>", line 1, in ?
TypeError: 'str' object does not support item assignment
>>> word[:1] = 'Splat'
Traceback (most recent call last):
 File "<stdin>", line 1, in ?
TypeError: 'str' object does not support slice assignment

>>> 'x' + word[1:]
'xelpA'
>>> 'Splat' + word[4]
'SplatA'

>>> word[:2] + word[2:]
'HelpA'
>>> word[:3] + word[3:]
'HelpA'

>>> word[1:100]
'elpA'
>>> word[10:]
''
>>> word[2:1]
''

>>> word[-1]     # Das letzte Zeichen
'A'
>>> word[-2]     # Das vorletzte Zeichen
'p'
>>> word[-2:]    # Die letzten zwei Zeichen
'pA'
>>> word[:-2]    # Alles außer den letzten beiden Zeichen
'Hel'

>>> word[-0]     # (da -0 gleich 0)
'H'

>>> word[-100:]
'HelpA'
>>> word[-10]    # Fehler
Traceback (most recent call last):
 File "<stdin>", line 1, in ?
IndexError: string index out of range

 +---+---+---+---+---+
 | H | e | l | p | A |
 +---+---+---+---+---+
 0   1   2   3   4   5
-5  -4  -3  -2  -1

>>> s = 'supercalifragilisticexpialidocious'
>>> len(s)
34

>>> 'Hello\u0020World !'
'Hello World !'

>>> "Äpfel".encode('utf-8')
b'\xc3\x84pfel'

>>> a = ['spam', 'eggs', 100, 1234]
>>> a
['spam', 'eggs', 100, 1234]

>>> a[0]
'spam'
>>> a[3]
1234
>>> a[-2]
100
>>> a[1:-1]
['eggs', 100]
>>> a[:2] + ['bacon', 2*2]
['spam', 'eggs', 'bacon', 4]
>>> 3*a[:3] + ['Boo!']
['spam', 'eggs', 100, 'spam', 'eggs', 100, 'spam', 'eggs', 100, 'Boo!']

>>> a[:]
['spam', 'eggs', 100, 1234]

>>> a
['spam', 'eggs', 100, 1234]
>>> a[2] = a[2] + 23
>>> a
['spam', 'eggs', 123, 1234]

>>> # Ein paar Elemente ersetzen:
... a[0:2] = [1, 12]
>>> a
[1, 12, 123, 1234]
>>> # Ein paar entfernen:
... a[0:2] = []
>>> a
[123, 1234]
>>> # Ein paar einfügen:
... a[1:1] = ['bletch', 'xyzzy']
>>> a
[123, 'bletch', 'xyzzy', 1234]
>>> # (Eine Kopie von) sich selbst am Anfang einfügen:
>>> a[:0] = a
>>> a
[123, 'bletch', 'xyzzy', 1234, 123, 'bletch', 'xyzzy', 1234]
>>> # Die Liste leeren: Alle Elemente durch eine leere Liste  ersetzen
>>> a[:] = []
>>> a
[]

>>> a = ['a', 'b', 'c', 'd']
>>> len(a)
4

>>> q = [2, 3]
>>> p = [1, q, 4]
>>> len(p)
3
>>> p[1]
[2, 3]
>>> p[1][0]
2

>>> p[1].append('xtra')
>>> p
[1, [2, 3, 'xtra'], 4]
>>> q
[2, 3, 'xtra']

Erste Schritte zur Programmierung¶

Natürlich kann man Python für kompliziertere Aufgaben verwenden, als nur zwei und zwei zu addieren. Beispielsweise lassen sich die ersten Glieder der Fibonacci-Folge folgendermaßen erzeugen:

>>> # Fibonacci-Folge:
... # Die Summe der letzten beiden Elemente ergibt das nächste
... a, b = 0, 1
>>> while b < 10:
...     print(b)
...     a, b = b, a+b
...
1
1
2
3
5
8

Dieses Beispiel stellt ein paar neue Eigenschaften vor.

• Die erste Zeile enthält eine Mehrfachzuweisung (multiple assignment): Die Variablen a und b bekommen gleichzeitig die neuen Werte 0 und 1. In der letzten Zeile wird sie erneut eingesetzt, um zu zeigen, dass zuerst alle Ausdrücke auf der rechten Seite ausgewertet werden, bevor irgendeine Zuweisung vorgenommen wird! Die Ausdrücke auf der rechten Seite werden von links nach rechts ausgewertet.

• Die while Schleife wird solange ausgeführt, wie die Bedingung (hier: b < 10) wahr ist. In Python wie in C ist jede von Null verschiedene Zahl wahr (True), Null ist unwahr (False). Die Bedingung kann auch ein String- oder Listenwert sein, eigentlich sogar jede Sequenz. Alles mit einer von Null verschiedenen Länge ist wahr, leere Sequenzen sind unwahr. Die Bedingung im Beispiel ist ein einfacher Vergleich. Die normalen Vergleichsoperatoren werden wie in C geschrieben: < (kleiner als), > (größer als), == (gleich), <= (kleiner oder gleich), >= (größer oder gleich) und != (ungleich).

• Der Schleifenrumpf ist eingerückt (indented): Durch Einrückung wird in Python eine Gruppierung vorgenommen. In der interaktiven Eingabeaufforderung muss man Tabs oder Leerzeichen für jede eingerückte Zeile eingeben. In der Praxis wird man kompliziertere Codestücke mit einem Texteditor vorbereiten und alle vernünftigen Editoren haben eine Möglichkeit, um automatisch einzurücken. Wenn eine zusammengesetzte Anweisung (compound statement) interaktiv eingegeben wird, muss eine Leerzeile darauf folgen, um anzuzeigen, dass sie komplett ist, da der Parser nicht erahnen kann, wenn man die letzte Zeile eingegeben hat. Beachte, dass jede Zeile in einem zusammengehörigen Block gleich eingerückt sein muss.

• Die Funktion print() gibt den Wert des Ausdrucks aus, der ihr übergeben wurde. Die Ausgabe unterscheidet sich bei Mehrfachausdrücken, Fließkommazahlen und Zeichenketten von der Ausgabe, die man erhält, wenn man die Ausdrücke einfach so eingibt (wie wir es vorher in den Taschenrechnerbeispielen gemacht haben). Zeichenketten werden ohne Anführungszeichen ausgegeben, und bei Angabe mehrere Argumente wird zwischen je zwei Argumenten ein Leerzeichen eingefügt. So lassen sich einfache Formatierungen vornehmen, wie das Beispiel zeigt

  >>> i = 256 * 256
  >>> print('Der Wert von i ist', i)
  Der Wert von i ist 65536
  

Durch Verwendung des Schlüsselwortarguments end kann der Zeilenumbruch nach der Ausgabe verhindert oder die Ausgabe mit einem anderen String beendet werden.

>>> a, b = 0, 1
>>> while b < 1000:
...     print(b, end=' ')
...     a, b = b, a+b
...
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987

if-Anweisungen¶

Ein Beispiel zur if-Anweisung

>>> x = int(input("Please enter an integer: "))
Please enter an integer: 42
>>> if x < 0:
...      x = 0
...      print('Negative changed to zero')
... elif x == 0:
...      print('Zero')
... elif x == 1:
...      print('Single')
... else:
...      print('More')
...
More

else-Zweig oder elif-Zweige sind optional. Im Unterschied zum else-Zweig, der nur einmal vorkommen kann, ist eine Abfolge von mehreren elif-Zweigen möglich; dadurch lassen sich verschachtelte Einrückungen vermeiden. Eine Abfolge von if ... elif ... elif-Zweigen ersetzt die switch- oder case-Konstrukte anderer Programmiersprachen.

for-Anweisungen¶

Die for-Anweisung in Python unterscheidet sich ein wenig von der, die man von C oder Pascal her kennt. Man kann nicht nur über eine Zahlenfolge iterieren (wie in Pascal) oder lediglich Schrittweite und Abbruchbedingung festlegen (wie in C), sondern über eine beliebige Sequenz (also z. B. eine Liste oder Zeichenkette), und zwar in der Reihenfolge, in der die Elemente in der Sequenz vorkommen. Zum Beispiel:

>>> # Die Längen einiger Zeichenketten ermitteln:
... a = ['Katze', 'Fenster', 'rauswerfen']
>>> for x in a:
...     print(x, len(x))
...
Katze 5
Fenster 7
rauswerfen 10

Vorsicht ist geboten, wenn man versucht, Veränderungen an einer Sequenz vorzunehmen, über die gerade iteriert wird (was natürlich nur bei veränderbaren Sequenztypen, wie etwa Listen, passieren kann). Will man eine Liste verändern, über die man iteriert, um beispielsweise ausgewählte Elemente zu duplizieren, muss man über eine Kopie iterieren. Die Slice-Notation macht dies sehr einfach:

>>> for x in a[:]: # benutze eine Kopie der gesamten Liste
...    if len(x) > 7: a.insert(0, x)
...
>>> a
['rauswerfen', 'Katze', 'Fenster', 'rauswerfen']

Die Funktion range()¶

Wenn man wirklich über eine Zahlenfolge iterieren muss, bietet sich die eingebaute Funktion range() an, die arithmetische Folgen erzeugt.

>>> for i in range(5):
...     print(i)
...
0
1
2
3
4

Wird nur ein Argument angegeben, so beginnt der erzeugte Bereich bei Null und endet mit dem um 1 kleineren Wert des angegebenen Arguments. range(10) erzeugt die Zahlen von 0 bis einschließlich 9. Das entspricht den gültigen Indizes einer Sequenz mit zehn Elementen. Es ist ebenfalls möglich, den Bereich mit einem anderen Wert als Null zu beginnen oder auch eine bestimmte Schrittweite (step) festzulegen — sogar negative Schrittweiten sind möglich.

range(5, 10)
   5 bis 9

range(0, 10, 3)
   0, 3, 6, 9

range(-10, -100, -30)
  -10, -40, -70

Will man über die Indizes einer Sequenz iterieren, kann man range() und len() wie folgt kombinieren:

>>> a = ['Mary', 'hatte', 'ein', 'kleines', 'Lamm']
>>> for i in range(len(a)):
...     print(i, a[i])
...
0 Mary
1 hatte
2 ein
3 kleines
4 Lamm

Eleganter ist es jedoch, in solchen Fällen die Funktion enumerate() zu benutzen, siehe Schleifentechniken.

Etwas Seltsames passiert, wenn man einfach ein range-Objekt ausgeben will:

>>> print(range(10))
range(0, 10)

Zwar verhält sich das von range() zurückgegebene Objekt in etwa wie eine Liste, es ist jedoch in Wahrheit keine Liste. range() liefert ein Objekt zurück, das der Reihe nach die einzelnen Zahlen der Folge zurückliefert, die durch die an range() übergebenen Argumente festgelegt wurde. Dadurch lässt sich gegenüber der Erzeugung einer Liste Speicherplatz sparen.

Wir nennen solch ein Objekt Iterable, und es kann überall da eingesetzt werden, wo ein Objekt erwartet wird, das eine Folge von Elementen der Reihe nach “produziert”, bis sein Vorrat erschöpft ist. Beispielsweise fungiert die for-Anweisung als ein solcher Iterator. Auch die Funktion list() ist ein solcher Iterator, die als Argument ein Iterable erwartet und eine Liste daraus macht

>>> list(range(5))
[0, 1, 2, 3, 4]

Später werden noch weitere Funktionen behandelt, die Iterables zurückgeben und Iterables als Argument aufnehmen.

break- und continue-Anweisungen und der else-Zweig bei Schleifen¶

Eine break-Anweisung in einem Schleifenrumpf bewirkt — wie in C — dass an dieser Stelle mit sofortiger Wirkung die sie unmittelbar umgebende Schleife verlassen wird.

Auch Schleifen-Anweisungen können einen else-Zweig haben. Dieser wird genau dann ausgeführt, wenn die Schleife nicht durch eine break-Anweisung abgebrochen wurde. Das folgende Beispiel zur Berechnung von Primzahlen veranschaulicht das.

>>> for n in range(2, 10):
...     for x in range(2, n):
...         if n % x == 0:
...             print(n, 'equals', x, '*', n//x)
...             break
...     else:
...         # Schleife wurde durchlaufen, ohne dass ein Faktor gefunden wurde
...         print(n, 'is a prime number')
...
2 is a prime number
3 is a prime number
4 equals 2 * 2
5 is a prime number
6 equals 2 * 3
7 is a prime number
8 equals 2 * 4
9 equals 3 * 3

(Ja, dieser Code ist korrekt. Schau genau hin: Die else Klausel gehört zur for-Schleife, nicht zur if-Anweisung.)

Wenn die else Klausel bei einer Schleife benutzt wird, hat sie mehr mit dem else einer try Anweisung gemein, als mit dem der if Anweisung: Die else Klausel eines try wird ausgeführt, wenn keine Ausnahme auftritt und die einer Schleife, wenn kein break ausgeführt wird. Mehr Informationen zur try Anweisung und Ausnahmen gibt es unter Ausnahmen behandeln.

Entsprechend bewirkt die continue-Anweisung — ebenso von C entliehen — , dass sofort mit der nächsten Iteration der Schleife fortgefahren wird:

>>> for num in range(2, 10):
...     if num % 2 == 0:
...         print("Found an even number", num)
...         continue
...     print("Found a number", num)
Found an even number 2
Found a number 3
Found an even number 4
Found a number 5
Found an even number 6
Found a number 7
Found an even number 8
Found a number 9

pass-Anweisungen¶

Die pass-Anweisung tut nichts. Sie wird eingesetzt, wenn syntaktisch eine Anweisung benötigt wird, das Programm jedoch nichts tun soll. Ein Beispiel:

>>> while True:
...     pass  # geschäftiges Warten auf den Tastatur-Interrupt (Strg+C)
...

Auch bei der Erzeugung einer minimalen Klasse kann pass zum Einsatz kommen:

>>> class MyEmptyClass:
...     pass
...

pass lässt sich auch sinnvoll einsetzen als Platzhalter für den Rumpf einer Funktionen oder Schleife bei der “Top-Down”-Programmierung, um so zunächst auf einer abstrakteren Ebene zu denken

>>> def initlog(*args):
...     pass   # Implementieren nicht vergessen!
...

Funktionen definieren¶

Im folgenden Beispiel wird eine Funktion definiert, die die Fibonacci-Folge bis zu einer beliebigen Grenze ausgibt:

>>> def fib(n):    # die Fibonacci-Folge bis n ausgeben
...     """Print the Fibonacci series up to n."""
...     a, b = 0, 1
...     while a < n:
...         print(a, end=' ')
...         a, b = b, a+b
...     print()
...
>>> # Jetzt rufen wir die Funktion auf, die wir gerade definiert haben:
... fib(2000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597

Das Schlüsselwort def leitet die Definition einer Funktion ein. Darauf folgt der Funktionsname und eine Auflistung der formalen Parameter, die allerdings auch leer sein kann. Die Anweisungen, die den Funktionskörper bilden, beginnen in der nächsten Zeile und müssen eingerückt sein.

Die erste Anweisung des Funktionskörpers kann auch ein Zeichenkettenliteral sein, ein so genannter Dokumentationsstring der Funktion, auch Docstring genannt. (Mehr zu Docstrings kann im Abschnitt Dokumentationsstrings nachgelesen werden.) Es gibt Werkzeuge, die Docstrings verwenden, um automatisch Online-Dokumentation oder gedruckte Dokumentation zu erzeugen oder es dem Anwender ermöglichen, interaktiv den Code zu durchsuchen. Die Verwendung von Docstrings ist eine gute Konvention, an die man sich bei der Programmierung nach Möglichkeit halten sollte.

Beim Aufruf einer Funktion kommt es zur Bildung eines lokalen Namensraums, der sich auf alle Bezeichner erstreckt, die im Funktionsrumpf (durch Zuweisung oder als Elemente der Parameterliste) neu definiert werden. Diese Bezeichner werden mit den ihnen zugeordneten Objekten in einer lokalen Symboltabelle abgelegt.

Wenn im Funktionsrumpf ein Bezeichner vorkommt, wird der Name zunächst in der lokalen Symboltabelle gesucht, danach in den lokalen Symboltabellen der umgebenden Funktionen, dann in der globalen Symboltabelle und schließlich in der Symboltabelle der eingebauten Namen. Darum ist es ohne weiteres nicht möglich, einer globalen Variablen innerhalb des lokalen Namensraums einer Funktion einen Wert zuzuweisen. Dadurch würde stattdessen eine neue, namensgleiche lokale Variable definiert, die die namensgleiche globale Variable überdeckt und dadurch auch den lesenden Zugriff auf diese globale Variable verhindert. Ein lesender Zugriff auf globale Variablen ist ansonsten immer möglich, ein schreibender Zugriff nur unter Verwendung der global-Anweisung.

Die konkreten Parameter (Argumente), die beim Funktionsaufruf übergeben werden, werden den formalen Parametern der Parameterliste zugeordnet und gehören damit zur lokalen Symboltabelle der Funktion. Das heißt, Argumente werden über call by value übergeben (wobei der Wert allerdings immer eine Referenz auf ein Objekt ist, nicht der Wert des Objektes selbst) [1]. Wenn eine Funktion eine andere Funktion aufruft, wird eine neue lokale Symboltabelle für diesen Aufruf erzeugt.

Eine Funktionsdefinition fügt den Funktionsnamen in die lokale Symboltabelle ein. Der Wert des Funktionsnamens hat einen Typ, der vom Interpreter als benutzerdefinierte Funktion erkannt wird. Dieser Wert kann einem anderen Namen zugewiesen werden, der dann ebenfalls als Funktion genutzt werden kann und so als Möglichkeit zur Umbenennung dient.

>>> fib
<function fib at 10042ed0>
>>> f = fib
>>> f(100)
0 1 1 2 3 5 8 13 21 34 55 89

Wer Erfahrung mit anderen Programmiersprachen hat, wird vielleicht einwenden, dass fib gar keine Funktion, sondern eine Prozedur ist, da sie keinen Wert zurückgibt. Tatsächlich geben aber auch Funktionen ohne eine return-Anweisung einen Wert zurück, wenn auch einen eher langweiligen, nämlich den eingebauten Namen None (“nichts”). Die Ausgabe des Wertes None wird normalerweise vom Interpreter unterdrückt, wenn es der einzige Wert wäre, der ausgegeben wird. Möchte man ihn sehen, kann man ihn mittels print() sichtbar machen.:

>>> fib(0)
>>> print(fib(0))
None

Statt eine Abfolge von Zahlen in einer Funktion auszugeben, kann man auch eine Liste dieser Zahlen als Objekt zurückliefern.

>>> def fib2(n): # gibt die Fibonacci-Folge bis  n zurück
...     """Return a list containing the Fibonacci series up to n."""
...     result = list()
...     a, b = 0, 1
...     while a < n:
...         result.append(a)    # siehe unten
...         a, b = b, a + b
...     return result
...
>>> f100 = fib2(100)    # ruf es auf
>>> f100                # gib das Ergebnis aus
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

Dieses Beispiel zeigt einige neue Eigenschaften von Python:

• Die return-Anweisung gibt einen Wert von einer Funktion zurück. Ohne einen Ausdruck als Argument gibt return None zurück; das gleiche gilt, wenn eine return-Anweisung fehlt.
• Die Anweisung result.append(a) ruft eine Methode des Listenobjektes in result auf. Eine Methode ist eine Funktion, die zu einem Objekt ‘gehört’ und wird mittels Punktnotation (obj.methodname) dargestellt. Dabei ist obj irgendein Objekt (es kann auch ein Ausdruck sein) und methodname der Name einer Methode, die vom Typ des Objektes definiert wird. Unterschiedliche Typen definieren verschiedene Methoden. Methoden verschiedener Typen können denselben Namen haben ohne doppeldeutig zu sein. (Es ist auch möglich, eigene Objekttypen zu erstellen, indem man Klassen benutzt, siehe Klassen.) Die Methode append(), die im Beispiel gezeigt wird, ist für Listenobjekte definiert. Sie hängt ein neues Element an das Ende der Liste an. Im Beispiel ist es äquivalent zu result = result + [a], aber effizienter.

Mehr zum Definieren von Funktion¶

Funktionen lassen sich auch mit einer variablen Anzahl von Argumenten definieren. Dabei sind drei Varianten zu unterscheiden, die auch kombiniert werden können.

def ask_ok(prompt, retries=4, complaint='Bitte Ja oder Nein!'):
   while True:
       ok = input(prompt)
       if ok in ('j', 'J', 'ja', 'Ja'): return True
       if ok in ('n', 'N', 'ne', 'Ne', 'Nein'): return False
       retries = retries - 1
       if retries < 0:
           raise IOError('Benutzer abgelehnt!')
       print(complaint)

i = 5

def f(arg=i):
   print(arg)

i = 6
f()

def f(a, L=[]):
   L.append(a)
   return L

print(f(1))
print(f(2))
print(f(3))

[1]
[1, 2]
[1, 2, 3]

def f(a, L=None):
    if L is None:
        L = []
    L.append(a)
    return L

def parrot(voltage, state='völlig steif', action='fliegen', type='norwegische Blauling'):
    print("-- Der Vogel würde selbst dann nicht", action, end=' ')
    print("selbst wenn Sie ihm ", voltage, "Volt durch den Schnabel jagen täten")
    print("-- Ganz erstaunlicher Vogel, der", type, "! Wunderhübsche Federn!")
    print("-- Er is", state, "!")

parrot(4000)
parrot(action = 'VOOOOOM', voltage = 1000000)
parrot('Viertausend', state = 'an den Gänseblümchen riechen')
parrot('eine Million', 'keine Spur leben', 'springen')

parrot()                     # das benötigte Argument fehlt
parrot(voltage=5.0, 'tot')   # auf ein Schlüsselwortargument folgt ein normales
parrot(110, voltage=220)     # doppelter Wert für ein Argument
parrot(actor='John Cleese')  # unbekanntes Schlüsselwort

>>> def function(a):
...     pass
...
>>> function(0, a=0)
Traceback (most recent call last):
 File "<stdin>", line 1, in ?
TypeError: function() got multiple values for keyword argument 'a'

def cheeseshop(kind, *arguments, **keywords):
    print("-- Haben sie", kind, "?")
    print("-- Tut mir leid,", kind, "ist leider gerade aus.")
    for arg in arguments:
        print(arg)
    print("-" * 40)
    keys = sorted(keywords.keys())
    for kw in keys:
        print(kw, ":", keywords[kw])

cheeseshop("Limburger", "Der ist sehr flüssig, mein Herr.",
          "Der ist wirklich sehr, SEHR flüssig, mein Herr.",
          shopkeeper="Michael Palin",
          client="John Cleese",
          sketch="Cheese Shop Sketch")

-- Haben sie Limburger ?
-- Tut mir leid, Limburger ist leider gerade aus.
Der ist sehr flüssig, mein Herr.
Der ist wirklich sehr, SEHR flüssig, mein Herr.
----------------------------------------
client : John Cleese
shopkeeper : Michael Palin
sketch : Cheese Shop Sketch

def write_multiple_items(file, separator, *args):
    file.write(separator.join(args))

>>> def concat(*args, sep="/"):
...    return sep.join(args)
...
>>> concat("Erde", "Mars", "Venus")
'Erde/Mars/Venus'
>>> concat("Erde", "Mars", "Venus", sep=".")
'Erde.Mars.Venus'

>>> list(range(3, 6))   # normaler Aufruf mit getrennten Argumenten
[3, 4, 5]
>>> args = [3, 6]
>>> list(range(*args))  # Aufruf mit Argumenten, die aus einer Liste ausgepackt werden
[3, 4, 5]

>>> def parrot(voltage, state=' völlig steif',
...    action='fliegen', type='norwegische Blauling'):
...    print("-- Der Vogel würde selbst dann nicht", action, end=' ')
...    print("selbst wenn Sie ihm ", voltage, "Volt durch den Schnabel jagen täten.")
...    print("-- Er is", state, "!")

>>> d = {"voltage": "vier Millionen", "state": "verdammt nochmal tot!", "action": "FLIEGEN"}
>>> parrot(**d)
-- Der Vogel würde selbst dann nicht FLIEGEN selbst wenn sie ihm vier Millionen Volt durch den Schnabel jagen täten.
-- Er is verdammt nochmal tot!

>>> def make_incrementor(n):
...     return lambda x: x + n
...
>>> f = make_incrementor(42)
>>> f(0)
42
>>> f(1)
43

>>> def my_function():
...     """Do nothing, but document it.
...
...     No, really, it doesn't do anything.
...     """
...     pass
...
>>> print(my_function.__doc__)
Do nothing, but document it.

   No, really, it doesn't do anything.

Intermezzo: Schreibstil¶

Jetzt da Du längere, komplexere Stücke in Python schreibst, ist es an der Zeit einmal über den Schreibstil (coding style) zu sprechen. Viele Sprachen können in verschiedenen Stilen geschrieben (präziser: formatiert) werden; davon sind manche lesbarer als andere. Es anderen leichter zu machen Deinen Code zu lesen ist immer eine gute Idee und sich einen schönen Schreibstil anzugewöhnen hilft dabei ungemein.

Für Python hat sich PEP 8 als der Styleguide herauskristallisiert, dem die meisten Projekte folgen. Es fördert einen sehr lesbaren Schreibstil, der angenehm zu lesen ist. Jeder Pythonentwickler sollte ihn irgendwann einmal lesen, hier jedoch die wichtigsten Punkte:

• Benutze eine Einrückung von 4 Leerzeichen, keine Tabs.

  4 Leerzeichen sind ein guter Kompromiss zwischen geringer Einrückung, die eine größere Verschachtelungstiefe ermöglicht, und größerer Einrückung, die den Code leichter lesbar macht. Tabs führen zu Unordnung und sollten deshalb vermieden werden.

• Breche Zeilen so um, dass sie nicht über 79 Zeichen hinausgehen.

  Das ist hilfreich für Benutzer mit kleinen Bildschirmen und macht es auf größeren möglich mehrere Dateien nebeneinander zu betrachten.

• Benutze Leerzeilen, um Funktion und Klassen, sowie größere Codeblöcke innerhalb von Funktionen zu trennen.

• Verwende eine eigene Zeile für Kommentare, sofern das möglich ist.

• Schreibe Docstrings.

• Benutze Leerzeichen um Operatoren herum und nach Kommas, jedoch nicht direkt innerhalb von Klammerkonstrukten: a = f(1, 2) + g(3, 4).

• Benenne Deine Klassen und Funktionen konsistent: Die Konvention schlägt CamelCase für Klassen und klein_geschrieben_mit_unterstrichen für Funktionen und Methoden vor. Benutze immer self als Namen für das erste Methoden Argument (mehr zu Klassen und Methoden, siehe Eine erste Betrachtung von Klassen).

• Benutze keine ausgefallenen Dateikodierungen, wenn Dein Code für ein internationales Publikum vorgesehen ist. Pythons Standardkodierung – UTF-8 – oder sogar einfaches ASCII ist in jedem Fall am Besten.

• Benutze auch keine nicht-ASCII-Zeichen in Bezeichnern, wenn es auch nur den Hauch einer Chance gibt, dass der Code von Menschen gelesen oder gewartet wird, die eine andere Sprache sprechen.

Fußnoten

Mehr zu Listen¶

Der Datentyp list hat noch ein paar andere Methoden. Hier sind alle Methoden von Listenobjekten:

list.append(x)

Hängt ein neues Element an das Ende der Liste an. Äquivalent zu a[len(a):] = [x].

list.extend(L)

Erweitert die Liste, indem es alle Elemente der gegebenen Liste anhängt. Äquivalent zu a[len(a):] = L.

list.insert(i, x)

Fügt ein Element an der gegebenen Position ein. Das erste Argument ist der Index des Elements, vor dem eingefügt werden soll, so fügt a.insert(0, x) am Anfang der Liste ein und a.insert(len(a), x) ist äquivalent zu a.append(x).

list.remove(x)

Entfernt das erste Element, dessen Wert x ist. Es gibt eine Fehlermeldung, wenn solch ein Element nicht existiert.

list.pop([i])

Entfernt das Element an der gegebenen Position und gibt es zurück. Ist kein Index gegeben, entfernt a.pop() das letzte Element der Liste und gibt es zurück. (Die eckigen Klammern um das i in der Methodensignatur herum, zeigen an, dass das Argument optional ist und nicht, dass man dort eckige Klammern eintippen sollte. Du wirst diese Notation des öfteren in der Referenz der Pythonbibliothek sehen.

list.index(x)

Gibt den Index des ersten Elements in der Liste zurück, dessen Wert x ist. Es gibt eine Fehlermeldung, wenn solch ein Element nicht existiert.

list.count(x)

Gibt zurück, wie oft x in der Liste vorkommt.

list.sort()

Sortiert die Elemente der Liste im selben Exemplar (in place).

list.reverse()

Kehrt die Reihenfolge der Listenelemente im selben Exemplar (in place) um.

Ein Beispiel, das die meisten Methoden von Listen benutzt:

>>> a = [66.25, 333, 333, 1, 1234.5]
>>> print(a.count(333), a.count(66.25), a.count('x'))
2 1 0
>>> a.insert(2, -1)
>>> a.append(333)
>>> a
[66.25, 333, -1, 333, 1, 1234.5, 333]
>>> a.index(333)
1
>>> a.remove(333)
>>> a
[66.25, -1, 333, 1, 1234.5, 333]
>>> a.reverse()
>>> a
[333, 1234.5, 1, 333, -1, 66.25]
>>> a.sort()
>>> a
[-1, 1, 66.25, 333, 333, 1234.5]

Vielleicht ist dir aufgefallen, dass bei Methoden wie insert, remove oder sort, die die Liste verändern, keinen Rückgabewert gedruckt wird – sie geben None zurück. [1] Dies ist ein Designprinzip für alle veränderlichen Datenstrukturen in Python.

>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]

>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry")           # Terry kommt an
>>> queue.append("Graham")          # Graham kommt an
>>> queue.popleft()                 # Der Erste geht jetzt
'Eric'
>>> queue.popleft()                 # Der Zweite geht jetzt
'John'
>>> queue                           # Verbleibende Schlange in der
>>>                                 # Reihenfolge der Ankunft
deque(['Michael', 'Terry', 'Graham'])

>>> squares = []
>>> for x in range(10):
...     squares.append(x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

squares = [x**2 for x in range(10)]

>>> [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

>>> combs = []
>>> for x in [1,2,3]:
...     for y in [3,1,4]:
...         if x != y:
...             combs.append((x, y))
...
>>> combs
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

>>> vec = [-4, -2, 0, 2, 4]
>>> # erzeuge eine neue Liste mit den verdoppelten Werten
>>> [x*2 for x in vec]
[-8, -4, 0, 4, 8]
>>> # filtere die negativen Zahlen heraus
>>> [x for x in vec if x >= 0]
[0, 2, 4]
>>> # wende eine Funktion auf alle Elemente an
>>> [abs(x) for x in vec]
[4, 2, 0, 2, 4]
>>> # rufe eine Methode auf allen Elementen auf
>>> freshfruit = ['  banana', '  loganberry ', 'passion fruit  ']
>>> [weapon.strip() for weapon in freshfruit]
['banana', 'loganberry', 'passion fruit']
>>> # erstelle eine Liste von 2-Tupeln der Form (zahl, quadrat)
>>> [(x, x**2) for x in range(6)]
[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)]
>>> # das Tupel muss geklammert werden, sonst wird ein Fehler erzeugt
>>> [x, x**2 for x in range(6)]
  File "<stdin>", line 1, in ?
    [x, x**2 for x in range(6)]
               ^
SyntaxError: invalid syntax
>>> # verflache eine Liste durch eine LC mit zwei 'for'
>>> vec = [[1,2,3], [4,5,6], [7,8,9]]
>>> [num for elem in vec for num in elem]
[1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> from math import pi
>>> [str(round(pi, i)) for i in range(1, 6)]
['3.1', '3.14', '3.142', '3.1416', '3.14159']

>>> matrix = [
...     [1, 2, 3, 4],
...     [5, 6, 7, 8],
...     [9, 10, 11, 12],
... ]

>>> [[row[i] for row in matrix] for i in range(4)]
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

>>> transposed = []
>>> for i in range(4):
...     transposed.append([row[i] for row in matrix])
...
>>> transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

>>> transposed = []
>>> for i in range(4):
...     # the following 3 lines implement the nested listcomp
...     transposed_row = []
...     for row in matrix:
...         transposed_row.append(row[i])
...     transposed.append(transposed_row)
...
>>> transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

>>> list(zip(*mat))
[(1, 4, 7), (2, 5, 8), (3, 6, 9)]

Die del-Anweisung¶

Es gibt einen Weg ein Listenelement durch seinen Index, statt durch seinen Wert zu löschen: Die del-Anweisung. Sie unterscheidet sich von der pop()-Methode, da sie keinen Wert zurückgibt. Die del-Anweisung kann auch dazu benutzt werden Abschnitte einer Liste zu löschen oder sie ganz zu leeren (was wir vorhin durch die Zuweisung einer leeren Liste an einen Abschnitt getan haben). Zum Beispiel:

>>> a = [-1, 1, 66.25, 333, 333, 1234.5]
>>> del a[0]
>>> a
[1, 66.25, 333, 333, 1234.5]
>>> del a[2:4]
>>> a
[1, 66.25, 1234.5]
>>> del a[:]
>>> a
[]

del kann auch dazu benutzt werden, ganze Variablen zu löschen:

>>> del a

Danach den Namen a zu referenzieren führt zu einer Fehlermeldung (zumindest bis dem Namen ein anderer Wert zugewiesen wird). Später werden werden wir noch andere Einsatzmöglichkeiten besprechen.

Tupel und Sequenzen¶

Wir haben gesehen, dass Listen und Zeichenketten viele Eigenschaften, wie Slicing und Indizierung, gemein haben. Beide sind Exemplare von Sequenzdatentypen (siehe Sequence Types). Da sich Python weiterentwickelt können auch noch andere Sequenzdatentypen hinzukommen. Es gibt aber noch einen weiteren standardmäßigen Sequenzdatentyp: Das Tupel.

Ein Tupel besteht aus mehreren Werten, die durch Kommas von einander getrennt sind, beispielsweise:

>>> t = 12345, 54321, 'Hallo!'
>>> t[0]
12345
>>> t
(12345, 54321, 'Hallo!')
>>> # Tupel können verschachtelt werden:
... u = t, (1, 2, 3, 4, 5)
>>> u
((12345, 54321, 'Hallo!'), (1, 2, 3, 4, 5))
>>> # Tupel sind unveränderlich:
... t[0] = 88888
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> # aber sie können veränderliche Objekte enthalten:
... v = ([1, 2, 3], [3, 2, 1])
>>> v
([1, 2, 3], [3, 2, 1])

Wie man sehen kann, werden die ausgegebenen Tupel immer von Klammern umgeben, sodass verschachtelte Tupel richtig interpretiert werden. Sie können mit oder ohne Klammern eingegeben werden, obwohl Klammern trotzdem sehr oft benötigt werden (wenn das Tupel Teil eines größeren Ausdrucks ist). Es ist nicht möglich den individuellen Elementen etwas zuzuweisen, aber es ist möglich Tupel zu erstellen, die veränderliche Objekte, wie beispielsweise Listen, enthalten.

Obwohl Tupel ähnlich zu Listen erscheinen, werden sie oft an verschiedenen Situationen und zu einem anderen Zweck verwendet. Tupel sind unveränderlich und enthalten üblicherweise eine heterogene Sequenz von Elementen, auf die über unpacking (siehe unten) oder über einen Index (oder sogar über Attribute im Fall von namedtuples) zugegriffen wird. Lisen sind veränderlich und ihre Elemente sind üblicherweise homogen und der Zugriff erfolgt durch das iterieren über die Liste.

Ein spezielles Problem ergibt sich in der Darstellung von Tupeln, die 0 oder 1 Elemente haben: Die Syntax hat ein paar Eigenheiten um das Problem zu lösen. Leere Tupel lassen sich mit einem leeren Klammerpaar darstellen und ein Tupel mit einem Element wird erstellt, indem dem Wert ein Komma nachgestellt wird, es reicht jedoch nicht, das Element nur in Klammern zu schreiben. Hässlich aber effektiv. Zum Beispiel:

>>> empty = ()
>>> singleton = 'Hallo',    # <-- das angehängte Komma nicht vergessen
>>> len(empty)
0
>>> len(singleton)
1
>>> singleton
('Hallo',)

Die Anweisung t = 12345, 54321, 'Hallo!' ist ein Beispiel für das Tupel packen (tuple packing): Die Werte 12345, 54321, 'Hallo!' werden zusammen in ein Tupel gepackt. Das Gegenteil ist ebenso möglich:

>>> x, y, z = t

Das wird passenderweise Sequenz auspacken (sequence unpacking) genannt und funktioniert mit jeder Sequenz auf der rechten Seite der Zuweisung. Die Anzahl der Namen auf der linken Seite muss genauso groß sein, wie die Länge der Sequenz. Eine Mehrfachzuweisung ist eigentlich nur eine Kombination von Tupel packen und dem Auspacken der Sequenz.

Mengen¶

Python enthält auch einen Datentyp für Mengen (sets). Eine Menge ist eine ungeordnete Sammlung ohne doppelte Elemente. Sie werden vor allem dazu benutzt, um zu testen, ob ein Element in der Menge vertreten ist und doppelte Einträge zu beseitigen. Mengenobjekte unterstützen ebenfalls mathematische Operationen wie Vereinigungsmenge, Schnittmenge, Differenz und symmetrische Differenz.

Geschweifte Klammern oder die Funktion set() können dazu genutzt werden Mengen zu erzeugen. Wichtig: Um eine leere Menge zu erzeugen muss man set() benutzen, {} ist dagegen nicht möglich. Letzteres erzeugt ein leeres Dictionary, eine Datenstruktur, die wir im nächsten Abschnitt besprechen.

Hier eine kurze Demonstration:

>>> basket = {'Apfel', 'Orange', 'Apfel', 'Birne', 'Orange', 'Banane'}
>>> print(basket)                      # zeigt, dass die Duplikate entfernt wurden
{'Orange', 'Birne', 'Apfel', 'Banane'}
>>> 'Orange' in basket                 # schnelles Testen auf Mitgliedschaft
True
>>> 'Fingerhirse' in basket
False

>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  # einzelne Buchstaben in a
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # in a aber nicht in b
{'r', 'd', 'b'}
>>> a | b                              # in a oder b
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # sowohl in a, als auch in b
{'a', 'c'}
>>> a ^ b                              # entweder in a oder b
{'r', 'd', 'b', 'm', 'z', 'l'}

Wie für Listen gibt es auch eine “Set Comprehension”-Syntax:

>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}

Dictionaries¶

Ein weiterer nützlicher Datentyp, der in Python eingebaut ist, ist das Dictionary (siehe Mapping Types). Dictionaries sind in manch anderen Sprachen als “assoziativer Speicher” oder “assoziative Arrays” zu finden. Anders als Sequenzen, die über Zahlen indizierbar sind, sind Dictionaries durch Schlüssel (keys), als die jeder unveränderbare Typ dienen kann, indizierbar; aus Zeichenketten und Zahlen kann immer solch ein Schlüssel gebildet werden. Tupel können als Schlüssel benutzt werden, wenn sie nur aus Zeichenketten, Zahlen oder Tupel bestehen; enthält ein Tupel direkt oder indirekt ein veränderbares Objekt, kann es nicht als Schlüssel genutzt werden. Listen können nicht als Schlüssel benutzt werden, da sie direkt veränderbar sind, sei es durch Indexzuweisung, Abschnittszuweisung oder Methoden wie append() and extend().

Am Besten stellt man sich Dictionaries als ungeordnete Menge von Schlüssel: Wert-Paaren vor, mit der Anforderung, dass die Schlüssel innerhalb eines Dictionaries eindeutig sind. Ein Paar von geschweiften Klammern erstellt ein leeres Dictionary: {}. Schreibt man eine Reihe von Komma-getrennten Schlüssel-Wert-Paaren in die Klammern, fügt man diese als Anfangspaare dem Dictionary hinzu; dies ist ebenfalls die Art und Weise, wie Dictionaries ausgegeben werden.

Die Hauptoperationen, die an einem Dictionary durchgeführt werden, sind die Ablage eines Wertes unter einem Schlüssel und der Abruf eines Wertes mit dem gegebenen Schlüssel. Es ist auch möglich ein Schlüssel-Wert-Paar per del zu löschen. Legt man einen Wert unter einem Schlüssel ab, der schon benutzt wird, überschreibt man den alten Wert, der vorher mit diesem Schlüssel verknüpft war. Einen Wert mit einem nicht-existenten Schlüssel abrufen zu wollen, erzeugt eine Fehlermeldung.

Der Aufruf list(d.keys()) auf ein Dictionary gibt eine Liste aller Schlüssel in zufälliger Reihenfolge zurück (will man sie sortiert haben, verwendet man einfach die Funktion sorted(d.keys()) stattdessen). [2] Um zu überprüfen ob ein einzelner Schlüssel im Dictionary ist, lässt sich das Schlüsselwort in benutzen.

Hier ein kleines Beispiel wie man Dictionaries benutzt:

>>> tel = {'jack': 4098, 'sape': 4139}
>>> tel['guido'] = 4127
>>> tel
{'sape': 4139, 'guido': 4127, 'jack': 4098}
>>> tel['jack']
4098
>>> del tel['sape']
>>> tel['irv'] = 4127
>>> tel
{'guido': 4127, 'irv': 4127, 'jack': 4098}
>>> list(tel.keys())
['irv', 'guido', 'jack']
>>> sorted(tel.keys())
['guido', 'irv', 'jack']
>>> 'guido' in tel
True
>>> 'jack' not in tel
False

Der dict()-Konstruktor erstellt Dictionaries direkt von Sequenzen von Schlüssel-Wert-Paare:

>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'sape': 4139, 'jack': 4098, 'guido': 4127}

Außerdem können “Dict Comprehensions” benutzt werden, um Dictionaries von willkürlichen Schlüssel und Wert Ausdrücken zu erstellen:

>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}

Sind die Schlüssel einfache Zeichenketten, ist es manchmal einfacher, die Paare als Schlüsselwort-Argumente anzugeben:

>>> dict(sape=4139, guido=4127, jack=4098)
{'sape': 4139, 'jack': 4098, 'guido': 4127}

Schleifentechniken¶

Wenn man über Dictionaries iteriert, lassen sich der Schlüssel und der entsprechende Wert gleichzeitig durch die Methode items() abrufen.

>>> knights = {'Gallahad': 'der Reine', 'Robin': 'der Mutige'}
>>> for k, v in knights.items():
...     print(k, v)
...
Gallahad der Reine
Robin der Mutige

Iteriert man über eine Sequenz, lassen sich der Index und das entsprechende Objekt gleichzeitig über die Funktion enumerate() abrufen.

>>> for i, v in enumerate(['tic', 'tac', 'toe']):
...     print(i, v)
...
0 tic
1 tac
2 toe

Um über mehrere Sequenzen gleichzeitig zu iterieren, können die Einträge mit Hilfe der zip()-Funktion gruppiert werden.

>>> questions = ['Name', 'Auftrag']
>>> answers = ['Lancelot', 'die Suche nach dem Heiligen Gral']
>>> for q, a in zip(questions, answers):
...     print('Was ist dein {0}?  Er ist {1}.'.format(q, a))
...
Was ist dein Name?  Er ist Lancelot.
Was ist dein Auftrag?  Er ist die Suche nach dem Heiligen Gral.

Um über eine Sequenz in umgekehrter Reihenfolge zu iterieren, gibt man die Sequenz zuerst in richtiger Reihenfolge an und ruft dann die Funktion reversed() auf.

>>> for i in reversed(range(1, 10, 2)):
...     print(i)
...
9
7
5
3
1

Um über eine Sequenz in sortierter Reihenfolge zu iterieren, gibt es die Funktion sorted(), die eine neue, sortierte Liste zurückgibt, die ursprüngliche Sequenz, aber nicht anrührt.

>>> basket = ['Apfel', 'Orange', 'Apfel', 'Birne', 'Orange', 'Banane']
>>> for f in sorted(set(basket)):
...     print(f)
...
Apfel
Banane
Birne
Orange

Mehr zu Bedingungen¶

Die Bedingungen, die in while- und if-Anweisungen benutzt werden, können jegliche Operatoren enthalten, nicht nur Vergleiche.

Die Vergleichsoperatoren in und not in überprüfen, ob ein Wert in einer Sequenz (nicht) vorkommt. Die Operatoren is und is not vergleichen auf Objektidentität, d.h. ob zwei Objekte dieselben sind; dies ist aber nur wichtig für veränderbare Objekte wie Listen. Alle Vergleichsoperatoren haben dieselbe Priorität, die geringer als die von numerischen Operatoren ist.

Vergleiche können aneinandergereiht werden. Zum Beispiel überprüft a < b == c, ob a kleiner als b ist und darüberhinaus b gleich c ist.

Vergleiche können kombiniert werden, indem man die boolschen Operatoren and und or benutzt. Das Ergebnis des Vergleiches (oder jedes anderen boolschen Ausdrucks) kann mit not negiert werden. Sie haben eine geringere Priorität als Vergleichsoperatoren; von ihnen hat not die höchste und or die niedrigste Priorität, sodass A and not B or C äquivalent zu (A and (not B)) or C ist. Wie üblich können auch hier Klammern benutzt werden, um die gewünschte Gruppierung auszudrücken.

Die boolschen Operatoren and und or sind sogenannte Kurzschluss- (short-circuit) Operatoren: Ihre Argumente werden von links nach rechts ausgewertet und die Auswertung wird abgebrochen, sobald das Ergebnis feststeht. Zum Beispiel, wenn A und C wahr, aber B unwahr ist, wird C von A and B and C nicht ausgewertet. Werden sie als genereller Wert und nicht als Boolean benutzt, ist der Rückgabewert eines Kurzschluss-Operators das zuletzt ausgewertete Argument.

Es ist möglich das Ergebnis eines Vergleiches oder eines anderen boolschen Ausdruck einer Variablen zuzuweisen. Zum Beispiel:

>>> string1, string2, string3 = '', 'Trondheim', 'Hammer Tanz'
>>> non_null = string1 or string2 or string3
>>> non_null
'Trondheim'

Wichtig ist, dass in Python, anders als in C, Zuweisungen nicht innerhalb eines Ausdrucks vorkommen können. C-Programmierer mögen darüber murren, aber diese Einschränkung vermeidet eine in C übliche Fehlerklasse, in einem Ausdruck = , statt des beabsichtigten ==, zu schreiben.

Vergleich von Sequenzen mit anderen Typen¶

Sequenzobjekte können mit anderen Objekten desselben Sequenztyps verglichen werden. Der Vergleich benutzt eine lexikographische Ordnung: Zuerst werden die ersten beiden Elemente verglichen, unterscheiden sie sich, bestimmt das das Ergebnis des Vergleiches. Sind sie gleich, werden die nächsten zwei Elemente verglichen, und so weiter, bis sich eine der beiden erschöpft. Sind zwei Elemente, die verglichen werden sollen wiederum Sequenzen desselben Sequenztyps, wird der lexikographische Vergleich rekursiv durchgeführt. Sind alle Elemente zweier Sequenzen gleich, werden die Sequenzen für gleich befunden. Ist eine Sequenz eine anfängliche Teilfolge der anderen, so ist die kürzere die kleinere (geringere). Die Lexikographische Ordnung von Zeichenketten benutzt die Nummer des Unicode-Codepoints, um einzelne Zeichen zu ordnen. Ein paar Beispiele für Vergleiche zwischen Sequenzen des gleichen Typs:

(1, 2, 3)              < (1, 2, 4)
[1, 2, 3]              < [1, 2, 4]
'ABC' < 'C' < 'Pascal' < 'Python'
(1, 2, 3, 4)           < (1, 2, 4)
(1, 2)                 < (1, 2, -1)
(1, 2, 3)             == (1.0, 2.0, 3.0)
(1, 2, ('aa', 'ab'))   < (1, 2, ('abc', 'a'), 4)

Das Vergleichen von Objekten verschiedenen Typs durch < oder > ist erlaubt, sofern die Objekte passende Vergleichsmethoden haben. Zum Beispiel werden numerische Typen anhand ihres numerischen Wertes verglichen, sodass 0 0.0 gleicht, usw. Andernfalls wird der Interpreter eine TypeError-Ausnahme verursachen, statt eine willkürliche Ordnung bereitzustellen.

Mehr zum Thema Module¶

Ein Modul kann sowohl ausführbare Anweisungen, als auch Definitionen einer Funktion enthalten. Diese Anweisungen sind dazu gedacht, das Modul zu initialisieren, und werden nur ausgeführt, wenn das Modul zum ersten Mal importiert wird.

Jedes Modul hat seine eigene, private Symboltabelle, welche wiederum als globale Symboltabelle von allen Funktion in diesem Modul verwendet wird. Daher kann der Verfasser eines Moduls ohne Bedenken globale Variablen in seinem Modul verwenden, da sie sich nicht mit den globalen Variablen des Benutzers überschneiden können. Andererseits kann man (wenn man weiß, was man tut) auch die globalen Variablen eines Moduls verändern, indem man die gleiche Schreibweise verwendet, um auch dessen Funktionen anzusprechen, modname.itemname.

Module können andere Module importieren. Es ist üblich, aber nicht zwingend notwendig, dass man alle import-Anweisungen an den Anfang eines Moduls setzt (oder in diesem Fall Skripts). Die Namen der importierten Module werden in die Symboltabelle des importierenden Moduls eingefügt.

Es gibt eine Variante der import-Anweisung, welche bestimmte Namen aus einem Modul direkt in die Symboltabelle des importierenden Moduls einfügt. Beispielsweise:

>>> from fibo import fib, fib2
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377

Diese Variante fügt allerdings nicht den Modulnamen, aus dem die Namen importiert werden, in die lokale Symboltabelle ein, sondern nur die aufgeführten. In diesem Beispiel wird fibo also nicht eingefügt.

Zusätzlich gibt es eine Variante um alle Namen eines Moduls zu importieren:

>>> from fibo import *
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 37

Hiermit werden alle Namen, sofern sie nicht mit einem Unterstrich (_) beginnen , importiert. In den meisten Fällen wird diese Variante nicht verwendet, denn dadurch werden unbekannte Namen in den Interpreter importiert und so kann es vorkommen, dass einige Namen überschrieben werden, die bereits definiert worden sind.

Beachte, dass der *-Import eines Moduls oder Paketes im allgemeinen verpönt ist, da er oft schlecht lesbaren Code verursacht. Allerdings ist es in Ordnung ihn im interaktiven Interpreter zu benutzen, um weniger tippen zu müssen.

python fibo.py <Argumente>

if __name__ == "__main__":
    import sys
    fib(int(sys.argv[1]))

$ python fibo.py 50
1 1 2 3 5 8 13 21 34

>>> import fibo
>>>

Standardmodule¶

Python wird mit einer Bibliothek von Standardmodulen ausgeliefert, welche in der Python Library Reference beschrieben werden. Einige Module sind in den Interpreter eingebaut. Diese bieten Zugang zu Operationen, die nicht Teil des Sprachkerns sind, aber trotzdem eingebaut sind. Entweder, um Zugang zu Systemoperationen (wie z. B. Systemaufrufe) bereitzustellen oder aus Effizienzgründen. Die Zusammenstellung dieser Module ist eine Option in der Konfiguration, welche auch von der verwendeten Plattform abhängig ist. Beispielsweise ist das winreg-Modul nur unter Windows-Systemen verfügbar. Ein bestimmtes Modul verdient besondere Aufmerksamkeit: sys, welches in jeden Python-Interpreter eingebaut ist. Die Variablen sys.ps1 und sys.ps2 definieren die primären und sekundären Eingabeaufforderungen, die in der Kommandozeile verwendet werden:

>>> import sys
>>> sys.ps1
'>>> '
>>> sys.ps2
'... '
>>> sys.ps1 = 'C> '
C> print('Yuck!')
Yuck!
C>

Diese beiden Variablen werden nur definiert, wenn der Interpreter im interaktiven Modus ist.

Die Variable sys.path ist eine Liste von Zeichenketten, die den Suchpfad des Interpreters vorgibt. Sie ist mit einem Standardpfad voreingestellt, der aus der Umgebungsvariable PYTHONPATH entnommen wird oder aus einem eingebauten Standardwert, falls PYTHONPATH nicht gesetzt ist. Man kann diese Variable mit normalen Listenoperationen verändern:

>>> import sys
>>> sys.path.append('/ufs/guido/lib/python')

Die dir()-Funktion¶

Die eingebaute Funktion dir() wird benutzt, um herauszufinden, welche Namen in einem Modul definiert sind. Es wird eine sortierte Liste von Strings zurückgegeben:

    >>> import fibo, sys
    >>> dir(fibo)
    ['__name__', 'fib', 'fib2']
    >>> dir(sys)
['__displayhook__', '__doc__', '__excepthook__', '__name__', '__stderr__',
'__stdin__', '__stdout__', '_getframe', 'api_version', 'argv',
'builtin_module_names', 'byteorder', 'callstats', 'copyright',
'displayhook', 'exc_info', 'excepthook', 'exec_prefix', 'executable',
'exit', 'getdefaultencoding', 'getdlopenflags', 'getrecursionlimit',
'getrefcount', 'hexversion', 'maxint', 'maxunicode', 'meta_path', 'modules',
'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix', 'ps1',
'ps2', 'setcheckinterval', 'setdlopenflags', 'setprofile',
'setrecursionlimit', 'settrace', 'stderr', 'stdin', 'stdout', 'version',
'version_info', 'warnoptions']

Wenn man keine Parameter übergibt, liefert dir() eine Liste der aktuell definierten Namen:

    >>> a = [1, 2, 3, 4, 5]
    >>> import fibo
    >>> fib = fibo.fib
    >>> dir()
['__builtins__', '__doc__', '__file__', '__name__', 'a', 'fib', 'fibo',
'sys']

Zu Beachten ist, dass alle Typen von Namen ausgegeben werden: Variablen, Module, Funktionen, etc.

dir() listet allerdings nicht die Namen der eingebauten Funktionen und Variablen auf. Falls man diese auflisten will, muss man das Standardmodul builtins verwenden:

    >>> import builtins
>>> dir(builtins)
['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException',
'BufferError', 'BytesWarning', 'DeprecationWarning', 'EOFError', 'Ellipsis',
'EnvironmentError', 'Exception', 'False', 'FloatingPointError',
'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning',
'IndentationError', 'IndexError', 'KeyError', 'KeyboardInterrupt',
'LookupError', 'MemoryError', 'NameError', 'None', 'NotImplemented',
'NotImplementedError', 'OSError', 'OverflowError',
'PendingDeprecationWarning', 'ReferenceError', 'RuntimeError',
'RuntimeWarning', 'StopIteration', 'SyntaxError', 'SyntaxWarning',
'SystemError', 'SystemExit', 'TabError', 'True', 'TypeError',
'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError',
'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning',
'ValueError', 'Warning', 'ZeroDivisionError', '__build_class__',
'__debug__', '__doc__', '__import__', '__name__', '__package__', 'abs',
'all', 'any', 'ascii', 'bin', 'bool', 'bytearray', 'bytes', 'chr',
'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr',
'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit', 'filter',
'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash',
'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter',
'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min',
'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit',
'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted',
'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']

Pakete¶

Pakete werden dazu verwendet, den Modul-Namensraum von Python zu strukturieren, indem man Modulnamen durch Punkte trennt. Zum Beispiel verweist A.B auf ein Untermodul B im Paket A. Genauso wie die Verwendung von Modulen den Autor von Modulen davor bewahrt, sich Sorgen um andere globale Variablennamen zu machen, so bewahrt die Verwendung von Modulen, die durch mehrere Punkte getrennt sind, den Autor davor, sich Sorgen um andere Modulnamen machen zu müssen.

Angenommen man will eine Sammlung von Modulen (ein “Paket”) erstellen, um Audiodateien und -daten einheitlich zu bearbeiten. Es gibt unzählige verschiedene Audioformate (gewöhnlicherweise erkennt man diese an Ihrer Dateiendung, z.B. .wav, .aiff, .au), sodass man eine ständig wachsende Sammlung von Modulen erstellen und warten muss. Außerdem will man auch verschiedene Arbeiten an den Audiodaten verrichten (wie zum Beispiel Mixen, Echo hinzufügen, etc.), also wird man immer wieder Module schreiben, die diese Arbeiten ausführen. Hier eine mögliche Struktur für so ein Paket (ausgedrückt in der Form eines hierarchischen Dateisystems):

sound/                             Top-level package
         __init__.py               Initialize the sound package
         formats/                  Subpackage for file format conversions
                 __init__.py
                 wavread.py
                 wavwrite.py
                 aiffread.py
                 aiffwrite.py
                 auread.py
                 auwrite.py
                 ...
         effects/                  Subpackage for sound effects
                 __init__.py
                 echo.py
                 surround.py
                 reverse.py
                 ...
         filters/                  Subpackage for filters
                 __init__.py
                 equalizer.py
                 vocoder.py
                 karaoke.py
                 ...

Wenn man das Paket importiert, sucht Python durch die Verzeichnisse im sys.path, um nach dem Paket in einem Unterverzeichnis zu suchen.

Die __init__.py-Datei wird benötigt, damit Python das Verzeichnis als Paket behandelt. Dies hat den Grund, dass Verzeichnisse mit einem normalen Namen, wie z.B. string, nicht unbeabsichtigt Module verstecken, die weiter hinten im Suchpfad erscheinen. Im einfachsten Fall ist __init__.py eine leere Datei, sie kann allerdings auch Initialisierungscode für das Paket enthalten oder die __all__-Variable setzen, welche später genauer beschrieben wird.

Benutzer eines Pakets können individuelle Module aus dem Paket importieren:

import sound.effects.echo

Dieser Vorgang lädt das Untermodul sound.effects.echo. Es muss mit seinem kompletten Namen referenziert werden:

sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)

Eine alternative Methode, um dieses Untermodul zu importieren:

from sound.effects import echo

Diese Variante lädt auch das Untermodul echo, macht es aber ohne seinen Paket-Präfix verfügbar. Man verwendet es folgendermaßen:

echo.echofilter(input, output, delay=0.7, atten=4)

Eine weitere Möglichkeit ist, die beschriebene Funktion oder Variable direkt zu importieren:

from sound.effects.echo import echofilter

Genau wie in den anderen Beispielen, lädt dies das Untermodul echo. In diesem Fall wird aber die echofilter() Funktion direkt verfügbar gemacht:

echofilter(input, output, delay=0.7, atten=4)

Wenn man from package import item verwendet, kann das item entweder ein Untermodul und -paket sein oder ein Name, der in diesem Paket definiert ist (z. B. eine Funktion, eine Klasse oder Variable). Die import-Anweisung überprüft zuerst, ob das item in diesem Paket definiert ist; falls nicht, wird von einem Modul ausgegangen und versucht es zu laden. Wenn nichts gefunden wird, wird eine ImportError-Ausnahme geworfen.

Im Gegensatz dazu, muss bei Verwendung von import item.subitem.subsubitem jedes item ein Paket sein; das letzte item kann ein Modul oder ein Paket sein, aber es darf keine Klasse, Funktion oder Variable im darüber geordneten item sein.

__all__ = ["echo", "surround", "reverse"]

import sound.effects.echo
import sound.effects.surround
from sound.effects import *

from . import echo
from .. import formats
from ..filters import equalizer

Ausgefallenere Ausgabeformatierung¶

Bis jetzt sind uns zwei Arten der Ausgabe von Werten begegnet: Ausdrucksanweisungen (expression statements) und die print()-Funktion. (Eine dritte Möglichkeit ist die write()-Methode von Dateiobjekten; die Standardausgabedatei kann als sys.stdout referenziert werden. In der Bibliotheksreferenz gibt es dazu weitere Informationen.)

Oft will man mehr Kontrolle über die Formatierung der Ausgabe haben als nur Leerzeichen-getrennte Werte auszugeben. Es gibt zwei Arten die Ausgabe zu formatieren: Die erste Möglichkeit ist, dass man die gesamte Verarbeitung der Zeichenketten selbst übernimmt; indem man Slicing- und Verknüpfungsoperationen benutzt, kann man jede denkbare Anordnung zusammenstellen. Der Typ string hat einige Methoden, die ein paar nützliche Operationen ausführen, um Zeichenketten auf eine bestimmte Länge aufzufüllen; diese werden wir in Kürze behandeln. Die zweite Möglichkeit ist die Benutzung der format()-Methode.

Das string-Modul enthält eine Klasse Template, die noch einen Weg bietet, Werte in Zeichenketten zu ersetzen.

Eine Frage bleibt natürlich: Wie konvertiert man Werte zu Zeichenketten? Glücklicherweise kennt Python Wege, um jeden Wert in eine Zeichenkette umzuwandeln: Man übergibt den Wert an die repr()- oder str()-Funktion.

Die str()-Funktion ist dazu gedacht eine möglichst menschenlesbare Repräsentation des Wertes zurückzugeben, während repr() dazu gedacht ist, vom Interpreter lesbar zu sein (oder einen SyntaxError erzwingt, wenn es keine äquivalente Syntax gibt). Für Objekte, die keine besondere menschenlesbare Repräsentation haben, gibt str() denselben Wert wie repr() zurück. Viele Werte wie Nummern oder Strukturen wie Listen und Dictionaries benutzen für beide Funktionen dieselbe Repräsentation. Besonders Zeichenketten haben zwei verschiedene Repräsentationen.

Ein paar Beispiele:

>>> s = 'Hallo Welt!'
>>> str(s)
'Hallo Welt!'
>>> repr(s)
"'Hallo Welt!'"
>>> str(1/7)
'0.14285714285714285'
>>> x = 10 * 3.25
>>> y = 200 * 200
>>> s = 'Der Wert von x ist ' + repr(x) + ', und y ist ' + repr(y) + '...'
>>> print(s)
Der Wert von x ist 32.5, und y ist 40000...
>>> #repr() bei einer Zeichenkette benutzt Anführungszeichen und Backslashes:
... hello = 'Hallo Welt\n'
>>> hellos = repr(hello)
>>> print(hellos)
'Hallo Welt\n'
>>> # Das Argument für repr() kann jedes Pythonobjekt sein:
... repr((x, y, ('spam', 'eggs')))
"(32.5, 40000, ('spam', 'eggs'))"

Hier zwei Möglichkeiten, eine Tabelle von Quadrat- und Kubikzahlen zu erstellen:

>>> for x in range(1, 11):
...     print(repr(x).rjust(2), repr(x*x).rjust(3), end=' ')
...     # Achte auf die Benutzung von 'end' in der vorherigen Zeile
...     print(repr(x*x*x).rjust(4))
...
 1   1    1
 2   4    8
 3   9   27
 4  16   64
 5  25  125
 6  36  216
 7  49  343
 8  64  512
 9  81  729
10 100 1000

>>> for x in range(1, 11):
...     print('{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x))
...
 1   1    1
 2   4    8
 3   9   27
 4  16   64
 5  25  125
 6  36  216
 7  49  343
 8  64  512
 9  81  729
10 100 1000

(Beachte, dass im ersten Beispiel ein Leerzeichen pro Spalte durch die Funktionsweise von print() hinzugefügt wird: Sie trennt ihre Argumente mit Leerzeichen.)

Dieses Beispiel hat die rjust()-Methode von Zeichenkettenobjekten gezeigt, die eine Zeichenkette in einem Feld der gegebenen Breite rechtsbündig macht, indem sie diese links mit Leerzeichen auffüllt. Es gibt die ähnlichen Methoden ljust() und center(). Diese Methoden schreiben nichts, sondern geben eine neue Zeichenkette zurück. Ist die gegebene Zeichenkette zu lang, schneiden sie nichts, sondern geben diese unverändert zurück; dies wird die Anordnung durcheinanderbringen, aber ist meistens besser als die Alternative, dass der Wert verfälscht wird. (Will man wirklich abschneiden, kann man immer noch eine Slicing-Operation hinzufügen, zum Beispiel x.ljust(n)[:n].)

Es gibt noch eine weitere Methode, zfill(), die eine numerische Zeichenkette mit Nullen auffüllt. Sie versteht auch Plus- und Minuszeichen:

>>> '12'.zfill(5)
'00012'
>>> '-3.14'.zfill(7)
'-003.14'
>>> '3.14159265359'.zfill(5)
'3.14159265359'

Die einfachste Benutzung der format()-Methode sieht so aus:

>>> print('Wir sind die {}, die "{}!" sagen.'.format('Ritter', 'Ni'))
Wir sind die Ritter, die "Ni!" sagen.

Die Klammern und die Zeichen darin (genannt Formatfelder - format fields) werden mit den Objekten ersetzt, die der format()-Methode übergeben werden. Eine Nummer in den Klammern bezieht sich auf die Position des Objektes, die der format()-Methode übergeben werden.

>>> print('{0} and {1}'.format('spam', 'eggs'))
spam and eggs
>>> print('{1} and {0}'.format('spam', 'eggs'))
eggs and spam

Werden Schlüsselwortargumente in der format()-Methode benutzt, können deren Werte durch die Benutzung des Argumentnamens referenziert werden.

>>>print('Dieses {Speise} ist {Adjektiv}.'.format(Speise='Spam',
         Adjektiv='absolut schrecklich'))
Dieses Spam ist absolut schrecklich.

Positionsabhängige und Schlüsselwortargumente können willkürlich kombiniert werden:

>>>print('Die Geschichte von {0}, {1} und {anderer}.'.format('Bill',
         'Manfred', anderer='Georg'))
Die Geschichte von Bill, Manfred und Georg.

'!a' (wendet ascii() an), '!s' (wendet str() an) und '!r' (wendet repr() an) können dazu benutzt werden den übergebenen Wert zu konvertieren bevor er formatiert wird:

>>> import math
>>> print('Der Wert von PI ist ungefähr {}.'.format(math.pi))
Der Wert von PI ist ungefähr 3.14159265359.
>>> print('Der Wert von PI ist ungefähr {!r}.'.format(math.pi))
Der Wert von PI ist ungefähr 3.141592653589793.

Ein optionales ':' mit Formatspezifizierer (format specifier) können auf den Namen des Feldes folgen. Dies erlaubt einem eine größere Kontrolle darüber, wie der Wert formatiert wird. Das folgende Beispiel rundet Pi auf drei Stellen nach dem Komma.

>>> import math
>>> print('Der Wert von Pi ist ungefähr {0:.3f}.'.format(math.pi))
Der Wert von Pi ist ungefähr 3.142.

Übergibt man einen Integer nach dem ':', so legt man eine minimale Breite für dieses Feld an. Das ist nützlich um Tabellen schön aussehen zu lassen.

>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}
>>> for name, phone in table.items():
...     print('{0:10} ==> {1:10d}'.format(name, phone))
...
Jack       ==>       4098
Dcab       ==>       7678
Sjoerd     ==>       4127

Hat man einen wirklich langen Formatstring, den man nicht aufteilen will, wäre es nett, wenn man die zu formatierenden Variablen durch den Namen statt durch die Position referenzieren könnte. Dies kann einfach bewerkstelligt werden, indem man das Dictionary übergibt und auf die Schlüssel über eckige Klammern '[]' zugreift

>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
>>> print('Jack: {0[Jack]:d}; Sjoerd: {0[Sjoerd]:d}; '
         'Dcab: {0[Dcab]:d}'.format(table))
Jack: 4098; Sjoerd: 4127; Dcab: 8637678

Das könnte auch genauso erreicht werden, indem man die Tabelle als Schlüsselwortargumente mit der ‘**’-Notation übergibt.

>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
>>> print('Jack: {Jack:d}; Sjoerd: {Sjoerd:d}; Dcab: {Dcab:d}'.format(**table))
Jack: 4098; Sjoerd: 4127; Dcab: 8637678

Das ist besonders nützlich in Verbindung mit der eingebauten Funktion vars(), die ein Dictionary mit allen lokalen Variablen zurückgibt.

Format String Syntax gibt eine komplette Übersicht zur Zeichenkettenformatierung mit format().

>>> import math
>>> print('Der Wert von Pi ist ungefähr %5.3f.' % math.pi)
Der Wert von Pi ist ungefähr 3.142.

Lesen und Schreiben von Dateien¶

open() gibt ein Dateiobjekt (file object) zurück und wird meistens mit zwei Argumenten aufgerufen: open(filename, mode)

>>> f = open('/tmp/workfile', 'w')


>>> print(f)
<open file '/tmp/workfile', mode 'w' at 80a0960>

Das erste Argument ist eine Zeichenkette, die den Dateinamen enthält. Das zweite Argument ist eine andere Zeichenkette mit ein paar Zeichen, die die Art der Benutzung der Datei beschreibt. mode kann 'r' sein, wenn die Datei nur gelesen wird, 'w', wenn sie nur geschrieben wird (eine existierende Datei mit demselben Namen wird gelöscht) und 'a' öffnet die Datei zum Anhängen; alle Daten, die in die Datei geschrieben werden, werden automatisch ans Ende angehängt. 'r+' öffnet die Datei zum Lesen und Schreiben. Das mode-Argument ist optional, fehlt es, so wird 'r' angenommen.

Normalerweise werden Dateien im Textmodus (text mode) geöffnet, das heisst, dass man Zeichenketten von ihr liest beziehungsweise in sie schreibt, die in einer bestimmten Kodierung kodiert werden (der Standard ist UTF-8). Wird 'b' an das mode-Argument angehängt, so öffnet man die Datei im Binärmodus (binary mode); in ihm werden Daten als Byteobjekte gelesen und geschrieben. Dieser Modus sollte für alle Dateien genutzt werden, die keinen Text enthalten.

Im Textmodus wird beim Lesen standardmäßig das plattformspezifische Zeilenende (\n unter Unixen, \r\n unter Windows) zu einem einfachen \n konvertiert und beim Schreiben \n zurück zum plattformspezifischen Zeilenende. Diese versteckte Modifikation ist klasse für Textdateien, wird aber binäre Dateiformate, wie JPEG- oder EXE-Dateien, beschädigen. Achte sehr sorgfältig darauf, dass Du den Binärmodus benutzt, wenn Du solche Dateien schreibst oder liest.

>>> f.read()
'Das ist die ganze Datei.\n'
>>> f.read()
''

>>> f.readline()
'Dies ist die erste Zeile der Datei\n'
>>> f.readline()
'Zweite Zeile der Datei\n'
>>> f.readline()
''

>>> f.readlines()
['Dies ist die erste Zeile der Datei\n', 'Zweite Zeile der Datei\n']

>>> for line in f:
...     print(line, end='')
...
Dies ist die erste Zeile der Datei.
Zweite Zeile der Datei

>>> f.write('Dies ist ein Test\n')
18

>>> value = ('Die Antwort', 42)
>>> s = str(value)
>>> f.write(s)
19

>>> f = open('/tmp/workfile', 'rb+')
>>> f.write(b'0123456789abcdef')
16
>>> f.seek(5)     # Gehe zum 6. Byte der Datei
5
>>> f.read(1)
b'5'
>>> f.seek(-3, 2) # Gehe zum drittletzten Byte
13
>>> f.read(1)
b'd'

>>> f.close()
>>> f.read()
Traceback (most recent call last):
 File "<stdin>", line 1, in ?
ValueError: I/O operation on closed file

>>> with open('/tmp/workfile', 'r') as f:
...     read_data = f.read()
>>> f.closed
True

pickle.dump(x, f)

x = pickle.load(f)

Syntaxfehler¶

Syntaxfehler, auch Parser-Fehler genannt, sind vielleicht die häufigsten Fehlermeldungen, die Du bekommt, wenn Du Python lernst:

>>> while True print('Hallo Welt')
  File "<stdin>", line 1, in ?
    while True print('Hallo Welt')
                   ^
SyntaxError: invalid syntax

Der Parser wiederholt die störende Zeile und zeigt mit einem kleinen ‘Pfeil’ auf die Stelle, an der der Fehler entdeckt wurde. Der Fehler ist an dem Token aufgetreten (oder wurde zumindest dort entdeckt), welches vor dem Pfeil steht: In dem Beispiel wurde der Fehler bei der print()-Funktion entdeckt, da ein Doppelpunkt (':') vor der Funktion fehlt. Des weiteren werden der Dateiname und die Zeilennummer ausgegeben, sodass Du weißt, wo Du suchen musst, falls die Eingabe aus einem Skript kam.

Ausnahmen¶

Selbst wenn eine Anweisung oder ein Ausdruck syntaktisch korrekt ist, kann es bei der Ausführung zu Fehlern kommen. Fehler, die bei der Ausführung auftreten, werden Ausnahmen (engl: exceptions) genannt und sind nicht notwendigerweise schwerwiegend: Du wirst gleich lernen, wie Du in Python-Programmen mit ihnen umgehst. Die meisten Ausnahmen werden von Programmen aber nicht behandelt, und erzeugen Fehlermeldungen, wie dieses Beispiel zeigt:

>>> 10 * (1/0)
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
ZeroDivisionError: int division or modulo by zero
>>> 4 + spam*3
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
NameError: name 'spam' is not defined
>>> '2' + 2
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
TypeError: Can't convert 'int' object to str implicitly

Die letzte Zeile der Fehlermeldung gibt an, was passiert ist. Es gibt verschiedene Typen von Ausnahmen, und der Typ der Ausnahme wird als Teil der Meldung ausgegeben: Die Typen in diesem Beispiel sind ZeroDivisionError, NameError und TypeError. Die Zeichenkette, die als Ausnahmetyp ausgegeben wird, ist der Name der eingebauten Ausnahme, die aufgetreten ist. Dies gilt für alle eingebauten Ausnahmen, muss aber für benutzerdefinierte Ausnahmen nicht zutreffen (es ist aber eine nützliche Konvention). Standard-Ausnahmen sind eingebaute Bezeichner (keine reservierten Schlüsselwörter).

Der Rest der Zeile gibt Details an, die auf dem Ausnahmetyp und darauf, was die Ausnahme ausgelöst hat, basieren.

Der vorangehende Teil der Fehlermeldung zeigt den Zusammenhang, in dem die Ausnahme auftrat, in Form eines Traceback. Im Allgemeinen wird dort der Programmverlauf mittels der entsprechenden Zeilen des Quellcodes aufgelistet; es werden jedoch keine Zeilen ausgegeben, die von der Standardeingabe gelesen wurden.

Built-in Exceptions listet alle eingebauten Ausnahmen und ihre Bedeutung auf.

Ausnahmen behandeln¶

Es ist möglich, Programme zu schreiben, welche ausgewählte Ausnahmen behandeln. Schau Dir das folgende Beispiel an, welches den Benutzer solange um Eingabe bittet, bis eine gültige Ganzzahl eingegeben wird, es dem Benutzer aber ermöglicht, das Programm abzubrechen (mit Strg-C oder was das Betriebssystem sonst unterstützt); ein solcher vom Benutzer erzeugter Abbruch löst eine KeyboardInterrupt-Ausnahme aus:

>>> while True:
...     try:
...         x = int(input("Bitte gib eine Zahl ein: "))
...         break
...     except ValueError:
...         print("Ups! Das war keine gültige Zahl. Versuche es noch einmal...")
...

Die try-Anweisung funktioniert folgendermaßen:

• Zuerst wird der try-Block (die Anweisung(en) zwischen den Schlüsselwörtern try und except) ausgeführt.
• Wenn dabei keine Ausnahme auftritt, wird der except-Block übersprungen, und die Ausführung der try-Anweisung ist beendet.
• Wenn während der Ausführung des try-Blocks eine Ausnahme auftritt, wird der Rest des Blockes übersprungen. Wenn dann der Typ dieser Ausnahme der Ausnahme gleicht, welche nach dem except-Schlüsselwort folgt, wird der except-Block ausgeführt, und danach ist die Ausführung der try-Anweisung beendet.
• Wenn eine Ausnahme auftritt, welche nicht der Ausnahme im except-Block gleicht, wird sie an äußere try-Anweisungen weitergegeben; wenn keine passende try-Anweisung gefunden wird, ist die Ausnahme eine unbehandelte Ausnahme (engl: unhandled exception), und die Programmausführung stoppt mit einer Fehlermeldung wie oben gezeigt.

Eine try-Anweisung kann mehr als einen except-Block enthalten, um somit verschiedene Aktionen für verschiedene Ausnahmen festzulegen. Es wird höchstens ein except-Block ausgeführt. Ein Block kann nur die Ausnahmen behandeln, welche in dem zugehörigen try-Block aufgetreten sind, nicht jedoch solche, welche in einem anderen except-Block der gleichen try-Anweisung auftreten. Ein except-Block kann auch mehrere Ausnahmen gleichzeitig behandeln, dies wird in einem Tupel angegeben:

... except (RuntimeError, TypeError, NameError): ... pass

Der letzte except-Block kann ohne Ausnahme-Name(n) gelassen werden, dies fungiert als Wildcard. Benutze diese Möglichkeit nur sehr vorsichtig, denn dadurch können echte Programmierfehler verdeckt werden! Auf diese Weise kann man sich auch Fehlermeldungen ausgeben lassen und dann die Ausnahme erneut auslösen (sodass der Aufrufer diese Ausnahme ebenfalls behandeln kann):

import sys

try:
    f = open('myfile.txt')
    s = f.readline()
    i = int(s.strip())
except IOError as err:
    print("I/O error: {0}".format(err))
except ValueError:
    print("Konnte Daten nicht in Ganzzahl umwandeln.")
except:
    print("Unbekannter Fehler:", sys.exc_info()[0])
    raise

Die try ... except-Anweisung erlaubt einen optionalen else-Block, welcher, wenn vorhanden, nach den except-Blöcken stehen muss. Er ist nützlich für Code, welcher ausgeführt werden soll, falls der try-Block keine Ausnahme auslöst. Zum Beispiel:

for arg in sys.argv[1:]:
    try:
        f = open(arg, 'r')
    except IOError:
        print('Kann', arg, 'nicht öffnen')
    else:
        print(arg, 'hat', len(f.readlines()), 'Zeilen')
        f.close()

Die Benutzung eines else-Blockes ist besser, als zusätzlichen Code zum try-Block hinzuzufügen. Sie verhindert, dass aus Versehen Ausnahmen abgefangen werden, die nicht von dem Code ausgelöst wurden, welcher von der try ... except-Anweisung geschützt werden soll.

Wenn eine Ausnahme auftritt, kann sie einen zugehörigen Wert haben, das sogenannte Argument der Ausnahme. Ob ein solches Argument vorhanden ist und welchen Typ es hat, hängt vom Typ der Ausnahme ab.

Der except-Block kann einen Variablennamen nach dem Ausnahme-Namen spezifizieren. Der Variablenname wird an eine Ausnahmeinstanz gebunden und die Ausnahme-Argumente werden in instance.args gespeichert. Für die bessere Benutzbarkeit definiert eine Ausnahmeinstanz __str__(), sodass die Argumente direkt ausgegeben werden können, ohne dass .args referenziert werden muss. Man kann außerdem eine Ausnahme instantiieren bevor man sie auslöst, um weitere Attribute nach Bedarf hinzuzufügen:

>>> try:
...    raise Exception('spam', 'eggs')
... except Exception as inst:
...    print(type(inst))    # Die Ausnahmeinstanz
...    print(inst.args)     # Argumente gespeichert in .args
...    print(inst)          # __str__ erlaubt direkte Ausgabe von .args,
...                         # kann aber in Subklassen überschrieben werden
...    x, y = inst.args     # args auspacken
...    print('x =', x)
...    print('y =', y)
...
<class 'Exception'>
('spam', 'eggs')
('spam', 'eggs')
x = spam
y = eggs