Python/Einstieg in Python

Aufruf des Interpreters

Aufruf des interaktiven Python-Interpreters.

$ python

Beenden des Python-Interpreters mit CTRL+D oder mit

>>> exit()

>>> import sys; sys.exit()

Aufruf des Python-Interpreters mit einem Python-Skript.

$ python pythonskript

$ python -c "pythonskript argument"

Unter BSD-ähnlichen Unix-Systemen können Python-Skripte direkt ausführbar gemacht werden, genau wie Shell- Skripte, indem (unter der Annahme, dass der Interpreter in der Variable $PATH ist) zu Beginn des Skriptes gesetzt wird und die Datei ausführbar gemacht wird.

#! /usr/bin/env python

Tritt ein Fehler auf, so gibt der Interpreter eine Fehlermeldung und einen "stack trace" aus. Im interaktiven Modus kehrt er dann zum primären Prompt zurück. Wenn die Eingabe von einer Datei kam, terminiert er mit einem von Null verschiedenen Exit-Status, nachdem der "stack trace" ausgegeben wurde. Einige Fehler sind ausnahmslos fatal und verursachen eine Terminierung mit Exit-Status ungleich Null. Dies gilt für interne Inkonsistenzen und einige Fälle von nicht ausreichendem Hauptspeicher. Alle Fehlermeldungen werden auf die Standard-Fehlerausgabe geschrieben. Die normale Ausgabe von ausgeführten Kommandos wird auf die Standard-Ausgabe geschrieben.

Zahlen

Der Python-Interpreter verhält sich wie ein einfacher Taschenrechner: man kann einen Ausdruck eingeben und er wird dessen Wert ausgeben. Die Operatoren +, -, * und / funktionieren wie in den meisten anderen Sprachen. Klammern können zur Gruppierung verwendet werden.

>>> 2+2
4
>>> # Dies ist ein Kommentar.
...
>>> # Dies ist ein Kommentar.
... 2+2
4
>>> 2+2 # Und ein Kommentar in einer Code-Zeile.
4
>>> (50-5*6)/4
5
>>> # Integer-Division ergibt die untere Ganzzahl:
... 7/3
2
>>> 7/-3
-3

Wie in C wird das Gleichheitszeichen "=" benutzt, um einer Variablen einen Wert zuzuweisen. Der Wert einer Zuweisung wird nicht ausgegeben.

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

Ein Wert kann mehreren Variablen gleichzeitig zugewiesen werden.

>>> x = y = 0 # Setze x und y auf Null.
>>> x
0
>>> y
0

Es können mehreren Variablen gleichzeitig Werte zugeweiesen werden.

>>> x, y = 1,2
>>> x+y
3

Fliesskommazahlen werden voll unterstützt. Operatoren mit gemischten Operandentypen wandeln den Ganzzahl-Operanden nach Fließkomma 1 um.

>>> 4 * 2.5 / 3.3
3.0303030303030303
>>> 7.0 / 2
3.5

Komplexe Zahlen werden unterstützt. Imaginäre Zahlen werden mit dem Suffix "j" oder "J" ausgegeben. Details finden sich in der Dokumentation.

Im interaktiven Modus wird der zuletzt ausgegebene Ausdruck der Variablen "_" zugewiesen, es ist also etwas einfacher, Berechnungen weiterzuführen. Diese Variable sollte aber nur lesend verwendet und ihr kein expliziter Wert zugeweisen werden, da sonst eine unabhängige lokale Variable mit dem gleichen Namen erzeugt würde, welche die eingebaute mit ihrem speziellen Verhalten ausblenden würde. Ein Beispiel:

>>> tax = 17.5 / 100
>>> price = 3.50
>>> price * tax
0.6125
>>> price + _
4.1125
>>> round(_, 2)
4.11

Zeichenketten

Python kann auch Zeichenketten (engl. strings) bearbeiten, die auf verschiedene Weise ausgedrückt werden können. Sie können in einfachen oder doppelten Anführungszeichen stehen.

>>> 'spam eggs'
'spam eggs'
>>> 'doesn\'t'
"doesn't"
>>> "doesn't"
"doesn't"
>>> '"Yes," he said.'
'"Yes," he said.'
>>> "\"Yes,\" he said."
'"Yes," he said.'
>>> '"Isn\'t," she said.'
'"Isn\'t," she said.'

Zeichenketten-Literale können sich auf verschiedene Arten über mehrere Zeilen erstrecken. Zeilenvorschübe können mit rückwärtsgerichteten Schrägstrichen maskiert werden, zum Beispiel:

>>> hello = "This is a rather long string containing\n\
... several lines of text just as you would do in C.\n\
... Note that whitespace at the beginning of the line is\
... significant.\n"
>>> print hello
This is a rather long string containing
several lines of text just as you would do in C.
Note that whitespace at the beginning of the line issignificant.

Zeichenketten können auch innerhalb eines Paares von dreifachen Anführungszeichen """ oder ''' auftreten. Das Zeilenende (engl. EOL, end-of-line) muss nicht maskiert werden, wenn man dreifache Anführungszeichen verwendet, es taucht aber in der Zeichenkette selbst auf.

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

Der Interpreter gibt das Ergebnis von Zeichenketten-Operationen genauso aus, wie es für die Eingabe verwendet würde: in Anführungszeichen und unter Voranstellung von rückwärtsgerichteten Schrägstrichen für Anführungszeichen und andere lustige Zeichen, um den exakten Wert anzuzeigen. Eine Zeichenkette steht in doppelten Anführungszeichen, wenn sie einzelne, aber keine doppelten Anführungszeichen enthält, sonst steht sie in einzelnen Anführungszeichen. Die später beschriebene print-Anweisung kann benutzt werden, um Zeichenketten ohne Anführungszeichen oder Maskierungen auszugeben. Zeichenketten können mit dem Operator "+" aneinandergefügt (zusammengeklebt) und mit "*" vervielfältigt werden.

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

Zwei Zeichenketten-Literale nebeneinander werden automatisch aneinandergefügt. Die obere Zeile hätte man auch schreiben können als "word = 'Help' 'A'". Das funktioniert nur mit zwei Zeichenketten-Literalen, nicht mit beliebigen Zeichenketten-Ausdrücken:

>>> import string
>>> 'str' 'ing' # Das funktioniert.
'string'
>>> string.strip('str') + 'ing' # Das funktioniert.
'string'
>>> string.strip('str') 'ing' # Das funktioniert nicht.
  File "<stdin>", line 1
    string.strip('str') 'ing'
                            ^
SyntaxError: invalid syntax

Zeichenketten können indiziert werden. Wie in C hat das erste Zeichen den Index 0. Es gibt keinen eigenen Datentyp für ein einzelnes Zeichen. Ein Zeichen ist einfach eine Zeichenkette der Länge eins. Teilzeichenketten können mit der Teilbereichs-Notation spezifiziert werden: zwei Indizes, getrennt durch einen Doppelpunkt (das Zeichen am zweiten Index gehört nicht mehr dazu).

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

Im Gegensatz zu Zeichenketten in C können Zeichenketten in Python nicht verändert werden. Die Zuweisung an eine durch einen Index angegebene Position in der Zeichenkette führt zu einem Fehler.

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

Dagegen ist es sehr einfach und effizient, eine neue Zeichenkette mit dem kombinierten Inhalt zu erzeugen.

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

Teilbereiche haben sinnvolle Voreinstellungen. Ein ausgelassener erster Index wird als Null, ein ausgelassener zweiter als die Länge der Zeichenkette interpretiert.

>>> word[:2] # Die ersten beiden Zeichen.
'He'
>>> word[2:] # Alles ausser den ersten beiden Zeichen.
'lpA'

Dies ist eine nützliche Invariante von Teilbereichs-Operationen: "s[:i] + s[i:]" ergibt "s".

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

Ungültige Teilbereiche werden anständig behandelt: ein Index, der zu gross ist, wird mit der Zeichenkettenlänge ersetzt, eine obere Grenze, die kleiner als die untere ist, ergibt eine leere Zeichenkette.

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

>>> word[2:1]

Indizes dürfen negativ sein. Es wird dann vom rechten Rand der Zeichenkette aus gezählt. "-0" allerdings ist identisch mit "0", wird also nicht von rechts gezählt!

>>> word[-1] # Das letzte Zeichen.
'A'
>>> word[-2] # Das vorletzte Zeichen.
'p'
>>> word[-2:] # Die letzten beiden Zeichen.
'pA'
>>> word[:-2] # Alles ausser den beiden letzten Zeichen.
'Hel'
>>> word[-0] # (Da -0 gleich 0 ist.)
'H'

Negative Bereichsindizes, die ausserhalb des erlaubten Bereichs liegen, werden abgeschnitten. Das sollte aber nicht bei ein-elementigen (Nicht-Bereichs-)Indizes versucht werden.

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

Am einfachsten kann man sich die Funktionsweise von Teilbereichen merken, indem man sich vcorstellt, dass die Randindizes zwischen die Zeichen zeigen, wobei die linke Kante des ersten Zeichens mit "0" bezeichnet wird. Dann hat die rechte Kante des letzten Zeichens von "n" Zeichen den Index "n". Die obere Zahlenreihe bezeichnet die Positionen der Indizes 0 bis 5 in der Zeichenkette, die untere entspricht den jeweiligen negativen Indizes. Der Bereich von "i" bis "j" besteht aus allen Zeichen zwischen den mit "i" und "j" markierten Kanten.

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

Für nicht-negative Indizes ist die Länge des Teilbereichs gleich der Differenz der Indizes, falls beide innerhalb der erlaubten Grenzen liegen. So ist etwa die Länge von "word[1:3]" gleich "2".

Die eingebaute Funktion "len()" ergibt die Länge einer Zeichenkette.

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

Unicode-Zeichenketten

Ab Python 2.0 steht der neue Datentyp "Unicode-Objekt" zur Verfügung, mit dem Unicode-Daten gespeichert und verändert werden können.

Erzeugung einer Unicode-Zeichenkette. Der kleingeschriebene Buchstabe "u" gibt dabei an, dass eine Unicode-Zeichenkette erzeugt werden soll.

>>> u'Hello World!'
u'Hello World!'

Soll die Zeichenkette Sonderzeichen enthalten, so kann dies mit Unicode-Maskierungscodes erreicht werden. Im Beispiel gibt die Maskierungssequenz (engl. escape sequence) "\u0020" an, dass das Unicode-Zeichen mit der Ordnungszahl 0x0020 (das Leerzeichen) an der angegebenen Stelle stehen soll.

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

Andere Zeichen werden interpretiert, indem ihre jeweiligen Nummernwerte direkt als Unicode-Nummer verwendet werden. Wird mit Zeichenketten-Literalen die in vielen westlichen Ländern verwendete Standard-Codierung Latin-1 umgangen, so ist es gut zu wissen, dass die unteren 256 Unicode-Zeichen mit den 256 Zeichen der Standard-Codierung Latin-1 identisch sind.

Durch Voranstellen des kleingeschriebenen Buchstabens "r" verwendet Python die Roh-Unicode-Maskierung. Dann wird die obige "\uXXXX"-Umwandlung nur dann angewendet, wenn eine ungerade Anzahl von Rückwärtsschrägstrichen vor dem kleinen "u" steht. Der Roh-Modus ist vor allem nützlich, wenn man wie z. B. in regulären Ausdrücken eine Menge von rückwärtsgerichtetetn Schrägstrichen eingeben muss.

>>> ur'Hello\u0020World !'
u'Hello World !'
>>> ur'Hello\\u0020World !'
u'Hello\\\\u0020World !'

Python bietet zusätzlich eine ganze Reihe weiterer Möglichkeiten, um aus einer bekannten Codierung Unicode-Zeichenketten. Die eingebaute Funktion "unicode()" bietet einen Zugang zu allen registrierten Unicode-Codecs . Einige der bekannteren Codierungen, die von diesen Codecs konvertiert weren können, sind Latin-1, ASCII, UTF-8 und UTF-16. Die beiden letzten sind Codierungen mit variabler Länge, die jedes Unicode-Zeichen in einem oder mehreren Bytes speichern. Die voreingestellte Codierung ist normalerweise auf ASCII gesetzt, die Zeichen von 0 bis 127 weitergibt und alle anderen Zeichen mit einem Fehler zurückweist. Wenn ein Unicode-String ausgegeben, in eine Dateien abspeichert oder mit "str()" konvertiert wird, findet die Umwandlung mit dieser voreingestellten Codierung statt.

>>> u"abc"
u'abc'
>>> str(u"abc")
'abc'
>>> u"äöü"
u'\xe4\xf6\xfc'
>>> str(u"äöü")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-2: ordinal not in range(128)

Um eine Unicode-Zeichenkette in eine 8-Bit-Zeichenkette mit einer bestimmten Codierung umzuwandeln, stellen Unicode-Objekte die Methode "encode()" zur Verfügung, die ein Argument erwartet, den Namen der Codierung. Dabei werden Namen mit kleinen Buchstaben bevorzugt.

>>> u"äöü".encode('utf-8')
'\xc3\xa4\xc3\xb6\xc3\xbc'

Liegen die Daten in einer bestimmten Codierung vor und soll daraus die entsprechende Unicode-Zeichenkette erzeugt werden, so kann dazu die Funktion "unicode()" mit dem Namen der Codierung als zweitem Argument verwendet werden.

>>> unicode('\xc3\xa4\xc3\xb6\xc3\xbc', 'utf-8')
u'\xe4\xf6\xfc'

Listen

Python kennt eine Anzahl von zusammengesetzten Datentypen, die zur Gruppierung anderer Werte verwendet werden. Der vielseitigste dieser Typen ist die Liste, die als Liste von durch Kommata getrennten Werten (Elementen) innerhalb von eckigen Klammern steht. Listenelemente müssen nicht alle vom selben Typ zu sein.

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

Listen-Indizes beginnen bei 0 und es können Teilbereiche von Listen gebildet und Listen zusammengefügt werden.

>>> 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] + ['Boe!']
['spam', 'eggs', 100, 'spam', 'eggs', 100, 'spam', 'eggs', 100, 'Boe!']

Im Gegensatz zu den unveränderlichen Zeichenketten ist es möglich, einzelne Elemente von Listen zu ändern.

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

Ebenso ist die Zuweisung an Teilbereiche möglich, was sogar die Länge der Liste verändern kann.

>>> a[0:2] = [1, 12] # Ersetze einige Elemente
>>> a
[1, 12, 123, 1234]
>>> a[0:2] = [] # Entferne einige Elemente
>>> a
[123, 1234]
>>> a[1:1] = ['bletch', 'xyzzy'] # Füge einige Elemente ein
>>> a
[123, 'bletch', 'xyzzy', 1234]
>>> a[:0] = a # Füge (eine Kopie von) sich selbst am Anfang ein
>>> a
[123, 'bletch', 'xyzzy', 1234, 123, 'bletch', 'xyzzy', 1234]

Die eingebaute Funktion "len()" gilt auch für Listen und gibt die Anzahl der enthaltenen Elemente an.

>>> len(a)
8

Listen können auch verschachtelt werden - es können also Listen erzeugt werden, die andere Listen enthalten. Im Beispiel ist zu beachten, dass "p[1]" und "q" wirklich dasselbe Objekt bezeichnen!

>>> q = [2, 3]
>>> p = [1, q, 4]
>>> len(p)
3
>>> p[1]
[2, 3]
>>> p[1][0]
2
>>> p[1].append('xtra') # Siehe Abschnitt 5.1
>>> p
[1, [2, 3, 'xtra'], 4]
>>> q
[2, 3, 'xtra']