 |
 |
 |
Das Python-Tutorium |  |
 |
|
|
|
|
Das Python-Tutorium | |
|
|
In den folgenden Beispielen unterscheiden sich Ein- und Ausgabe durch die An- oder Abwesenheit von Prompts (">>>" und "..."). Um das jeweilige Beispiel zu wiederholen, müssen Sie alles hinter dem Prompt eingeben, wenn ein solcher da ist. Zeilen ohne Prompt stammen vom Interpreter. Man beachte, daß ein sekundärer Prompt ("...") in einer Zeile allein bedeutet, daß Sie eine Leerzeile eingeben müssen. Dies ist erforderlich, um ein Kommando über mehrere Zeilen zu beenden.
Viele der Beispiele in diesem Tutorium, selbst die, die interaktiv eingegeben werden, beinhalten Kommentare. Kommentare in Python beginnen mit einem Doppelkreuz-Zeichen, "#", und gelten bis zum Zeilenende. Ein Kommentar kann am Zeilenanfang auftreten, oder nach Leerzeichen oder Code, aber nicht in einem String-Literal. Ein Doppelkreuz-Zeichen in einem String-Literal ist lediglich ein Doppelkreuz.
Einige Beispiele:
# Dies ist der erste Kommentar.
SPAM = 1 # Dies ist der zweite.
# ... Und nun ein dritter!
STRING = "# Dies ist kein Kommentar."
Probieren wir ein paar einfache Python-Kommandos aus. Starten Sie den Interpreter und warten Sie bis zum primären Prompt, ">>>"! (Es sollte nicht lange dauern.)
Der Interpreter verhält sich wie ein einfacher Taschenrechner: man kann einen Ausdruck eingeben und er wird dessen Wert ausgeben. Die Syntax von Ausdrücken ist simpel: die Operatoren +, -, * und / funktionieren wie in den meisten anderen Sprachen (z.B. Pascal oder C). Klammern können zur Gruppierung verwendet werden.
>>> 2+2 4 >>> # 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 Gleich-Zeichen ("=") benutzt, um einen Wert einer Variablen 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 = z = 0 # Setze x, y und z auf Null. >>> x 0 >>> y 0 >>> z 0
Es gibt volle Unterstützung für Fließkommazahlen. Operatoren mit gemischten Operandentypen konvertieren den Ganzzahl-Operanden nach Fließkomma 3.1:
>>> 4 * 2.5 / 3.3 3.0303030303 >>> 7.0 / 2 3.5
Komplexe Zahlen werden auch unterstützt. Imaginäre Zahlen werden mit dem Suffix "j" oder "J" ausgegeben. Komplexe Zahlen mit einem Realteil ungleich Null werden als "(real+imagj)" ausgegeben und können mit der Funktion "complex(real, imag)" erzeugt werden.
>>> 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
Die Konvertierungsfunktionen nach Fließkomma- und Ganzzahl (float(), int() und long()) funktionieren nicht für komplexe Zahlen - es gibt keine korrekte Möglichkeit, eine komplexe Zahl in eine reelle zu konvertieren. Man verwende abs(z), um ihren Betrag (als Fließkommazahl) oder z.real, um ihren Realteil zu erhalten.
>>> a=1.5+0.5j >>> float(a) Traceback (innermost last): File "<stdin>", line 1, in ? TypeError: can't convert complex to float; use e.g. abs(z) >>> a.real 1.5 >>> abs(a) 1.58113883008
Im interaktiven Modus wird der zuletzt ausgegebene Ausdruck der Variablen _ zugewiesen. Das bedeutet, wenn man Python als Taschenrechner benutzt, ist es etwas einfacher, Berechnungen weiterzuführen, z.B.:
>>> tax = 17.5 / 100 >>> price = 3.50 >>> price * tax 0.6125 >>> price + _ 4.1125 >>> round(_, 2) 4.11
Diese Variable sollte von der Benutzerin nur lesend verwendet werden. Weisen Sie ihr keinen Wert explizit zu - Sie würden eine unabhängige lokale Variable mit dem gleichen Namen erzeugen, die die eingebaute mit ihrem speziellen Verhalten ausblendet.
Abgesehen von Zahlen kann Python auch Strings (Zeichenketten) manipulieren, 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.'
String-Literale können sich auf verschiedene Arten über mehrere Zeilen erstrecken. Zeilenvorschübe können mit Rückwärts-Schrägstrichen maskiert werden, z.B.:
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
was folgendes ausgeben würde:
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 is significant.
Strings können auch innerhalb eines Paares von dreifachen
Anführungszeichen """ oder ''' auftreten.
Das Zeilenende (engl. EOL) muß nicht maskiert werden, wenn
man dreifache Anführungszeichen verwendet, es taucht jedoch
im String selbst auf:
print """
Usage: thingy [OPTIONS]
-h Display this usage message
-H hostname Hostname to connect to
"""
erzeugt die folgende Ausgabe:
Usage: thingy [OPTIONS] -h Display this usage message -H hostname Hostname to connect to
Der Interpreter gibt das Resultat von String-Operationen genauso aus, wie es für die Eingabe verwendet würde: in Anführungszeichen und unter Voranstellung von Rückwärts-Schrägstrichen für Anführungszeichen und andere lustige Zeichen, um den exakten Wert anzuzeigen. Ein String steht in doppelten Anführungszeichen, wenn er einzelne, aber keine doppelten Anführungszeichen enthält, sonst steht er in einzelnen Anführungszeichen. Die später beschriebene print-Anweisung kann benutzt werden, um Strings ohne Anführungszeichen oder Maskierungen auszugeben.
Strings können mit dem Operator + aneinandergefügt (zusammengeklebt) und mit * vervielfältigt werden.
>>> word = 'Help' + 'A' >>> word 'HelpA' >>> '<' + word*5 + '>' '<HelpAHelpAHelpAHelpAHelpA>'
Zwei String-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 String-Literalen, nicht mit beliebigen String-Ausdrücken:
>>> 'str' 'ing' # <- Das ist ok.
'string'
>>> string.strip('str') + 'ing' # <- Das ist ok.
'string'
>>> string.strip('str') 'ing' # <- Das ist ungueltig.
File "<stdin>", line 1
string.strip('str') 'ing'
^
SyntaxError: invalid syntax
Strings 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 ein String der Länge eins. Wie in der Sprache Icon können Teilstrings 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'
Teilbereiche haben sinnvolle Voreinstellungen. Ein ausgelassener erster Index wird als Null, ein ausgelassener zweiter als die Länge des Strings 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 groß ist, wird mit der Stringlänge ersetzt, eine obere Grenze, die kleiner als die untere ist, ergibt einen leeren String.
>>> word[1:100] 'elpA' >>> word[10:] '' >>> word[2:1] ''
Indizes dürfen negativ sein. Es wird dann vom rechten Rand des Strings aus gezählt, z.B.:
>>> 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'
Vorsicht aber bei -0: es ist identisch mit 0, zählt also nicht von rechts!
>>> word[-0] # (Da -0 gleich 0 ist.) 'H'
Negative Bereichsindizes, die außerhalb des erlaubten Bereichs liegen, werden abgeschnitten, aber versuchen Sie das nicht bei ein-elementigen (Nicht-Bereichs-) Indizes:
>>> word[-100:] 'HelpA' >>> word[-10] # Fehler. Traceback (innermost last): File "<stdin>", line 1 IndexError: string index out of range
Am besten kann man sich merken, wie Teilbereiche funktionieren, indem man sich denkt, daß 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, z.B.:
+---+---+---+---+---+ | H | e | l | p | A | +---+---+---+---+---+ 0 1 2 3 4 5 -5 -4 -3 -2 -1
Die obere Zahlenreihe bezeichnet die Positionen der Indizes 0...5 im String, 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.
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 z.B. die Länge von word[1:3] gleich 2.
Die eingebaute Funktion len() ergibt die Länge eines Strings:
>>> s = 'supercalifragilisticexpialidocious' >>> len(s) 34
Python kennt eine Anzahl von zusammengesetzten Datentypen, die verwendet werden, um andere Werte zu gruppieren. Der vielseitigste ist die Liste, die als Liste von durch Kommata getrennten Werten (Elementen) innerhalb von eckigen Klammern steht. Listenelemente brauchen nicht alle vom gleichen Typ zu sein.
>>> a = ['spam', 'eggs', 100, 1234] >>> a ['spam', 'eggs', 100, 1234]
Genau wie String-Indizes beginnen Listen-Indizes bei 0, und man kann Teilbereiche von Listen bilden, Listen zusammenfügen, und so weiter:
>>> 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 Strings, die unveränderlich sind, 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]
Die Zuweisung an Teilbereiche ist ebenso möglich, und das kann sogar die Länge der Liste verändern:
>>> # Ersetze einige Elemente: ... a[0:2] = [1, 12] >>> a [1, 12, 123, 1234] >>> # Entferne einige: ... a[0:2] = [] >>> a [123, 1234] >>> # Fuege einige ein: ... a[1:1] = ['bletch', 'xyzzy'] >>> a [123, 'bletch', 'xyzzy', 1234] >>> a[:0] = a # Fuege (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:
>>> len(a) 8
Es ist möglich, Listen zu verschachteln (Listen zu erzeugen, die andere Listen enthalten), z.B.:
>>> 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']
Man beachte, daß p[1] und q wirklich dasselbe Objekt bezeichnen! Wir werden auf die Objekt-Semantik später zurückkommen.
Natürlich können wir Python für kompliziertere Dinge verwenden, als nur, um zwei und zwei zu addieren. Zum Beispiel können wir einen ersten Teil der Fibonacci-Folge wie folgt schreiben:
>>> # Fibonacci-Reihe: ... # Die Summe zweier Elemente ergibt das naechste. ... a, b = 0, 1 >>> while b < 10: ... print b ... a, b = b, a+b ... 1 1 2 3 5 8
Dieses Beispiel demonstriert mehrere neue Eigenschaften.
>>> i = 256*256 >>> print 'The value of i is', i The value of i is 65536
Ein Komma am Zeilenende verhindert nach der Ausgabe den Sprung in die neue Zeile:
>>> a, b = 0, 1 >>> while b < 1000: ... print b, ... a, b = b, a+b ... 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
Man beachte, daß der Interpreter eine neue Zeile einfügt, bevor er den nächsten Prompt ausgibt, falls die letzte Zeile nicht leer war.
|
|
|
Das Python-Tutorium | |
|
|