Programmieren mit Python

Programmieren
mit Python
© 2003 by Thomas Bruhin, media sonics, 4148 Pfeffingen, Switzerland. All Rights Reserved.

Programmieren mit Python.............................................................................................3
Python: kurz und bündig.................................................................................................5
Python: Werte und Variablen..........................................................................................7
Python: Kommentare, Ein- und Ausgabe ........................................................................8
Python: Datentypen ......................................................................................................10
Python: Ausdrücke und Operatoren ..............................................................................15
Python: Programmfluss ................................................................................................19
Python: Fehlerbehandlung ............................................................................................25
Python: Funktionen und Module...................................................................................28
Python: Datum und Uhrzeit ..........................................................................................31
Python: Filesystemfunktionen.......................................................................................34
Python: Anhang............................................................................................................37
Python: reservierte Wörter............................................................................................38
Python: Vollständige Rangfolge der Operatoren ...........................................................39
Python: Funktionen des Moduls math...........................................................................40
Python: Funktionen des Moduls cmath .........................................................................41
2

Programmieren mit Python
Autor und Dozent: Thomas Bruhin
Dies ist die Begleitwebsite zum Workshop Einstieg in die Programmierung mit Hilfe der
Skriptingsprache Python. Dieser Einstiegworkshop ist für Programmierneulinge gedacht und
setzt keine Programmierkenntnisse voraus. Konzipiert wurde dieser Workshop von Thomas
Bruhin für das Hyperwerk der FHBB.
Warum gerade Python? (und nicht Javascript, PHP,...)
Python ist eine sehr einfach zu erlernende Programmiersprache (korrekt: Skriptingsprache)
und ideal als Einstieg in die Welt der Programmierung geeignet. Trotz ihrer Einfachheit bietet
diese Sprache auch die Möglichkeit, komplexe Programme für vielfältige Anwendungsgebiete
zu schreiben.
Javascript und PHP wurden hingegen für den Einsatz in Webprojekten und speziell der
Webprogrammierung entwickelt und eignen sich weniger für die generelle
Applikationsentwicklung.
Schnelle Anwendungs-Entwicklung
(Auszug aus dem Buch Einstieg in Python von Thomas Theis, Galileo Computing ISBN 3-
89842-227-5)
Python bietet besonders gute Möglichkeiten zur schnellen Entwicklung umfangreicher
Anwendungen, des sogenannten RAD. Python vereint zu diesem Zweck folgende Vorteile:
• Einfache, eindeutige Syntax: Python ist eine ideale Programmiersprache für
Einsteiger. Sie beschränkt sich auf einfache, klare Anweisungen. In anderen
Programmiersprachen werden vielfältige Lösungswege für das gleiche Problem
angeboten (Paradebeispiel: PERL), so dass der Entwickler und speziell der
Programmieranfänger verunsichert wird.
• Klare Strukturen: Ein Entwickler wird in Python gezwungen, in einer gut lesbaren
Struktur zu schreiben. Die Anordnung der Programmzeilen ergibt die logische
Struktur des Programms.
• Wiederverwendung von Code: Die Modularisierung, d.h. die Zerlegung eines
Problems in Teilprobleme und die anschliessende Zusammenführung der Teillösungen
zu einer Gesamtlösung (die Applikation oder das Programm), wird in Python sehr
leicht gemacht. Die vorhandenen Teillösungen können sehr unkompliziert für weitere
Aufgabenstellungen genutzt werden, so dass der Entwickler nach einiger Zeit über
einen umfangreichen Pool an Modulen verfügt.
• Objekt-Bearbeitung: In Python werden alle Daten als Objekte gespeichert. Dies führt
zu einer einheitlichen Daten-Behandlung für Objekte unterschiedlichen Typs.
Andrerseits wird die physikalische Speicherung der Objekte von Python automatisch,
ohne Eingriff des Entwicklers vorgenommen. Er muss sich nicht um die Reservierung
bzw. Freigabe geeigneter Speicherbereiche kümmern.
• Interpreter / Compiler: Python-Programme werden unmittelbar interpretiert, d.h.
ausgeführt (eine Eigenschaft praktisch aller Skriptingsprachen!). Sie müssen nicht erst
kompiliert und gebunden werden, wie dies Code in traditionellen
3

Programmiersprachen wie C, C++ oder Pascal verlangt. Dies ermöglicht einen nicht
zu unterschätzenden häufigen, schnellen Wechsel zwischen Codierungs- und
Testphase.
• Betriebsystem-Unabhängigkeit: Sowohl Programme die von der Kommandozeile
aus bedient werden, als auch Programme mit grafischen Benutzeroberfl&aum;chen
können auf unterschiedlichen Betriebsystemen (Windows, Unix, Mac OS) ohne Neu-
Entwicklung und Anpassung eingesetzt werden.
4

Python: kurz und bündig
Python ist eine Skriptingsprache die immer mehr an Popularität gewinnt. Entwickelt wurde
Python (benannt nach Monty Python) Anfang der 90er Jahre vom Niederländer Guido van
Rossum und wird von ihm und seiner Gefolgschaft gerne als das bessere Perl angesehen. Die
Wahrheit ist, dass das was mit Python gelöst werden kann aber auch genauso gut mit Perl
gelöst werden kann und umgekehrt.
Grosser Unterschied ist jedoch, dass Python neben seinen Skriptingqualitäten vollkommen
objektorientiert konzipiert wurde, d.h. Python ist eine objektorientierte Skriptingsprache.
Diese Objektorientiertheit verhalf der Sprache auch zum Erfolg und sie wird z.B. eingesetzt
um Applikationserver wie Zope oder Groupwaresysteme wie BSCW zu entwickeln.
Python ist Open Source und Freeware und läuft auf sehr vielen Computerplattformen -> der
Sourcecode ist portabel. Python hat sehr viel von der freien Perlform (ist ebenfalls
interpretiert) übernommen, ist handkehrum aber strukturiert wie eine traditionelle
Programmiersprache. Tatsache ist, dass Python den Programmierer zu strukturiertem
Programmieren anleitet.
Sprachdesign (für Programmierer und Geeks):
Python ist eine minimalistische Sprache. Das Referenz Manual gleicht von seinem Umfang
her eher dem von Pascal. Guido van Rossum akkumulierte keine Features, sondern
konzentrierte sich auf wenige Prinzipien:
• Sparsamkeit durch Orthogonalität: Es gibt nur eine begrenzte Zahl von -
leistungsfähigen und kombinierbaren - Konstrukten, Grunddatentypen und
Standardfunktionen.
• Abgestufte Strukturierungsmittel: auf mehreren Ebenen strukturierbar durch Module,
Klassen, Funktionen und Codeblocks.
• Programmkomponenten: dynamische Datenobjekte. Die strukturellen Einheiten von
Programmen sind selbst solche Objekte. Sie lassen sich inspizieren, manipulieren, zur
Laufzeit erzeugen und generell wie andere Daten handhaben.
• Konsistente Erweiterbarkeit: Werkzeuge für spezielle Anwendungsgebiete sind nicht
fest in die Sprache integriert, sondern Erweiterungsmodule realisieren sie; wobei die
vorhandenen Konstrukte und Standardfunktionen auf neue Objektklassen übertragbar
sind.
Die Sparsamkeit der Ausstattung und die abgestufte Struktur machen Python zu einem
akzeptablen Werkzeug des Software-Engineering. Nichts an Python ist grundsätzlich neu. Das
Geniale liegt in einer gelungenen Auswahl von Ideen, die aus zum Teil weit ausserhalb des
Mainstream verlaufenden Entwicklungen stammen. In gewisser Weise bietet Python Lisp
ohne Klammern und Smalltalk ohne die komplexe Objektorientiertheit. Auch die regulären
Ausdrücke, die die Perl-Anhänger so schätzen, stehen (in Form des re-Moduls) zur
Verfügung. Weitere Module bieten Zugang zu wichtigen Internet-Diensten beziehungsweise -
Protokollen der Transport- und Anwendungsebene.
5

Einrückungen:
Eine Besonderheit von Python ist - und dies unterscheidet die Sprache auch von allen anderen
-, dass Blöcke durch Einrückung gekennzeichnet werden. Ein Block ist eine Folge von
zusammengehörenden Anweisungen (Befehle). Die meisten anderen Programmiersprachen
benützen Klammern in irgendeiner Form (meistens geschweifte Klammern), um Blöcke zu
kennzeichnen.
Für Python heisst das nun, dass zusammengehörige Anweisungen auf der gleichen
Einrückungsebene stehen müssen, zum Beispiel:
n = 9
r = 1
while n > 0:
r = r * n
n = n - 1
print "Das war's"
Einsatzbereich:
Neben Internetprogrammierung eignet sich Python auch hervorragend zur Anbindung von
Datenbanken - Module zur Anbindung an die bekanntesten Datenbanken werden mitgeliefert
- für GUI Entwicklungen sowie für Rapid Prototyping.
Aufgrund der sehr guten XML Unterstützung, wird Python auch oft als Bindeglied für die
XML-Datenverarbeitung und Visualisierung genommen.
Python Scripts werden in eigenen Dateien gespeichert (mit Endung .py), im Falle von CGIs
müssen diese ausführbaren Sripts auch noch in einem speziellen Verzeichnis auf dem Server
gespeichert werden -> meist das cgi-bin Verzeichnis. Ebenfalls muss auf dem Server der
Pythoninterpreter installiert sein, denn Pythonskripts werden erst beim Aufruf
abgearbeitet/übersetzt.
Merkmale:
1. Python ist Open Source, gut getestet und wird durch eine aktive Entwicklergemeinde
weiterentwicklet.
2. Basics sind relativ einfach und schnell erlernbar.
3. Sprachkonstruktion zwingt zur strukturierten Programmierung!
4. Objektorientierung: Da Skriptingsprache hervorragend als Einstiegssprache in die
objektorientierte Programmierung geeignet.
5. XML Unterstützung: Hervorragende XML Unterstützung, darum auch gute Wahl
wenn es um die Bearbeitung von XML Datenstrukturen geht.
6. Datenbankanbindung: Datenbankadapter für praktisch alle Datenbanken verfügbar.
7. Webeinsatz: Browserunabhängig, Python kann von jedem Webbrowser dargestellt
werden, solange es der Server unterstützt.
6

Python: Werte und Variablen
Wie jede halbwegs vernünftige Programmiersprache so besitzt auch Python die Möglichkeit
mit Variablen und Zuweisungen zu arbeiten. Der wohl häufigst gebrauchte Befehl in Python
ist die Zuweisung, d.h. wir weisen einer Variablen einen Wert zu.
Variablen sind Platzhalter denen irgendein Wert zugewiesen werden kann, der im Laufe des
Programms auch manipuliert werden kann und auf dessen Inhalt (Wert) wir mit dem
Variablennamen zugreifen können.
Einfacher gesagt: Variablen sind Gefässe in die wir beliebigen Inhalt füllen können. Diesen
Inhalt können wir manipulieren (hinzufügen, wegnehmen etc.).
Variablennamen:
Der Name einer Variablen kann (fast) frei gewählt werden. Es gelten die folgenden Regeln:
• Variablen beginnn mit einem Buchstaben oder dem Unterstrich (_) Zeichen. Darauf
kann eine beliebige Kombination aus Buchstaben, Zahlen oder Unterstrichen folgen.
• Der Name darf nicht mit einer Zahl beginnen!
• Variablennamen dürfen nicht einem reservierten Wort der Programmiersprache
entsprechen.
• Python ist «case sensitive», das heisst es wird zwischen Gross- und Kleinschreibung
unterschieden. Variablennamen, Anweisungen etc. sollten immer genau so
geschrieben werden wie vordefiniert.
Zuweisungen (Assignment):
Eine Variable ist ein Name der einen Wert repräsentiert. Durch die Zuweisung (assigment
statement) wird eine Variable angelegt und ihr ein Wert zugewiesen.
message = "wie geht es dir?"
zahl = 17
pi = 3.14159
Hier haben wir drei Variablen denen jeweils ein anderer Wert (mit anderem Datentyp)
zugewiesen wird. Im ersten Beispiel weisen wir der Variablen message den Wert wie geht
es dir in Form einer Zeichenkette zu. Im zweiten Fall der Variable zahl den (Ganz-)
Zahlwert 17 und im dritten Beispiel der Variablen pi den Fliesskommawert 3.14159
Werte und Typen:
Werte sind der eigentlich Inhalt der in einer Variablen gespeichert wird und sind
logischerwiese Fundamental. Werte können auch vereinfacht als die eigentlichen Daten
angesehen werden die wir verarbeiten wollen, d.h. ohne Werte keine Datenverarbeitung. Und
wo keine Daten sind braucht es auch kein Programm.
Werte können Zahlen, Fliesskommazahlen, Zeichenketten, Objekte etc. sein.
Eine Pythonvariable hat keinen festgelegten Typ und es muss ihr auch kein solcher explizit
zugewiesen werden, es können ihr alle verschiedenen Datentypen zugewiesen werden. Und
im Verlaufe des Programms kann auch der Datentyp des Inhalts gewechselt werden durch
simple Zuweisung eines anderen Werts.
7

Python: Kommentare, Ein- und Ausgabe
Kommentare:
Kommentare sind ein wichtiges Hilfsmittel um Programmcode zu dokumentieren. In Python
werden Kommentare mit dem Hashzeichen # gekennzeichnet, d.h. alles von diesem Zeichen
an bis zum Ende der Zeile gilt als Kommentar und wird nicht ausgeführt.
Als Ausnahme gilt der Fall, wenn das Kommentarzeichen innerhalb einer Zeichenkette steht.
Dann ist es ein Zeichen der Zeichenkette und wird nicht als Kommentar gewertet.
#Zahl 5 der Variablen x zuweisen
x = 5
y = 3 # Zahl 3 der Variablen y zuweisen
blah = "# Das ist kein Kommentar"
Ein- und Ausgabe:
Praktisch jedes Program gibt irgendetwas, z.Bsp. das Resultat einer Berechnung, auf dem
Bildschirm aus. In Python steht uns hierfür die Anweisung print() zur Verfügung, die Text
oder Werte von Variablen auf dem Bildschirm ausgibt.
Um Daten vom Benutzer anzufordern gibt es in Python die zwei Anweisungen:
1. input()
2. raw_input()
Die Funktion input() nimmt nur Zahlenwerte entgegen, die Funktion raw_input() nur
Zeichenketten. Es ist also wichtig, dies bei der Programmentwicklung zu berücksichtigen,
sonst kann es zu unangenehmen Fehlern kommen.
#Umrechnung Euro in CHF
kurs = 1.4865
print "Bitte geben Sie einen Betrag in Euro ein:"
eurobetrag = input()
chfbetrag = kurs * eurobetrag
print "Dies sind in CHF:"
print chfbetrag
Verkettung von Ausgaben:
Die Anweisung print() erlaubt uns auch mehrerer Ausgaben in einer Zeile zu machen. Die
einzelnen Teile der Ausgabe werden durch Kommata voneinander getrennt. Unser
obenstehendes Programm lässt sich also folgendermassen ändern:
#Umrechnung Euro in CHF
kurs = 1.4865
print "Bitte geben Sie einen Betrag in Euro ein:"
eurobetrag = input()
chfbetrag = kurs * eurobetrag
print "Dies sind in CHF:", chfbetrag
Kommentierte Eingabe:
8

Die Funktionen input() und raw_input() können auch noch einen optionalen Parameter
entgegen nehmen. Dabei handelt es sich um eine Zeichenkette, die einen Kommentar zur
Eingabe beinhalten sollte. Dies erspart eine print-Anweisung.
#Umrechnung Euro in CHF
kurs = 1.4865
eurobetrag = input("Bitte geben Sie einen Betrag in Euro ein:")
chfbetrag = kurs * eurobetrag
print "Dies sind in CHF:", chfbetrag
9

Python: Datentypen
Wie wir gesehen haben können Werte/Daten einen Typ haben, z.B. Ganzzahl,
Fliesskommazahl, Zeichenkette etc. Diese Typen nennt man Datentypen.
Die folgenden Datentypen können in Python verwendet werden:
• numerische Konstanten
• sequentielle Datentypen
• None
Numerische Konstanten:
Fünf numerische Typen werden von Python unterstützt:
1. Integer-Werte (Ganzzahlwerte)
2. Long-Integer-Werte
3. Fliesskommazahlen bzw. Dezimalzahlen
4. Oktal- und Hexadezimalzahlen
5. Komplexe Zahlen
Integer Werte:
Bei den Integer-Werten handelt es sich um alle ganzen Zahlen, die im Bereich von -
2147483647 und 2147483647 liegen. Wenn wir Werte verwenden, die diesen Bereich unteroder
überschreiten, oder wenn wir Ausdrücke verwenden, deren Resultat den Bereich verlässt,
dann erhalten wir eine (Python-)Fehlermeldung
Integer-Zahlen dürfen nicht mit der Zahl Null beginnen, da sie sonst als Oktalzahl interpretiert
werden.
Beispiel
123 123
-3456 -3456
2147483647 2147483647
Ergebnis der Auswertung
Long-Integer Werte:
Bei den Long-Integer-Werten handelt es sich ebenfalls um ganzen Zahlen, die jedoch den
Bereich der Integer-Werte verlassen und beliebig gross werden können; nur der verfügbare
Arbeits-Speicher des Rechners bildet eine Grenze. Ein Long-Integer-Wert wird durch
Anfügen des Buchstabens "L" (Klein- oder Grossschreibung erlaubt) an die Zahl erzeugt.
99999999999L
2147483648L
Beispiel
99999999999L
2147483648L
9 * 999999999l 8999999991l
Ergebnis der Auswertung
Fliesskommazahlen:
10

Fliesskommazahlen (auch Gleitkomma- oder Dezimalzahlen genannt) sind positive und
negative reelle Zahlen, deren Kommastelle durch einen Dezimalpunkt zu kennzeichnen ist.
Bei grösseren Werten kann auch der Übersichtlichkeit halber die wissenschaftliche Notation
verwendet werden, d.h. wir können den Buchstaben "e" oder "E" einfügen.
Beispiel
-3.14 -3.14
3.14e-1 0.314
3.14e+10 31400000000.0
4E5 400000.0
4.0e+210 4e+210
Ergebnis der Auswertung
Oktal- und Hexadezimalzahlen:
Oktal- und Hexadezimalzahlen können nicht nur Dezimalzahlen sondern auch Oktal- und
Hexadezimalzahlen in Ausdrücken verwenden, d.h. Zahlen zur Basis 8 oder zur Basis 16.
Oktalzahlen beginnen mit einer Null ("0"), Hexadezimalzahlen beginnen mit "0X" oder "0x".
Beispiel
010 8
05 5
0x10 16
0X15 21
0X2F 47
Ergebnis der Auswertung
Komplexe Zahlen:
Komplexe Zahlen wurden mit Python 1.4 eingeführt und bestehen aus einem Real- und einem
Imaginärteil. In Python sieht eine komplexe Zahl so aus: Realteil+Imaginärteil. Die Zahl wird
von einem "J" oder "j" abgeschlossen. Vor diesem Buchstaben muss auf jeden Fall eine Wert
stehen, sonst wird "j" oder "J" als Variable interpretiert.
Um Berechnung mit komplexen Zahlen durchführen zu könen müssen wir das spezielle
Modul cMath importieren und die Methoden aus diesem Modul anwenden.
Beispiel
6+6j (6+6j)
6.9+0j
1j
(6.9+0j)
1j
Ergebnis der Auswertung
Sequentielle Datentypen:
Python unterstützt vier sogenannte sequentielle Datentypen:
1. Zeichenketten / Strings
11

2. Listen
3. Dictionaries
4. Tupel
Dabei handelt es sich um verschiedenartige Sammlungen von Objekten. Die einzelnen
Elemente dieser Datentypen sind indiziert, das heisst, jedes Element besitzt eine
Positionsnummer. In Python beginnt deren Nummerierung bei Null, wie in den meisten
anderen Programmiersprachen auch. Das erste Element einer Sequenz hat also immer den
Index 0.
Zeichenketten / Strings:
Strings sind Zusammenfassungen von Zeichen zu einer Zeichenkette. Eine Zeichenkette kann
aus mehreren Zeichen, aus nur einem Zeichen aber auch aus keinem Zeichen bestehen. In
einer Zeichenkette kann im Prinzip alles enthalten sein, das sich in irgendeiner Weise in Text
umwandeln lässt.
Zeichenketten sind nicht veränderbare Folge von Zeichen (eigentlich: von Bytes). Einfache
Zeichenkettenkonstanten (short strings) werden durch einfache (') oder doppelte (")
Anführungszeichen eingefasst - das jeweils andere Zeichen kann dann innerhalb des Strings
verwendet werden. Eine leere Zeichenkette wird durch zwei nebeneinanderstehende einfache
(oder doppelte) Anführungszeichen erzeugt. Zeichenketten müssen auf der gleichen Zeile
enden, auf der sie begonnen haben (die Ausnahmenregelung lernen wir noch kennen).
Will man Steuerzeichen oder andere Sonderzeichen in einem String haben, muss man sie mit
einem Backslash (\) maskieren. Diese Escapesequenzen unterliegen folgender Regel:
Maximal 3 Oktalziffern und genau zwei Hexadezimalziffern. Weiterhin können eine Reihe
von Kürzeln für Escapesequenzen verwendet werden (siehe untenstehende Tabelle). In
Unicode-Objekten ist zusätzlich noch die \u-Sequenz und \N-Sequenz erlaubt.
Escapezeichen
\\ Backslash
\'
einfaches Anführungszeichen
\" doppeltes Anführungszeichen
\n Zeilenvorschub
\b Rückschritt
\f Seitenvorschub
\r Wagenrücklauf
\v Vertikaler Tabulator
\a Klingel
12
Bedeutung
\0 ... \7 Oktalwert des Zeichens (maximal drei Ziffern)
\x Hexadezimalwert des Zeichens (zwei Ziffern Hexadezimal)
\u
Unicodewert des Zeichens (4 Hexadezimalzeichen, nur in
Unicodeobjekten erlaubt)
\U Unicodewert des Zeichens (8 Hexadezimalzeichen)
\N{Zeichenname}
Zeichen mit dem angegebenen universal character name, beispielsweise
\N{WHITE SMILING FACE}

Listen:
Eine Liste ist eine veränderbare Sammlung von Objekten verschiedener Datentypen zu einem
Objekt (vergleichbar mit einem Array in anderen Programmiersprachen). Im Gegensatz zu
Zeichenketten können also nicht nur Zeichen in einer Liste vorhanden sein, sondern auch
andere Objekte, wie z.B. Fliesskommazahlen oder auch andere Listen.
Eine Liste wird durch eckige Klammern eingeschlossen ([]); die einzelnen Elemente sind
durch Kommas voneinander getrennt. Listen können geschachtelt werden, d.h. eine Liste
kann eine andere Liste als Element enthalten.
Beispiel
13
Erklärung
[] Leere Liste, die keine Elemente enthält
[1, 3.5, "Zeichenkette",
10]
[1, 3.5, ["Internet",
"Intranet"]]
Dictionaries:
Liste mit 4 Elementen: Integer, Fliesskommazahl, String,
Integer
Liste mit 3 Elementen wobei das dritte Elemente eine weitere
Liste mit Zeichenketten als Elemente ist.
Dictionaries stellen eine Sammlung von Schlüssel- und Wertepaaren dar. Ein Dictionary ist
also eine Liste aus Schlüssen (keys), denen jeweils ein Wert (value) zugewiesen ist. Schlüssel
können numerische Konstanten, Zeichenketten, Tupel, und einige konstante Objekte sein. Als
Wert sind alle in Python gültigen Datentypen zulässig.
Ein Dictionary ist in geschweifte Klammern eingeschlossen; Elemente sind durch Komams
voneinander getrennt:
{ Schlüssel1: Wert1, Schlüssel2:Wert2, Schlüssel3:Wert3 }
Man kann sich Dictionaires wie ein einfaches Wörterbuch vorstellen, in dem ein Element aus
einem Fremdwort (= der Schlüssel) sowie dem zugehörigen Begriff (= der Wert) besteht:
{ house: Hause, coffee:Kaffee, beer:Bier }
Dictionaries können geschachtelt werden, also andere Dictionaries enthalten.
Beispiel
{} Leerer Dictionary
{ 1:'Goethe',
2:'Schiller', 3:5.67}
{ 1:'wow',
2:{'inter':'net'}}
Tupel:
Erklärung
Dictionary mit 3 Elementpaaren
Dictionary mit 2 Elementpaaren wobei das zweite Elemente
einen weitere Dictionary mit einem Elementpaar ist.
Ein Tupel ist eine Sammlung von Objekten verschiedener Datentypen zu einem Objekt. Im
Gegensatz zu einer Liste ist die Folge der Elemente dabei nicht veränderbar. Die Elemente
werden durch Kommas voneinander getrennt, das gesamte Tupel ist in runde Klammern
einzuschliessen.
Beispiel
Erklärung
() Leeres Tupel, das keine Elemente enthält

(1,)
Beispiel
('Oster',
'hase')
Erklärung
Tupel mit einem Element. beachte das zwingend notwendige Komma als
Trennzeichen. Ohne dieses würde der Ausdruck als Zahl gewertet.
Tupel mit 2 (Zeichenketten-) Elementen
(1, 2, 3) Tupel mit drei (Integer-) Elementen
None:
Der Datentyp None hat in Python nur einen einzigen Wert: None. Er dient als Platzhalter für
Variablen, die eigentlich keinen Wert haben sollen. Funktionen, die keinen Wert
zurückgeben, haben implizit None als Rückgabewert. Wenn der interaktive Interpreter einen
Ausdruck auswertet, gibt er ihn nur aus, wenn der Rückgabewert nicht None ist.
14

Python: Ausdrücke und Operatoren
Ein Ausdruck wird duch folgendes Kennzeichen definiert: Er besitzt einen Wert. Im
einfachsten Fall besteht ein Ausdruck lediglich aus einem Literal oder einer Variablen. Dann
entspricht der Wert des Ausdrucks dem Wert des Literals bzw. der Variablen.
Literale und Variablen können aber auch durch Literale und Variablen verknüpft werden.
Dadurch entstehen zusammengesetzte Ausdrücke. Der Wert eines zusammengesetzten
Ausdrucks kann entweder ein Zahlen-, ein Zeichenketten- oder ein Wahrheitswert sein.
Ausdruck Art Wert Typ
7 einfach 7 Zahl
true einfach true Wahrheitswert
-7 zusammengesetzt -7 Zahl
7 + 5 zusammengesetzt 12 Zahl
7 > 5 zusammengesetzt true Wahrheitswert
x = (9 + 12) / 7 zusammengesetzt 3 Zahl
Operatoren:
Operatoren verknüpfen Literale, Variablen oder Teilausdrücke zu grösseren Ausdrücken.
Operatoren unterscheiden sich in der Anzahl der Operatoren
1. Unäre Operatoren: ein Operand
2. Binäre Operatoren: zwei Operanden
3. Ternäre Operatoren: drei Operanden
Arithmetische Operatoren
haben als Operanden Zahlenwerte und liefern ebenfalls einen Zahlenwert als Ergebnis. Bei
Verwendung mehrer arithemtischer Operatoren gilt die Regel: Punkt- vor Strichrechnung,
d.h. Multiplikation und Division werden vor Addition und Subtraktion ausgeführt, bei
gleicher Hierarchiestufe gilt Abarbeitung von links nach rechts.
Operator Syntax Beispiel Wert
Grundrechenarten
+ summand1 + summand2 7 + 4 11
- minuend1 - minuend2 7 - 4 3
* faktor1 * faktor2 7 * 4 28
Division: hier gibt es ein paar Besonderheiten
/ dividend / divisor 7 / 4 1 (!!!!!)
/ dividend / divisor 7 / 4.0 1.75
// dividend // divisor (Restlose Division) 7 // 4 1
ab Python 3.0 wird / zur echten Division umgewandelt d.h. auch bei Ganzzahlendivision wird
ein Rest ausgegeben
15

Operator Syntax Beispiel Wert
/ dividend / divisor 7 / 4 1.75
Modulo: liefert den Rest einer Ganzzahldivision
% dividend % divisor 7 % 4 3
Negation: unärer Operator, der das Vorzeichen eines Zahlenwertes invertiert.
- -operand -(2 + 5) -7
16
-(2 - 5) 3
Identität: unärer Operator, liefert immer den positiven Wert einer Zahl sofern diese positiv ist
ansonsten den negativen Wert.
+ +operand x = 12 -> +x 12
Potenz:
x = -12 -> +x -12
** basis ** faktor 12 ** 6 2985984
Funktionen für Zahlenwerte:
Operator Funktion Beispiel Wert
abs(x) Betrag von x abs(-12) 12
int(x) Umwandlung von x in einen Integerwert int(12.6) 12
long(x) Umwandlung von x in einen Longintegerwert long(12.6) 12L
float(x) Umwandlung von x in eine Fliesskommazahl float(12) 12.0
complex(re,
im)
divmod(x,y)
Umwandlung in eine komplexe Zahl
liefert den ganzzahligen Teil und den ganzzahligen
Rest als Tupel
complex(4,
3)
(4+3j)
divmod(12,5) (2, 2)
pow(x,y) Potenz y zur Basis x pow(12,6) 2985984
Logische Operatoren
Logische Operatoren haben als Operanden Wahrheitswerte und liefern ebenfalls
Wahrheitswerte als Ergebnis. Mit Hilfe der logischen Operatoren UND (AND), ODER (OR)
und NICHT (NOT) können mehrere Bedingungen miteinander verknüpft werden.
Operator Syntax Beispiel Wert
Logisches UND: verknüpft 2 Wahrheitswerte miteinander
and operand1 and operand2 true and true true
Logisches ODER: verknüpft 2 Wahrheitswerte miteinander
true and false
false and true
false and false
or operand1 or operand2 true or true true
false
false
false

Operator Syntax Beispiel Wert
true or false
false or true
false or false
Logisches NICHT: unärer Operator. Invertierung des Wahrheitswertes
true
true
false
not not operand1 not true false
Bitweise Operatoren
Bitweise Operatoren sind vorallem für Low-Level Programmierer interessant, lassen sich
hierdurch doch Zahlenwerte direkt im Speicherberich manipulieren. Python stellt hierzu die
bitweisen Operatoren: AND (&), OR (|), sowie XOR (^) zur Verfügung. Ebenfalls die
Verschieboperatoren >> und operand1 > operand2 "Zehn" > "10" true
= 7 false
true
17

Achtung: Die Verwechslung des Zuweisungsoperatoren = mit dem Vergleichsoperator == ist
die Ursache vieler, schwer zu entdeckender Programmfehler. Vergewissere dich darum
jedesmal, dass du den richtigen Operator ausgewählt hast.
Zeichenketten, Listen und Tupel Operatoren
Operator Funktion Beispiel Wert
= Zuweisung x = 12
+ Konkatenation "Ein" + " Beispiel"
"Ein
Beispiel"
* Wiederholung 2 * "Du" Du Du
in enthalten in 1 in [1,2] 1
not in nicht enthalten in 3 not in [1,2] 1
for ... in
...:
Zählschleife
X[i]
X[i:j]
Indizierung, liefert Element aus X an
der Stelle i (Zählung beginnt bei 0)
Slicing, liefert aus X Unterelement von i
bis j-1 zurück (Zählung beginnt bei 0)
for x in [1,2]:
print "hallo"
x = "hallo"
x[1]
x = "hallo"
x[0:3]
len(s) Länge len("hallo") 5
min(s) kleinstes Element min("hallo") a
max(s) grösstes Element max("hallo") o
abkürzende Schreibweisen bei Zuweisungen:
+=
-=
*=
/=
%=
Arithmetische Zuweisungen
variable += ausdruck
variable -= ausdruck
variable *= ausdruck
variable /= ausdruck
variable %= ausdruck
hallo
hallo
a
hal
v = v + a
v = v - a
v = v * a
v = v / a
v = v % a
+= Zeichenketten-Zuweisung variable += ausdruck v = v + a
18

Python: Programmfluss
In Python werden alle Anweisungen normalerweise in der Reihenfolge, in der sie
aufgeschrieben wurden, bearbeitet. In sehr vielen Situationen ist eine solche lineare
Vorgehensweise aber nicht erwünscht. Dies ist zum Beispiel der Fall, wenn ein bestimmter
Teil des Skripts nur dann ausgeführt werden soll, wenn eine gewisse Bedingung erfüllt ist.
Auch falls ein Teil eines Skripts mehrfach ausgeführt werden soll, muss vom linearen
Programmablauf abgewichen werden.
Python stellt für die bedingte Ausführung das Konstrukt if-else sowie in erweiterter Form
if-elif-else zur Verfügung. Und für die wiederholte Ausführung die Schleifen-Konstrukte
for und while.
Vielfach wird im Zusammenhang mit der Ausgabe von wiederholten Anweisungen - print
Statements innerhalb einer Schleife - auch noch auf die formatierte Ausgabe
zurückgegriffen, welche ich am Ende dieses Abschnitts gerne vorstellen möchte.
Verzweigungen (Bedingte Ausführung)
Zur Steuerung eines Programmablaufs werden häufig Verzweigungen benötigt. Innerhalb des
Programms wird dann aufgrund einer Bedingung entschieden, welcher Zweig des Programms
ausgeführt werden soll.
Bedingungen werden mit Hilfe von Vergleichsoperatoren formuliert.
Einfache Verzweigung:
Sollen bestimmte Abschnitte eines Programms nur unter gewissen Bedingungen (etwa einer
bestimmten Eingabe des Benutzers) ausgeführt werden, stellt uns Python das if-else Konstrukt
zur Verfügung. Im folgenden Beispiel wird untersucht, ob eine Variable grösser als 0 ist.
Wenn dies der Fall ist, so wird ausgegeben: Diese Zahl ist grösser als 0, ansonsten wird
ausgebeben: Dies Zahl ist kleiner als 0
x = 12
if x > 0:
print "Diese Zahl ist grösser als 0"
else:
print "Diese Zahl ist kleiner als 0"
Mehrfache Verzweigung:
In vielen Anwendungsfällen gibt es mehr als zwei Möglichkeiten, zwischen denen
entschieden wird. Dazu wird eine mehrfache Verzweigung benötigt.
Im folgenden Beispiel wird untersucht, ob eine Variable grösser als 0, kleiner als 0 oder
gleich 0 ist und entsprechend kommentiert.
x = 12
if x > 0:
print "Diese Zahl ist grösser als 0"
19

elif x < 0:
print "Diese Zahl ist kleiner als 0"
else:
print "Bingo, diese Zahl ist auf's Loch 0"
Logische Operatoren:
Mit Hilfe der logischen Operatoren können mehrere Bedingungen miteinander verknüpft
werden.
• Eine Bedingung, die aus einer oder mehreren Einzelbedingungen besteht, die mit dem
Operator and verknüpft sind, ergibt wahr, wenn jede der Einzelbedingungen wahr
ergibt.
• Eine Bedingung, die aus einer oder mehreren Einzelbedingungen besteht, die mit dem
Operator or verknüpft sind, ergibt wahr, wenn eine der Einzelbedingungen wahr
ergibt.
• Der Operator not kehrt den Wahrheitswert einer Bedingung um, d.h., eine falsche
Bedingung wird wahr, eine wahre Bedingung wird falsch.
Ein Beispiel:
x = 12
y = 15
z = 18
#Bedingung 1
if xz:
print "y ist nicht die kleinste Zahl"
#Bedingung 3
if not z>y:
print "z ist nicht grösser als y"
else:
print "z ist grösser als y"
Geschachtelte Verzweigung:
Verzweigungen können auch geschachtelt werden. Dies bedeutet, dass eine Verzweigung eine
weitere Unterverzweigung beinhaltet. Ein Beispiel:
x = -6
if x > 0:
print "Diese Zahl ist grösser als 0"
else:
if x < 0:
print "Diese Zahl ist kleiner als 0"
else:
print "Bingo, diese Zahl ist auf's Loch 0"
20

Schleifen
Neben der Verzweigung gibt es noch eine weitere wichtige Struktur zur Steuerung des
Programmablaufs: die Schleife. Mit Hilfe einer Schleife kann man die wiederholte
Ausführung eines Programmschritts ermöglichen. Python stellt uns wie oben erwähnt für die
wiederholte Ausführung die Schleifen-Konstrukte for und while zur Verfügung.
• Man verwendet eine for-Schleife, falls ein Programmschritt für eine regelmässige, zu
diesem Zeitpunkt bekannt Folge von Werten wiederholt ausgeführt werden soll.
• Man verwendet eine while-Schleife, falls sich erst durch Eingaben des Anwenders
ergibt, ob ein Programmschritt wiederholt ausgeführt werden soll.
for-Schleife - Aufbau:
for i in 2, -6, 7.5, 22:
print "Zahl:", i
print "Quadrat:", i*i
Die erste Zeile muss wie folgt gelesen werden: Führe die nachfolgenden eingerückten
Anweisungen für jede Zahl aus der Liste 2, -6, 7.5, 22 aus. Nenne diese Zahl in diesen
Anweisungen i. Natürlich kann auch eine andere Schleifenvariable anstelle i genommen
werden.
Die genannten Zahlen werden zusammen mit einem kurzen Informationstext ausgegeben und
anschliessend quadriert und ebenfalls ausgegeben.
Im dargestellten Fall handelt es sich um eine unregelmässige Liste von Zahlen. Meist werden
Schleifen allerdings für regelmässige Listen von Zahlen genutzt. Dabei erweist sich die
Funktion range() als sehr nützlich:
for i in range(3,11,2):
print "Zahl:", i
print "Quadrat:", i*i
Range heisst übersetzt Bereich. Innerhalb der Klammern von range können bis zu drei
Zahlen stehen (jeweils durch Komma getrennt):
1. erste Zahl: gibt den Beginn des Bereichs an
2. zweite Zahl: gibt das Ende des Bereichs an, d.h die erste Zahl für den die Anweisung
nicht mehr ausgeführt wird.
3. dritte Zahl: gibt den Abstand, die Schrittweite der Schleife an. Die Zahlen, für die die
Anweisungen in unserem Beispiel ausgeführt werden, haben einen Abstand von +2
zueinander.
Kurz und bündig: Die Funktion erzeugt eine regelmässige Liste von ganzen Zahlen.
range() kann mit einem, zwei oder wie bisher gesehen mit drei Parametern aufgerufen
werden. Falls durch die Parameter keine sinnvolle Liste erzeugt werden kann, so wird die
Schleife nicht durchlaufen. Endlosschleifen wie in anderen Programmiersprachen können
nicht erzeugt werden.
Varianten von range():
21

1. Angabe von drei Parametern: Die Liste beginnt beim ersten und endet vor dem
zweiten Parameter, die Schrittweite wird mit dem dritten Parameter angegeben.
2. Angabe von zwei Parametern: Die Liste beginnt beim ersten und endet vor dem
zweiten Parameter, als Schrittweite wird 1 angenommen.
3. Angabe von einem Parameter: Die Liste beginnt bei 0 und endet vor dem angegebenen
Parameter, als Schrittweite wird 1 angenommen.
while-Schleife - Aufbau:
summe = 0
while summe < 50:
eingabe = input("Bitte Zahl eingeben ")
summe += eingabe
print "Zwischensumme: ", summe
Zuerst wird die Variable für die Summe der Zahlen auf 0 gesetzt. Die while-Anweisung leitet
die Schleife ein und beudeutet bei uns: Führe die Anweisungen solange aus als die Eingabe
des Anwenders kleiner als 50 ist. D.h die Schleife wird solange wiederholt bis der Anwender
eine Zahl grösser/gleich 50 eingibt.
Merke: Bei einer while-Schleife wird immer angegeben, unter welchen Bedingungen
wiederholt werden soll und nicht, unter welchen Bedingung beendet werden soll.
gezielte Steuerung der Verarbeitung:
Python bietet uns ein paar Funktionen, um die Iterationen einer Schleife oder die Ausführung
einer Kondition zu beeinflussen.
Die pass-Anweisung:
Die Anweisung pass bewirkt, dass nichts ausgeführt wird. Dies braucht man zum Beispiel
beim Sketching eines Programms das eine Funktion aufruft. Dann definiert man in einer
ersten Phase zuerst den Funktionsnamen, aber noch die nicht die eigentlichen Arbeitsschritte
die diese Funktion ausführen soll. Der Funktionsaufruf kann bereits an der richtigen Stelle
platziert werden, soll aber noch nicht ausgeführt werden. Die Funktionsdefinition beinhaltet
in dem Fall nur die Anweisung pass.
Oder aber wenn das Programm eine einfache oder mehrfache Verzweigung enthält, bei der in
einem bestimmten Zeig nichts ausgeführt werden soll.
# Funktionsdefinition
def QuadraturDesKreises():
pass
QuadraturDesKreises()
# nur ein Zweig interessant
a, b = -12, 6
if a > 0 and b > 0:
pass
22

else:
print "Eine Zahl ist negativ oder 0"
Schleifensteuerung mit break und continue:
Die Anweisungen break und continue bieten weitere Möglichkeiten zur Steuerung von
Schleifen. Die Anweisung break führt zu einem unmittelbaren Abbruch der Schleife. Die
Anweisung continue führt unmittelbar zum nächsten Durchlauf der Schleife, ohne die
restlichen Anweisungen innerhalb einer Schleife zu beachten. Beide werden sinnvollerweise
mit einer Bedingung verbunden und meist bei Sonderfällen eingesetzt.
Im folgenden Beispiel soll der Preis von maximal zehn Tankfüllungen berechnet werden. Der
Benutzer gibt die getankte Literzahl an, das Programm berechnet den Preis und gibt ihn aus.
Falls der Benutzer einen negativen Wert eingibt, wird statt dem Preis eine Fehlermeldung
ausgegeben und bei Eingabe des Werts 0 wird die Schleife vorzeitig beendet.
for i in range(1,11,1):
liter = input(str(i) + ": Wieviele Liter wurden getankt? ")
if liter == 0:
break # Abbruch der Schleife
if liter < 0:
print "Nur positive Werte eingeben"
continue # Zum naechsten Durchlauf
preis = liter * 1.32
print "Die Tankfüllung kostet ", preis
formatierte Ausgabe
Mit Hilfe des Operators % können formatierte Ausgabe-Ausdrücke erzeugt werden. Das
Ergebnis ist eine Zeichenkette, die ganze Zahlen, Zahlen mit Nachkommastellen und andere
Zeichenketten in einer vorbestimmten Form mit der gewünschten Mindestbreite beinhaltet.
Dies wird meist im Zusammenhang mit der Anweisung print benötigt, kann aber auch zur
Ausgabe von Datensätzen fester Länge in einer Datei verwendet werden.
Eine Übersicht:
Formatierung
%i, %o, %x,
%X
%f, %e
Verwendung
Ausgabe von ganzen Zahlen in dezimaler (Integer), oktaler oder
hexadezimaler Form
Ausgabe von Zahlen mit Nachkommastellen, und in Exponentialform
%s Ausgabe von Zeichenketten
%% Ausgabe des Prozentzeichens
- Minuszeichen für linksbündige Ausrichtung anstelle rechtsbündig
Beispiele:
print "ganze Zahlen"
for i in range(2,12,2):
quadrat = zahl * zahl
print "%4i %4i" % (zahl, quadrat)
23

# linksbuendig
print "ganze Zahlen"
for i in range(2,12,2):
quadrat = zahl * zahl
print "%-4i %-4i" % (zahl, quadrat)
# als Fliesskommazahlen
print "als Fliesskommazahlen ausgegeben"
for i in range(2,12,2):
quadrat = zahl * zahl
print "%10.2i %10.2i" % (zahl, quadrat)
24

Python: Fehlerbehandlung
Ein mächtiges Feature das uns Python für die Entwicklung eigener Applikationen zur
Verfügung stellt, ist ein ausgeklügeltes Fehlerbehandlungssystem. Fehler in einem Programm
können immer auftreten, sei diese aufgrund falscher oder fehlerhafter Benutzereingaben,
Systemfehlern, Laufzeitfehler etc. Umso bedenklicher ist es eigentlich dass
Fehlerbehandlungssysteme nur in sehr wenigen Programmiersprachen direkt zur Verfügung
gestellt werden: Java, C++, Python - also die objektorientierten Sprachen - besitzen ein
solches, aber zum Beispiel Perl, C und auch die auf dem WWW meistgenutzte Sprache PHP
besitzen (noch) keines -> PHP wird mit PHP5 ein solches aufweisen.
Im Computerchargon spricht man bei Fehlern von Bugs, wenn ein Fehler während der
Auführung eines Programms auftritt, spricht man von einer Exception (Ausnahme).
Definition von Exceptions:
Eine wunderschöne Definition fand ich im englischen Buch The quick Python Book:
Generating an exception is called raising or throwing an exception.
Detecting a thrown exception, and calling code to act on it, is called catching an exception.
The called code (the code which actually handles the exception) is the exception-handling
code or just exception handler.
In Python steht uns für die Ausnahmenbehandlung die try-except-Klausel zur Verfügung.
Im try-Block listen wir die normalen Programmbefehle auf, im except-Block dann was
gemacht werden muss wenn ein Fehler (eine Ausnahme) passiert.
D.h wir geben Python an, versuche (engl. try) zuerst den normalen Programmteil
durchzuführen, und wenn ein Fehler auftritt führe den Ausnahmenbereich (engl. except) aus.
Programmabbruch verhindern:
Fangen wir zuerst einfach an. Im folgenden Beispiel wollen wir eine
Fehlerbehandlungsroutine einbauen, die uns erlaubt bei fehlerhaften Benutzereingaben das
Programm sanft und mit einem Hinweis zu beenden.
Erinnern wir uns, dass die input-Funktion nur Zahlen entgegennehmen kann, wenn also der
Benutzer Zeichen eingibt, müssen wir dies abfangen und dem Benutzer mitteilen.
try:
eingabe = input("Bitte eine Zahl eingeben: ")
print "Du hast die Zahl", eingabe, "richtig eingegeben"
except:
print "falsche Eingabe"
Zuerst wird versucht der normale Programmteil innerhalb des try-Blocks auszuführen. Ist
dies erfolgreich so wird der except-Block übersprungen. Falls allerdings ein Fehler auftritt,
so wird dieser mit der except-Anweisung abgefangen und alle Befehle die in diesem Block
stehen ausgeführt. Anschliessend läuft das Programm ohne Abbruch zu Ende, da der Fehler
zwar auftrat aber abgefangen wurde.
Beachte: nur die kritische Stelle wird in die Ausnahmebehandlung eingebettet. Man hat die
25

Möglichkeit, unterschiedliche Fehlerarten in spezifischen except-Blöcken abzufangen. Dies
hat den Vorteil, dass die Fehlermeldung präzisiert werden kann.
Fehler abfangen:
Das oben aufgeführte Beispiel ist zwar schon ein wichtiger Schritt zur erfolgreichen
Fehlerbehandlung, aber aus Sicht des Benutzers sicher noch nicht optimal: Nach einer
falschen Eingabe wird er zwar informiert, hat aber keine Möglichkeit seine Eingabe zu
wiederholen. Wir wollen unser Beispiel also erweitern und den Fehler abfangen aber zugleich
dem Benutzer die Möglichkeit zu einer erneuten Eingabe bieten.
fehler = 1
while fehler == 1:
try:
eingabe = input("Bitte eine Zahl eingeben: ")
print "Du hast die Zahl", eingabe, "richtig eingegeben"
fehler = 0
except:
print "falsche Eingabe"
Wir betten unser Programm in eine Schleife, die solange wiederholt wird, bis der Benutzer
eine richtige Eingabe macht. Wir brauchen ein kleines Hilfsmittel in Form einer
Schleifenvariable deren Wert wir ändern sobald die Eingabe richtig war, die
Schleifenbedingung also nicht mehr zutrifft und wir aus dieser ausbrechen können.
Fehler erzeugen:
Wir haben nicht nur die Möglichkeit auf fest eingebaute Fehler zu reagieren, sondern können
auch eigene Fehler erzeugen um in eine Ausnahmenbehandlung zu gelangen. Folgendes
Beispiel erläutert dies, indem wir bei Eingabe einer zu grossen oder zu kleinen Zahl einen
Fehler erzeugen und die Eingabe wiederholen lassen.
fehler = 1
while fehler == 1:
try:
eingabe = input("Bitte eine Zahl zwischen 0 und 1000 eingeben: ")
# Eingabe zu gross oder zu klein
if eingabe > 1000 or eingabe < 0:
raise
fehler = 0
except:
print "falsche Eingabe, bitte wiederholen"
print "Du hast die Zahl", eingabe, "richtig eingegeben"
print "Ende gut alles gut"
Unterscheidung von Ausnahmen:
Bisher wurde geschildert wie ein Programm durch das Abfangen von Fehlern gegen Abstürze
gesichert werden kann. Die Fehler wurden dabei allgemein, d.h. ohne Angabe der Fehlerart
abgefangen.
26

Im folgenden Programm sollen verschiedene Arten von Fehlern spezifisch abgefangen
werden. Damit kann ein Benutzer wesentlich genauer über Fehlerursachen informiert werden.
Wir wollen den Kehrwert einer Zahl ermitteln und auf mehrere mögliche Fehler reagieren:
fehler = 0
while not fehler:
try:
zahl = input("Bitte eine Zahl 0 eingeben: ")
if zahl < 0:
raise StandardError, "Zahl zu klein"
kw = 1.0 / zahl
fehler = 1
except NameError:
print "Fehler: Zeichen zu beginn eingegeben"
except ZeroDivisionError:
print "Fehler: Zahl 0 eingegeben"
except StandardError, e:
print "Fehler: ", e
print "Der Kehrwert von", zahl, "ist", kw
27

Python: Funktionen und Module
Theoretisch könnte ein Programmierer auf die Modularisierung, d.h. die Zerlegung eines
Programms in selbst geschriebene Funktionen, verzichten. Besonders bei der Entwicklung
von grösseren Programmen bieten Funktionen allerdings einige gewichtige Vorteile:
• Umfangreiche Programme können in übersichtliche Teile zerlegt werden.
• Pflege und Wartung von Programmen wird erleichtert.
• Der eigene Programmcode wird verständlicher gegliedert, was vorallem der
Weiterentwicklung zugute kommt.
• Programmteile die nur einmal benötigt werden, müssen nur einmal definiert werden.
• Nützliche Programmteile können in mehreren Programmen verwendet werden.
Vordefinierte Funktionen:
Neben den selbst geschriebenen Funktionen gibt es in Python, wie bei jeder anderen
Programmiersprache auch, eine grosse Menge an nützlichen, vordefinierten Funktionen, die
dem Entwickler bereits viel Arbeit abnehmen können, wie z.B die input()-Funktion. Diese
Funktionen sind entweder fest eingebaut oder über die Einbindung spezifischer Module
verfügbar.
• Jede Funktion hat eine spezielle Aufgabe. Im Fall der Funktion input() ist dies: das
Programm anhalten und eine Eingabe entgegennehmen.
• Wie viele, aber lange nicht alle Funktionen, hat input() einen sogenannten
Rückgabewert, d.h. die Funktion liefert ein Ergebnis an die Stelle des Programms
zurück, von der sie aufgerufen wurden.
Wichtig: Funktionen werden immer am Anfang eines Programms definiert, damit man sie zu
einem späteren Zeitpunkt vom Hauptprogramm aufrufen kann. Ist eine Funktion noch nicht
bekannt wenn sie aufgerufen wird - was meistens der Fall ist wenn man Funktionen nicht am
Anfang definiert - dann kommt es zu unangenehmen Programmfehlern.
Einfache Funktionen:
Einfache Funktionen führen bei ihrem Aufruf immer genau das Gleiche aus.
# Funktionsdefinition
def stern():
for i in range(1,21,1):
print "*",
print
# Hauptprogramm
x = 12
stern() # 1. Aufruf
y = 5
stern() # 2. Aufruf
Eine Funktion wird zuerst einmal mit dem Schlüsselwort def und einem Namen (siehe
Nameskonvention) definiert. Dann folgen die eigentlichen Anweisungen die die Funktion
ausführen soll im eingerückten Codeblock.
28

Eine Funktion schliesslich wird aufgerufen (ausgeführt), indem ihr Name gefolgt von den
runden Klammern notiert wird. Falls Informationen an die Funktion geliefert werden sollen,
so werden diese innerhalb der runden Klammern angegeben.
Funktionen mit einem Parameter:
Bei einem Aufruf können auch Informationen an Funktionen übermittelt werden, so genannte
Parameter. Dies führt im Allgemeinen dazu, dass diese Informationen innerhalb der Funktion
ausgewertet werden und bei jedem Aufruf zu unterschiedlichen Ergebnissen führen.
# Funktionsdefinition
def umrechnung(eurobetrag):
kurs = 1.4865
chfbetrag = kurs * eurobetrag
print "%.2f Euro ergeben %.2f CHF" % (eurobetrag, chfbetrag)
# Hauptprogramm
eingabe = input("Bitte einen Betrag in Euro eingeben: ")
umrechnung(eingabe) # Funktions-Aufruf
Funktionen mit mehreren Parametern:
Eine Funktion kann noch vielseitiger werden, falls man mehrere Parameter definiert und
übermittelt. Dabei ist auf eine übereinstimmende Anzahl und Reihenfolge der Parameter zu
achten. Falls mehrere Parameter verwendet werden, so werden diese sowohl bei Definition als
auch Aufruf durch Kommata voneinander getrennt (Reihenfolge beachten!).
# Funktionsdefinition
def Benutzer(name, alter):
print "Hallo, " + name + ". Lustig, dass wir beide " + str(alter) + "
Jahre alt sind"
# Hauptprogramm
Benutzer("Hans", 40)
Benutzer("Irma", 35)
Funktionen mit Rückgabewert:
Funktionen werden häufig nur zur Berechnung, aber nicht zur Ausgabe der berechneten
Ergebnisse eingesetzt. Die Ausgabe bzw. weitere Verarbeitung soll dem Hauptprogramm oder
der aufrufenden Funktion überlassen werden. Zu diesem Zweck können Funktionen ihre
Ergebnisse als sogenannte Rückgabewerte zurückliefern.
Im Unterschied zu vielen anderen Programmiersprachen können Funktionen in Python mehr
als einen Rückgabewert liefern. Beschränken wir zuerst auf nur einen Rückgabewert.
# Funktionsdefinition
def umrechnung(eurobetrag):
kurs = 1.4865
chfbetrag = kurs * eurobetrag
return chfbetrag
# Hauptprogramm
eingabe = input("Bitte einen Betrag in Euro eingeben: ")
29

swissfraenkli = umrechnung(eingabe) # Funktions-Aufruf
print "%.2f Euro ergeben %.2f CHF" % (eingabe, swissfraenkli)
# zweiter Aufruf
print eingabe, " Euro ergeben ", umrechnung(eingabe), " CHF"
Funktionen mit mehreren Rückgabewerten:
Im Unterschied zu vielen anderen Programmiersprachen können Funktionen in Python mehr
als einen Rückgabewert liefern. Es wird dabei ein Ergebnistupel übergeben.
# Funktionsdefinition
def geom(breite, laenge):
flaeche = breite * laenge
umfang = 2 * (breite * laenge)
return flaeche, umfang
# Hauptprogramm
f, u = geom(3, 7)
print "Fläche:", f
print "Umfang:", u
x = geom(2,5)
print "Fläche:", x[0]
print "Umfang:", x[1]
Lambda (Funktionen):
Lamba bietet eine Möglichkeit für eine verkürzte Funktionsdefinition. Einer solchen Funktion
können Parameter übergeben werden. Sie liefert ihr Ergebnis als einen Ausdruck zurück, der
in der gleichen Zeile stehen muss. In diesem Ausdruck dürfen keine Mehrfachanweisungen,
Ausgaben oder Schleifen vorkommen.
# Funktionsdefinitionen
mal = lambda x,y: x*y
plus = lambda x,y: x+y
# Funktions-Aufrufe
print mal(3,5)
print plus(4,7)
30

Python: Datum und Uhrzeit
Um mit Datum und Uhrzeit innerhalb Python zu arbeiten, benötigen wir das Modul time
Nullpunkt: Auf vielen Betriebssystemen und in vielen Skripting- und Programmiersprachen
gilt der 1. Januar 1970 00:00:00 Uhr als Nullpunkt für die Verarbeitung von Datums- und
Zeitangaben. Die Zeit wird in Sekunden ab diesem Zeitpunkt gerechnet.
aktuelle Zeit ermitteln und ausgeben:
from time import *
# Zeit in Sekunden
print "Zeit in Sekunden: ", time()
# aktuelle, lokale Zeit als Tupel
lt = localtime()
# Entpacken des Tupels, Datum
jahr, monat, tag = lt[0:3]
print "Es ist der %02i.%02i.%04i" % (tag,monat,jahr)
Die Funktion time() liefert die aktuelle Zeit in Sekunden seit dem 1.1.1970.
Die Funktion localtime() ohne Parameter liefert die aktuelle Zeit als Tupel von
Einzelinformationen. Nachfolgend werden diese ausgewertet:
1. die ersten drei Elemente (0 bis 2) liefern Jahr, Monat und Tag
2. die nächsten drei Elemente (3 bis 5) liefern Stunde, Minute und Sekunde
3. das nächste Element (6) stellt den Wochentag von 0 bis 6 bereit. Montag entspricht
dabei der 0, Sonntag der 6.
4. die laufende Nummer des Tages innerhalb eines Jahres wird von Element 7 geliefert.
5. Informationen über den Status der Sommerzeit liefert das letzte Element 8.
strftime():
Noch genauere Informationen liefert die Funktion strftime(). Sie benötigt zwei Parameter:
1. Einen Formatierungsstring für die gewünschte Ausgabe
2. Ein Zeit-Tupel wie dies z.B. von der Funktion localtime() geliefert wird.
Es werden neben allen Angaben der Funktion localtime() folgende zusätzlichen
Informationen bereitsgestellt:
1. Zeit im 12-Stunden-Format, mit Angabe von AM bzw. PM
2. Jahresangabe nur mit 2 Ziffern
3. Name des Wochentags, abgekürzt bzw. ausgeschrieben. Im Unterschied zu
localtime() entspricht aber Sonntag der Zahl 0 (!!!)
4. Name des Monats, abgekürzt bzw. ausgeschrieben.
5. Kalenderwoche des Jahres, bezogen auf zwei verschiedene Systeme (Sonntag oder
Montag als erster Tag der Woche).
6. Angabe der Zeitzone
31

from time import *
lt = localtime()
print strftime("Tag.Monat.Jahr: %d.%m.%Y", lt)
print strftime("Stunde:Minute:Sekunde: %H:%M:%S", lt)
print strftime("im 12h-Format: %I:%M:%S Uhr %p", lt)
print strftime("Datum und Zeit: %c", lt)
print strftime("nur Datum: %x, nur Zeit: %X", lt)
print strftime("Wochentag abgekürzt: %a, ganz: %A, Nr. (Sonntag=0): %w",
lt)
print strftime("Monat abgekürzt: %b, ganz: %B", lt)
print strftime("Tag des jahres: %j", lt)
print strftime("Woche des Jahres, Start bei Sonntag: %U", lt)
print strftime("Woche des Jahres, Start bei Montag: %W", lt)
print strftime("Zeitzone: %Z", lt)
Beliebige Zeitangabe erzeugen:
Zur Erzeugung einer beliebigen Zeitangabe wird die Funktion mktime() genutzt. Sie benötigt
als Parameter ein Tupel mit allen neun Angaben, wie sie auch von localtime() geliefert
werden.
Die Angabe für Wochentag, Tag des Jahres und Sommerzeit kennt man natürlich in den
wenigsten Fällen. Sie können einfach mit 0 besetzt werden, sie werden dennoch automatisch
korrekt ermittelt, wie das folgende Beispiel zeigt:
from time import *
# Zeitangabe erzeugen
millenium = 2000, 1, 1, 0, 0, 0, 0, 0, 0
damals = mktime(millenium)
# Ausgabe
lt = localtime(damals)
print lt
Mit Zeitangaben rechnen:
Zur Berechnung eines Zeitraums, also der Differenz zwischen zwei Zeitangaben, müssen
beide Zeitangaben einzeln erzeugt werden. Anschliessend kann die Differenz in Sekunden
berechnet werden. Daraus kann dann die Differenz in Minuten, Stunden, Tagen etc. berechnet
werden.
from time import *
# Zwei Zeitangaben erzeugen
millenium = 2000, 1, 1, 0, 0, 0, 0, 0, 0
damals = mktime(millenium)
print "Zeit 1:", localtime(damals)
jetzt = 2003, 2, 4, 0, 0, 0, 0, 0, 0
heute = mktime(jetzt)
print "Zeit 2:", localtime(heute)
# Differenz berechnen
print "Differenz:"
32

print
diff_sek = heute - damals
print diff_sek, "Sekunden"
diff_min = diff_sek/60
print diff_min, "Minuten"
diff_std = diff_min/60
print diff_std, "Stunden"
diff_tag = diff_std/24
print diff_tag, "Tage"
Programm anhalten:
Die Funktion sleep() aus dem Modul time ermöglicht das Anhalten eines Programms für
einen bestimmten Zeitraum. Auf einigen Betriebssystemen können dabei nur ganzzahlige
Abstände angegeben werden.
from time import *
# 11 Zeitangaben jeweils mit Pause
for i in range(11):
wert = time()
if i == 0:
startwert = wert
elif i == 10:
endwert = wert
print i, wert
sleep(1.5)
# Durchschnittlicher Abstand
diff = (endwert - startwert) / 10
print "Abstand: ", diff
33

Python: Filesystemfunktionen
Um mit Files und dem Filesystem innerhalb Python zu arbeiten, benötigen wir das Modul os
Filesystemfunktionen:
getcwd()
listdir(curdir)
Funktionsname
path.join('c:','Eigene
Dateien','test')
chdir('foldername')
mkdir('name')
mkdirs('name/subname/subsubname')
rmdir('name')
Konstanten
name
curdir
pardir
Check-Funktionen
path.isdir('pfadangabe')
path.isfile('filename')
path.exists('pfadangabe')
Beschreibung
Aktuelles Verzeichnis anzeigen
Inhalt des aktuellen Verzeichnis auflisten
Pfad aus den angegebenen werten
zusammenstellen
In Verzeichnis 'foldername' wechseln
erstellt Unter-Verzeichnis 'name' im aktuellen
Verzeichnis
erstellt Unter-Verzeichnis 'name' mit 2 (oder
auch mehreren) Unterverzeichnisssen im
aktuellen Verzeichnis
löscht Verzeichnis 'name' aber nur wenn dieses
LEER ist, sonst wird eine Exception ausgelöst
Gibt Name des Betriebssystems aus
aktuelles Verzeichnis in Unix-Notation '.'
übergeordnetes Verzeichnis in Unix-Notation '..'
Gibt true aus wenn 'pfadangabe' ein Pfad ist
sonst false
Gibt true aus wenn 'filename' ein File ist
sonst false
Gibt true aus wenn 'pfadangabe' existiert
sonst false
File-Funktionen:
Beachte: beim Arbeiten mit Files wird nie das File "Direkt" angesprochen sondern immer
über seine zugewiesene Variable, die in diesem speziellen Fall File-Handle(r) heisst.
Funktionsname
open('path/filename',
'mode')
file('path/filename',
'mode')
Beschreibung
File 'filename' im Verzeichnis 'path' im Modus 'mode'
öffnen.
Ab Python 2.2: File 'filename' im Verzeichnis 'path' im
Modus 'mode' öffnen.
simple Modus:
r
34

Funktionsname
filehandle.read()
filehandle.readline()
filehandle.readlines()
Beschreibung
read = nur im Lese-Modus
w
write = nur im Schreib-Modus. Löscht File
komplett bevor geschrieben wird, falls File nicht
vorhanden wird dieses angelegt.
a
append = nur im Schreib-Modus. Schreibt am
Ende des Files weiter, d.h. bestehender Inhalt wird
nicht gelöscht.
Bei diesen Modi muss der Linebreak jeweils explizit
selber geschrieben werden!!
kombinierter Modus:
r+
read and write = im Lese- und Schreib-Modus
w+
write and read = Schreib- und Lese-Modus. Löscht
File komplett bevor geschrieben wird, falls File
nicht vorhanden wird dieses angelegt.
a+
append and read = im Schreib- und Lese-Modus.
Schreibt am Ende des Files weiter, d.h.
bestehender Inhalt wird nicht gelöscht.
Binary Modus (für Files die nicht im Textformat sind):
rb
read = im Lese-Modus
wb
write = im Schreib-Modus. Löscht File komplett
bevor geschrieben wird, falls File nicht vorhanden
wird dieses angelegt.
ab
append = im Schreib-Modus. Schreibt am Ende
des Files weiter, d.h. bestehender Inhalt wird nicht
gelöscht.
Universal newline support:
rU
read = im Lese-Modus. Alle Linebreaks werden
als \n interpretiert.
aU
append = im Schreib-Modus. Schreibt am Ende
des Files weiter, d.h. bestehender Inhalt wird nicht
gelöscht.
Dieser Modus kann nicht für 'w' und '+' verwendet
werden.
Alles aus Filehandle einlesen
eine Zeile einlesen
alles Zeilenweise einlesen
35

Funktionsname
filehandle.close()
filehandle.write()
filehandle.writelines()
löschen und umbenennen:
remove('filename')
rename('filename_orig',
'filename_new')
Check-Funktionen
filehandle.mode
filehandle.closed
Utility-Funktionen
seek(int)
tell()
File(-handle) schliessen
Beschreibung
eine einzelne Zeichenkette in Filehandle schreiben
schreibt eine Liste mit Zeichenketten sequentiell ins File.
Beachte, dass beiden Methoden write() und
writelines() kein Zeilenumbruch am Ende einer Zeile
schreiben -> muss selber hinzugefügt werden!
löscht File 'filename' im aktuellen Verzeichnis
benennt File 'filename_orig' im aktuellen Verzeichnis
in 'filename_new' um
gibt Modus aus, wie das im Filehandle 'filehandle'
referenzierte File geöffnet wurde.
gibt aus, ob das im Filehandle 'filehandle' referenzierte
File geschlossen ist.
filepointer auf beliebige Position innerhalb eines
File(handle) setzen
Gibt Position aus, in der wir uns im File(handle) gerade
befinden.
Beispiel: Ordner erstellen und dann darin File erstellen
from os import *
# Pfad zusammenstellen
mypath = path.join('/', 'Users', 'tbruhin')
chdir(mypath) # in Pfad wechseln
# Verzeichnis erstellen
mkdir('test')
chdir('test') # in Verzeichnis wechseln
# Neues Dokument erstellen
myfile = file('test.txt', 'w') # File-Handle auf File 'test.txt'
erstellen
mystring = "Hello World\n" # Zeichenkette erstellen
myfile.write(mystring) # Zeichenkette in File schreiben
myfile.close() # File schliessen
36

Python: Anhang
• Liste der reservierten Wörter
• Vollständige Rangfolge der Operatoren
• Funktionen des Moduls Math
• Funktionen des Moduls cMath
37

Python: reservierte Wörter
Die hier aufgeführten reservierten Worte der Programmiersprache Python dürfen nicht als
Namen für Variablen, Funktionen, Objekte, Klassen usw. verwendet werden.
and
Wort
assert
break
class
Logisches UND
Zum Testen von Ausdrücken
kurze Erläuterung
Unmittelbares Verlassen einer Schleife
Beginn der Definition einer Klasse
continue Unmittelbares Fortsetzen einer Schleife beim nächsten Durchlauf
def
del
elif
else
except
exec
Beginn der Definition einer Funktion
Löschen eines Objekts
Teilzweig einer (mehrfachen) Verzweigung
Endzweig einer (mehrfachen) Verzweigung
Teil einer Ausnahmebehandlung
Ausführung von Programmcode
finally Teilzweig einer Ausnahmebehandlung
for
from
global
if
import
in
is
lambda
not
or
pass
print
raise
return
try
while
Beginn einer for-Schleife
Teil einer import-Anweisung
Verlegung einer Variablen in den globalen Namensraum
Beginn einer Verzweigung
Import eines Moduls mit seinen Funktionen
Prüfung auf Mitgliedschaft in einer Sequenz
test auf Identität
Anonyme Funktion
Logisches NICHT
Logisches ODER
Platzhalter, führt nichts aus
Ausgabe
Auslösen einer Ausnahmebeandlung
Verlassen einer Funktion, Rückgabe von Werten
Beginn einer Ausnahmebeandlung
Beginn einer while-Schleife
38

Python: Vollständige Rangfolge der Operatoren
Nachfolgende Tabelle listed alle Operatoren in Python in der Reihenfolge der Auswertung.
Operatoren mit der höchsten Priorität stehen am Anfang der Tabelle. Opertoren mit gleicher
Priorität werden innerhalb eines Ausdrucks von links nach rechts ausgewertet
Operator
( ), [ ], { }, ' '
seq[i], seq[i:j], obj.attr,
fct()
+x, -x, ~x
x**y
x*x, x/y, x%y
x+y, x-y
xy
x&y
x^y
x|y
x=y, x is y, x is not y,
x in seq, x not in seq
not x
x and y
x or y
Erläuterung
Erzeugung eines Tupels, einer Liste, eines
Dictionaries, einer Zeichenkette
Indexierung einer Sequenz, Teilbereich einer Sequenz,
Objekt-Eigenschaft, Funktions- oder Methodenaufruf
Unäre Operatoren für positives Vorzeichen, negatives
Vorzeichen, Einer-Komplement
Exponentialrechnung
Multiplikation von Zahlen und Wiederholung von
Zeichenkette, Division, Modulo-Division von Zahlen
und Formatierung von Ausgaben
Addition von zahlen und Verkettung von
Zeichenketten, Subtraktion
Bitweises Verschieben (nach links und rechts)
Bitweises UND
Bitweises exklusives ODER
Bitweises ODER
Vergleichsoperatoren, Test auf Identität, Test auf
Mitgliedschaft in einer Sequenz
Logisches NICHT
Logisches UND
Logisches ODER
39

Python: Funktionen des Moduls math
Tabelle der Trigonometrischen Funktionen:
Funktionsname
acos(z)
asin(z)
atan(z)
atan2(z,n)
cos(z)
cosh(z)
sin(z)
sinh(z)
tan(z)
tanh(z)
ceil(z)
exp(z)
fabs(z)
floor(z)
fmod(a,b)
frexp(z)
Arcus Cosinus von z
Arcus Sinus von z
Arcus Tangens von z
Arcus Tangens von z/n
Cosinus von z
Cosinus Hyperbolicus von z
Sinus von z
Sinus Hyperbolicus von z
Tangens von z
Tangens Hyperbolicus von z
Ergebnis
Aufrundung nächst höhere Zahl von z aus
(Euler'sche Zahl) e hoch z
Betrag von z
Abrundung nächst kleinere Zahl von z aus
a%b, d.h. a modulo b
Ein Tupel, das die positive Mantisse und den Exponenten von z enthält
hypot(a,b) Wurzel (a 2 + b 2 ), Satz des Pythagoras
ldexp(z,i)
log(z)
log10(z)
modf(z)
pow(a,b)
round(z, i)
sqrt(z)
z * 2 hoch i
natürlicher Logarithmus von z
Logarithmus zur Basis 10 von z
Ein Tupe das den gebrochenen und den ganzzahligen Anteil von z enthält
a hoch b
Rundung der Zahl z auf Anzahl i Kommastellen. Wird die Anzahl
Kommastellen weggelassen, dann wird auf die nächst höhere ganze Zahl
gerundet.
Wurzel aus z
Tabelle der Konstanten:
Name
pi
e
Kreiszahl
Euler'sche Zahl e
Bedeutung
40

Python: Funktionen des Moduls cmath
Die Funktionen des Moduls cmath können nur für komplexe Zahlen, nicht für reelle Zahlen
eingesetzt werden. Für relle Zahlen dient das Modul math.
Tabelle der Trigonometrischen Funktionen:
acos(z)
acosh(z)
asin(z)
asinh(z)
atan(z)
atan2(z,n)
cos(z)
cosh(z)
sin(z)
sinh(z)
tan(z)
tanh(z)
Funktionsname
Arcus Cosinus von z
Ergebnis
Arcus Cosinus Hyperbolicus von z
Arcus Sinus von z
Arcus Sinus Hyperbolicus von z
Arcus Tangens von z
Arcus Tangens von z/n
Cosinus von z
Cosinus Hyperbolicus von z
Sinus von z
Sinus Hyperbolicus von z
Tangens von z
Tabelle der restlichen Funktionen:
exp(z)
log(z)
log10(z)
Funktionsname
Tabelle der Konstanten:
pi
e
Name
Tangens Hyperbolicus von z
Kreiszahl p, als komplexe Zahl
(Euler'sche Zahl) e hoch z
natürlicher Logarithmus von z
Ergebnis
Logarithmus zur Basis 10 von z
Euler'sche Zahl e, als komplexe Zahl
Bedeutung
41