Das Python Praxisbuch

open source library
Das Python Praxisbuch
Open Source Software wird gegenüber kommerziellen Lösungen immer wichtiger.
Addison-Wesley trägt dieser Entwicklung Rechnung mit den Büchern der Open Source
Library. Administratoren, Entwickler und User erhalten hier professionelles Know-how,
um freie Software effizient einzusetzen. Behandelt werden sowohl Themen wie Betriebssysteme, Netzwerke und Sicherheit als auch Programmierung.
Eine Auswahl aus unserem Programm:
Diese Neuauflage wurde auf die Debian GNU/Linux-Version 4 »Etch«
hin aktualisiert und überarbeitet. Sie wendet sich an Nutzer, die vielleicht schon eine Linux-Distribution ausprobiert haben, aber dennoch
eine grundlegende Einführung benötigen. Autor Frank Ronneburg
bietet genau das: einen Einstieg in alle Bereiche der täglichen Arbeit
mit Debian – von der Installation auf verschiedensten Plattformen
über Netzwerkeinsatz, Office- und Grafikanwendungen bis hin zu
Multimedia. Ein Schwerpunkt des Buchs liegt auf der Debian-eigenen
Paketverwaltung apt-get.
Frank Ronneburg
Debian GNU/Linux 4-Anwenderhandbuch
ISBN 978-3-8273-2523-5
768 Seiten
Euro 49,95 (D), 51,40 (A)
Der aktualisierte Nachdruck der 8. Auflage preisgünstig
als Studentenausgabe mit 3 DVDs: Fedora 9, openSUSE 11
(32/64-Bit), Ubuntu 8.04 LTS »Hardy Heron«
Michael Kofler
Linux
ISBN 978-3-8273-2752-9
1344 Seiten
Euro 39,95 (D), 41,10 (A)
We nn ein Buch den Aufstieg von Linux im deutschsprachigen
Raum begleitet hat, dann dieses: Michael Koflers »Linux«-Buch,
auch schlicht »der Kofler« genannt. Seit mehr als zehn Jahren gilt
dieses Buch als DAS Standardwerk für Linux-Einsteiger und
Anwender: Es richtet sich an alle, die ihr Betriebssystem nicht
nur einsetzen, sondern auch hinter die Kulissen blicken möchten.
Das Buch ist in acht Teilen gegliedert:
1. Einführung und Installation: Gnome, KDE 4
2. Linux im Büro: Webbrowser, Email-Clients, OpenOffice.org,
Digitalkameras, Scanner, Bildverwaltung, Gimp 2.4, Audio
und Video
3. Unix/Linux-Werkzeuge: Prozessverwaltung, Dateiverwaltung,
Netzwerk-Tools, Vim, bash (Shell)
4. Systemkonfiguration/-Administration und Entwicklung:
Software- und Paketverwaltung, Bibliotheken, Java und Mono,
X, Administration des Dateisystems, Kernel und Module
5. Netzwerk- und Server-Konfiguration: LAN, WLAN, VPN,
Modem, ISDN, ADSL, Internet-Gateway, Masquerading, DHCP,
Nameserver, Firewall, SELinux, AppArmor, Apache, PHP,
MySQL, FTP, SSH, CUPS, Samba, NFS
6. Wine, Xen, VMware & Co.
7. Distributionen: Details zu Debian/GNU Linux 4.0, Fedora 9,
Knoppix 5.3, Red Hat Enterprise Linux 5, openSUSE 11 und
Ubuntu 8.04
8. Referenz: Thematisch, alphabetisch
open source library
Farid Hajji
Das Python
Praxisbuch
Der große Profi-Leitfaden
für Programmierer
An imprint of Pearson Education
München • Boston • San Francisco • Harlow, England
Don Mills, Ontario • Sydney • Mexico City
Madrid • Amsterdam
Bibliografische Information der Deutschen Nationalbibliothek
Die Deutsche Nationalbibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie;
detaillierte bibliografische Daten sind im Internet über http://dnb.d-nb.de abrufbar.
Die Informationen in diesem Produkt werden ohne Rücksicht auf einen eventuellen Patentschutz
veröffentlicht.
Warennamen werden ohne Gewährleistung der freien Verwendbarkeit benutzt.
Bei der Zusammenstellung von Texten und Abbildungen wurde mit größter Sorgfalt vorgegangen.
Trotzdem können Fehler nicht ausgeschlossen werden.
Verlag, Herausgeber und Autoren können für fehlerhafte Angaben und deren Folgen weder eine
juristische Verantwortung noch irgendeine Haftung übernehmen.
Für Verbesserungsvorschläge und Hinweise auf Fehler sind Verlag und Herausgeber dankbar.
Alle Rechte vorbehalten, auch die der fotomechanischen Wiedergabe und der Speicherung in
elektronischen Medien.
Die gewerbliche Nutzung der in diesem Produkt gezeigten Modelle und Arbeiten ist nicht zulässig.
Fast alle Hardware- und Softwarebezeichnungen und weitere Stichworte und sonstige Angaben, die in
diesem Buch verwendet werden, sind als eingetragene Marken geschützt. Da es nicht möglich ist, in allen
Fällen zeitnah zu ermitteln, ob ein Markenschutz besteht, wird das ® Symbol in diesem Buch nicht
verwendet.
Umwelthinweis:
Dieses Produkt wurde auf chlorfrei gebleichtem Papier gedruckt.
Die Einschrumpffolie – zum Schutz vor Verschmutzung – ist aus umweltverträglichem und
recyclingfähigem PE-Material.
10
9 8
7
10
09 08
6 5
4
3
2 1
ISBN 978-3-8273-2543-3
c 2008 by Addison-Wesley Verlag,
ein Imprint der Pearson Education Deutschland GmbH,
Martin-Kollar-Straße 10–12, D-81829 München/Germany
Alle Rechte vorbehalten
Lektorat: Boris Karnikowski, [email protected]
Korrektorat: Annette Glaswinkler, www.sprache-und-text.de
Herstellung: Monika Weiher, [email protected]
Satz: PTP-Berlin Protago-TEX-Production GmbH, (www.ptp-berlin.eu)
Druck: Kösel, Krugzell, (www.KoeselBuch.de)
Printed in Germany
open source library
Inhaltsübersicht
Einführung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Teil I Die Python-Umgebung
xvii
1
Python installieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3
2 Die Python-Shell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
29
3 Hello, World! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
59
Teil II Python-Grundlagen
87
4 Zahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
89
5 Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
117
6 Listen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
149
7 Dictionarys . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
183
8 Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
223
9 Dateien und das Dateisystem . . . . . . . . . . . . . . . . . . . . . . . . . . .
259
10 Klassen und Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
319
11 Python und C/C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
377
1
Teil III Anwendungen
435
12 XML und XSLT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
437
13 Persistenz und Datenbanken . . . . . . . . . . . . . . . . . . . . . . . . . . .
473
14 Netzwerkprogrammierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
599
open source library
Inhaltsübersicht
15 Webprogrammierung und Web-Frameworks . . . . . . . . . . . . . . . . . . .
747
16 GUI-Toolkits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1031
17 Python für Wissenschaftler . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1163
Stichwortverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1255
vi
open source library
Inhaltsverzeichnis
Einführung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Teil I Die Python-Umgebung
1
1
Python installieren . . . . . . . . . . . . . . . . . .
1.1
Python auf Unix . . . . . . . . . . . . . . . .
1.1.1
Python ohne root-Rechte installieren
1.2
Python auf Windows . . . . . . . . . . . . .
1.3
Mehrere Python unter einem Dach . . . . . .
1.4
Drittanbietermodule installieren . . . . . . .
1.5
1.6
xvii
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
3
3
5
6
9
11
1.4.1
Einfache .py Dateien . . . . . . . . . . .
1.4.2
distutils-kompatible Packages . . . . .
1.4.3
Packages ohne root-Rechte installieren
setuptools, Eggs und ein Käse-Shop . . . . . . .
1.5.1
setuptools installieren . . . . . . . . . .
1.5.2
Ein Käse-Shop mit vielen Leckereien . .
1.5.3
ZODB3 mit easy_install hinzufügen . . .
1.5.4
easy_install benutzen . . . . . . . . . .
1.5.5
Was sind Eggs? . . . . . . . . . . . . . .
Zusammenfassung . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
11
12
12
14
14
20
20
23
24
27
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
29
29
30
33
34
2 Die Python-Shell . . . . . . . . . . . . . . .
2.1
Die Qual der (Python-Shell-) Wahl . .
2.1.1
Python-Shells unter Unix . .
2.1.2
Python-Shells unter Windows
2.2
Ein Taschenrechner . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
open source library
Inhaltsverzeichnis
2.3
2.4
Auf Erkundungstour . . . . . . . . . . . . . . . .
2.3.1
Introspektion mit dir, type und __doc__
2.3.2 Das Hilfesystem help . . . . . . . . . .
2.3.3 Das Dokumentationstool pydoc . . . . .
Zusammenfassung . . . . . . . . . . . . . . . .
3 Hello, World! . . . . . . . . . . . . . . . . . . . .
3.1
Das Hello, World!-Programm . . . . . . . .
3.1.1
hello.py verstehen . . . . . . . . .
3.1.2
hello.py unter Unix ausführen . . .
3.1.3
hello.py unter Windows ausführen
3.1.4
hello.py in IDLE ausführen . . . . .
3.2
3.3
3.4
hello2.py mit sys.argv . . . . . . . .
3.2.1
hello2.py verstehen . . . .
3.2.2 hello2.py ausführen . . . .
3.2.3 hello2.py unterm Debugger
tkhello.py mit Tkinter . . . . . . . .
Zusammenfassung . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
39
40
44
52
56
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
59
59
60
61
67
68
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
69
70
72
73
77
84
Teil II Python-Grundlagen
87
4 Zahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.1
Die Grundzahlentypen . . . . . . . . . . . . . . . . . . . . . . . . . . .
89
89
4.2
4.3
4.4
Dezimalzahlen mit dem decimal-Modul . . . . .
Zufallszahlen mit dem random-Modul . . . . . .
4.3.1
Zufallszahlen aus dem Mersenne Twister
4.3.2 Zufallszahlen aus einer Entropiequelle .
Zusammenfassung . . . . . . . . . . . . . . . .
5 Strings . . . . . . . . . . . . . . .
5.1
Einfache Bytestrings . . . .
5.1.1
String-Literale . . .
5.1.2
String Interpolation
5.1.3
String Slices . . . .
5.1.4
String-Operatoren .
5.1.5
String-Methoden . .
5.2
Unicode-Strings . . . . . . .
5.2.1
Warum Unicode? . .
viii
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
98
107
109
113
115
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
117
117
118
119
123
124
125
127
127
5.3
5.2.2 Unicode-Encodings . . . . . . . . . .
5.2.3 Der unicode-Datentyp . . . . . . . . .
5.2.4 Codieren und Decodieren von Unicode
5.2.5 Codecs . . . . . . . . . . . . . . . . .
Reguläre Ausdrücke . . . . . . . . . . . . . . .
5.3.1
Was sind reguläre Ausdrücke? . . . .
5.3.2 re.search und re.sub . . . . . . . . . .
5.3.3 Kompilierte reguläre Ausdrücke . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
128
129
130
132
134
134
135
137
5.3.4 Das Match-Objekt . . . .
5.3.5 Die Flags . . . . . . . . .
5.3.6 findall und finditer . . . .
Anwendungen . . . . . . . . . . .
5.4.1
Suchen in Strings . . . .
5.4.2 Strings effizient aufbauen
Zusammenfassung . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
139
140
141
142
142
143
145
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
149
149
152
153
160
164
164
6.5.2 Listen kopieren und vergleichen
6.5.3 Listen sortieren . . . . . . . . .
6.5.4 List comprehensions . . . . . . .
6.5.5 Das DSU-Idiom . . . . . . . . . .
6.5.6 Stabiles Sortieren . . . . . . . .
Zusammenfassung . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
166
170
175
177
178
180
7 Dictionarys . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.1
Dictionary-Literale . . . . . . . . . . . . . . . . . . . . . .
7.2
Dictionarys abfragen und verändern . . . . . . . . . . . .
7.2.1
Was tun bei nicht-existierenden Einträgen? . . .
7.2.2 Wie verändert man Dictionarys? . . . . . . . . .
7.2.3 Dictionarys mit Default-Initialwerten (setdefault)
7.3
Dictionarys durchlaufen . . . . . . . . . . . . . . . . . . .
7.3.1
Dictionarys effizient durchlaufen . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
183
183
186
189
190
194
196
200
5.4
5.5
6 Listen . . . . . . . . . . . . . . . . .
6.1
Zugriff auf Listenelemente . .
6.2
Listen-Slices . . . . . . . . . .
6.3
Memberfunktionen von Listen
6.4
Built-in-Funktionen für Listen .
6.5
Anwendungen . . . . . . . . .
6.5.1
Listen durchlaufen . .
6.6
.
.
.
.
.
.
.
.
.
.
.
.
.
.
ix
open source library
Inhaltsverzeichnis
open source library
Inhaltsverzeichnis
7.4
7.5
7.6
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
202
205
211
212
213
216
221
8 Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.1
Funktionen aufrufen . . . . . . . . . . . . . . . . . . .
8.2
Funktionsparameter . . . . . . . . . . . . . . . . . . .
8.3
Rückgabewerte . . . . . . . . . . . . . . . . . . . . .
8.4
Scope . . . . . . . . . . . . . . . . . . . . . . . . . .
8.4.1
Lokale und globale Namensräume verstehen
8.5
Ein Blick unter die Haube . . . . . . . . . . . . . . . .
8.6
Factory-Funktionen und -Closures . . . . . . . . . . .
8.7
Dekoratoren . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
223
224
226
230
230
232
234
240
241
8.7.1
Dekoratoren manuell erstellen . . . . . . . . . . . . . . . . . .
8.7.2 Das decorator-Modul . . . . . . . . . . . . . . . . . . . . . . .
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
242
248
257
7.7
8.8
Dictionarys kopieren . . . . . . . . . . .
Anwendung: word count . . . . . . . . .
Iteratoren und Generatoren . . . . . . . .
7.6.1
Was ist ein Iterator? . . . . . . .
7.6.2 Einen eigenen Iterator schreiben
7.6.3 Generatoren . . . . . . . . . . .
Zusammenfassung . . . . . . . . . . . .
9 Dateien und das Dateisystem . . . . . . . . . .
9.1
Dateien . . . . . . . . . . . . . . . . . .
9.1.1
Die Funktion open . . . . . . . .
9.1.2
Die Funktion close . . . . . . . .
9.1.3
Textdateien lesen und schreiben
9.2
9.3
x
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
259
259
260
266
268
9.1.4
Binärdateien lesen und schreiben .
9.1.5
RAM-Dateien mit StringIO . . . . . .
9.1.6
Memory mapped Dateien mit mmap
9.1.7
Spezielle Dateiformate . . . . . . .
Das Dateisystem . . . . . . . . . . . . . . .
9.2.1
Dateien verschieben oder löschen .
9.2.2 Metadaten einer Datei . . . . . . . .
9.2.3 Das Dateisystem durchlaufen . . . .
9.2.4 Das shutil-Modul . . . . . . . . . . .
Zusammenfassung . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
275
283
286
291
300
301
301
307
315
316
10 Klassen und Objekte . . . . . . . . . . . . . . . . . . . . .
10.1 Hello, OO-World! . . . . . . . . . . . . . . . . . . .
10.2 Klassen verwenden . . . . . . . . . . . . . . . . . .
10.2.1 Objekte instanziieren . . . . . . . . . . . .
10.2.2 Objektattribute . . . . . . . . . . . . . . .
10.2.3 Objektmethoden (Memberfunktionen) . . .
10.3 Klassen schreiben . . . . . . . . . . . . . . . . . . .
10.3.1 Klassenmethoden und statische Methoden
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
319
319
320
320
322
324
327
333
10.5
10.3.2 Klassenvererbung . . . . . . . . . . . . . . .
Hooks . . . . . . . . . . . . . . . . . . . . . . . . . .
10.4.1 Eine Einführung in Hooks . . . . . . . . . . .
10.4.2 Eine Tour der object-Hooks . . . . . . . . . .
10.4.3 Ein Dictionary mit case-insensitive Schlüsseln
10.4.4 Ein Dictionary mit Default-Werten . . . . . .
10.4.5 Ein aufrufbares Objekt . . . . . . . . . . . . .
10.4.6 Propertys . . . . . . . . . . . . . . . . . . . .
10.4.7 Deskriptoren . . . . . . . . . . . . . . . . . .
10.4.8 __slots__ . . . . . . . . . . . . . . . . . . . .
Metaklassen . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
336
339
339
340
344
346
348
350
353
360
364
10.6
10.5.1 Klassen sind Instanzen von Metaklassen
10.5.2 Das __metaclass__-Attribut . . . . . . .
10.5.3 Anwendungen von Metaklassen . . . .
Zusammenfassung . . . . . . . . . . . . . . . .
10.4
11 Python und C/C++ . . . . . . . . . . . . . .
11.1 ctypes . . . . . . . . . . . . . . . . .
11.1.1 Die ctypes-Datentypwrapper
11.1.2 Komplexe Datentypen . . . .
11.2
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
364
368
370
374
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
377
378
379
382
11.1.3 C-Funktionen aufrufen . . . . .
SWIG . . . . . . . . . . . . . . . . . . .
11.2.1 SWIG installieren . . . . . . . .
11.2.2 SWIG aufrufen . . . . . . . . .
11.2.3 Konstanten und Variablen . . .
11.2.4 Stringmanipulationen . . . . .
11.2.5 Strukturen . . . . . . . . . . .
11.2.6 C++-Klassen . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
387
400
401
403
408
416
419
422
xi
open source library
Inhaltsverzeichnis
open source library
Inhaltsverzeichnis
11.3
11.4
11.5
11.2.7 Unbekannte Datentypen sind Pointer .
11.2.8 Wie geht’s von hier aus weiter? . . . .
Boost.Python . . . . . . . . . . . . . . . . . .
Low-level Python/C-API . . . . . . . . . . . . .
Zusammenfassung . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Teil III Anwendungen
435
12 XML und XSLT . . . . . . . . . . . . . . . . . . . . .
12.1 Eine XML-Datei . . . . . . . . . . . . . . . .
12.2 xml.etree.ElementTree . . . . . . . . . . . .
12.3 4Suite-XML . . . . . . . . . . . . . . . . . .
12.3.1 4Suite-XML installieren . . . . . . .
12.3.2 Die 4Suite-XML-Skripte . . . . . . .
12.3.3 Ft.Xml.InputSource-Eingabequellen
12.3.4 DOM . . . . . . . . . . . . . . . . .
12.3.5 SAX . . . . . . . . . . . . . . . . . .
12.4
12.5
.
.
.
.
.
.
.
.
.
437
438
440
447
448
450
456
457
466
Transformationen mit XSLT . . . . . . . . . . . . . . . . . . . . . . . . .
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
469
471
13 Persistenz und Datenbanken . . . . . . . . . . .
13.1 Serialisieren und Deserialisieren . . . . . .
13.1.1 Ein naiver Versuch mit str und eval
13.1.2 Die richtige Lösung mit pickle . . .
13.2 Persistente Dictionarys mit anydbm . . . .
13.2.1 Eine naive suboptimale Lösung . .
13.2.2 Die richtige Lösung mit anydbm . .
13.3
13.4
13.5
13.6
xii
426
430
430
431
432
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
473
474
474
476
479
480
481
13.2.3 Besonderheiten von anydbm-Dictionarys
13.2.4 Die anydbm-Architektur . . . . . . . . . .
Mehr Flexibilität mit bsddb . . . . . . . . . . . . .
Persistente Datenstrukturen mit shelve . . . . . .
13.4.1 Eine umständliche Lösung . . . . . . . . .
13.4.2 Die shelve-Lösung . . . . . . . . . . . . .
Die ZODB-objektorientierte Datenbank . . . . . .
13.5.1 ZODB installieren . . . . . . . . . . . . .
13.5.2 Die ZODB benutzen . . . . . . . . . . . .
Ein Blogs-Backend mit ZODB . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
483
485
486
490
491
493
498
498
499
508
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
508
513
517
518
521
522
522
526
13.8.4 Anwendung: Verwaltung von MP3-Metadaten .
PostgreSQL-Anbindung mit psycopg2 . . . . . . . . . .
13.9.1 Was ist PostgreSQL? . . . . . . . . . . . . . . .
13.9.2 PostgreSQL installieren . . . . . . . . . . . . .
13.9.3 psycopg2 installieren . . . . . . . . . . . . . .
13.9.4 psycopg2 benutzen . . . . . . . . . . . . . . .
13.9.5 Anwendung: MP3-Metadaten unter PostgreSQL
13.10 MySQL-Anbindung mit MySQLdb . . . . . . . . . . . . .
13.10.1 MySQL-Datenbank vorbereiten . . . . . . . . .
13.10.2 MySQL-python installieren . . . . . . . . . . .
13.10.3 MySQL-python benutzen . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
531
540
540
541
555
559
563
566
566
569
571
13.10.4 Anwendung: MP3-Metadaten unter MySQL
13.11 Der objektrelationale Mapper SQLObject . . . . . .
13.11.1 Was sind objektrelationale Mapper? . . . .
13.11.2 SQLObject installieren . . . . . . . . . . . .
13.11.3 SQLObject benutzen . . . . . . . . . . . . .
13.11.4 Das Blog-System mit SQLObject . . . . . .
13.11.5 django.db, ein anderer ORM . . . . . . . .
13.12 Zusammenfassung . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
574
577
577
578
580
588
594
595
14 Netzwerkprogrammierung . . . . . . . . . . . . . . . . . . . . . . . .
14.1 Das Twisted Framework . . . . . . . . . . . . . . . . . . . . . .
14.1.1 Twisted installieren . . . . . . . . . . . . . . . . . . .
14.1.2 Erste Schritte ins Twisted-Universum . . . . . . . . . .
14.1.3 Zeilenpufferung und ein einfacher Dialog . . . . . . .
14.1.4 Anwendung: Ein Chat-Server . . . . . . . . . . . . . .
14.1.5 Deferred oder: Wenn ein Ergebnis auf sich warten lässt
14.1.6 Passwort-geschützte Bereiche mit cred . . . . . . . .
14.1.7 Twisted AMP (Asynchroneous Messaging Protocol) . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
599
600
601
603
613
620
625
635
646
13.7
13.8
13.6.1 Comment, Article und Blog . . . .
13.6.2 Das Blog-Backend BlogDB . . . .
DB-API 2.0 SQL-Anbindungen . . . . . . .
13.7.1 Eine kurze DB-API 2.0-Einführung .
SQLite-Anbindung mit sqlite3 . . . . . . .
13.8.1 sqlite3 benutzen . . . . . . . . . .
13.8.2 Das sqlite3-Tool . . . . . . . . . .
13.8.3 Das sqlite3-Modul . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
13.9
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
xiii
open source library
Inhaltsverzeichnis
open source library
Inhaltsverzeichnis
14.2
14.1.8 Ein Schnelldurchlauf durch die Twisted-Protokolle .
14.1.9 Twisted und Datenbanken . . . . . . . . . . . . . .
14.1.10 Wie findet man sich in Twisted zurecht? . . . . . .
Module der Python Standard Library . . . . . . . . . . . . .
14.2.1 Server mit SocketServer schreiben . . . . . . . . .
14.2.2 FTP mit ftplib.FTP . . . . . . . . . . . . . . . . . .
14.2.3 Mails senden mit smtplib.SMTP . . . . . . . . . . .
14.2.4 Mails abholen mit poplib.POP3 und imaplib.IMAP4
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
651
680
680
683
683
690
692
694
14.2.5 Newsreader mit nntplib.NNTP . .
14.2.6 Telnet-Clients mit telnetlib.Telnet
Verteilte Programme . . . . . . . . . . .
14.3.1 Twisted Perspective Broker . . .
14.3.2 XML-RPC . . . . . . . . . . . . .
14.3.3 asyncore/asynchat . . . . . . .
Low-level-Programmierung mit Sockets .
Zusammenfassung . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
697
699
700
701
711
722
730
742
15 Webprogrammierung und Web-Frameworks . . . . . . . .
15.1 Webserver in Python . . . . . . . . . . . . . . . . .
15.1.1 Webserver aus der Python Standard Library
15.1.2 Webserver aus Drittanbietermodulen . . . .
15.2 Integration mit anderen Webservern . . . . . . . . .
15.2.1 Lighttpd . . . . . . . . . . . . . . . . . . .
15.2.2 Apache . . . . . . . . . . . . . . . . . . . .
15.3 WSGI . . . . . . . . . . . . . . . . . . . . . . . . . .
15.3.1 Was ist WSGI? . . . . . . . . . . . . . . . .
15.3.2 WSGI-Tools . . . . . . . . . . . . . . . . . .
15.4 Low-level-Programmierung mit CGI . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
747
754
754
764
800
803
816
832
833
839
841
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
841
842
844
847
851
854
864
896
907
14.3
14.4
14.5
15.4.1
15.4.2
15.4.3
15.4.4
15.4.5
15.4.6
15.4.7
15.4.8
15.4.9
xiv
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Hello, CGI World! . . . . . . . . . . . .
CGI-Umgebungsvariablen . . . . . . .
Anwendung: Ein Web-Taschenrechner
Ein Formular manuell auslesen . . . .
Das cgi-Modul . . . . . . . . . . . . .
Anwendung: Dateien uploaden . . . .
Den Zustand clientseitig erhalten . . .
Den Zustand serverseitig erhalten . .
Nachteile von CGI . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
15.5
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
908
909
914
915
920
921
922
932
15.6.3 XML-basiertes Templating . . . . . . . .
15.6.4 Weitere Templating-Systeme . . . . . .
15.7 Web-Frameworks . . . . . . . . . . . . . . . . .
15.7.1 Django . . . . . . . . . . . . . . . . . .
15.7.2 Weitere Web-Frameworks . . . . . . . .
15.8 Zope, Plone et al. . . . . . . . . . . . . . . . . .
15.8.1 Zope und Plone zusammen installieren .
15.8.2 Erste Schritte in Zope . . . . . . . . . .
15.8.3 Macros in Plone . . . . . . . . . . . . .
15.9 Wikis . . . . . . . . . . . . . . . . . . . . . . . .
15.10 Lose Enden . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
961
981
982
982
1005
1006
1007
1008
1017
1022
1023
15.11 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1023
15.6
Webclients . . . . . . . . . . . . . . . . . . .
15.5.1 Low-level HTTP Protokoll mit httplib
15.5.2 Einfache Webclients mit urllib . . . .
15.5.3 Flexiblere Webclients mit urllib2 . .
15.5.4 Webclients mit Twisted . . . . . . .
Templating Engines . . . . . . . . . . . . . .
15.6.1 Templating für arme Leute . . . . . .
15.6.2 Text-basiertes Templating . . . . . .
16 GUI-Toolkits . . . . . . . . . . . . . . . . . . . . . .
16.1 wxPython . . . . . . . . . . . . . . . . . . .
16.1.1 wxPython installieren . . . . . . . .
16.1.2 Erste Schritte in wxPython . . . . . .
16.1.3 Responsive GUIs . . . . . . . . . . .
16.1.4 Schnelle Entwicklung mit RAD-Tools
16.2 PyQt4 . . . . . . . . . . . . . . . . . . . . .
16.3
16.2.1
16.2.2
16.2.3
16.2.4
16.2.5
Tkinter
16.3.1
16.3.2
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1031
1035
1035
1037
1060
1101
1111
PyQt4 installieren . . . . . . . . . . .
Erste Schritte in PyQt4 . . . . . . . . .
Responsive GUIs . . . . . . . . . . . .
Schnelle Entwicklung mit RAD-Tools .
eric4, eine PyQt4-IDE . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
Erste Schritte mit Tkinter . . . . . . .
Wie findet man sich in Tkinter zurecht?
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1112
1118
1126
1134
1142
1143
1144
1146
xv
open source library
Inhaltsverzeichnis
open source library
Inhaltsverzeichnis
16.4
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1146
1148
1152
1153
1153
1156
1158
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1163
1163
1164
1166
1173
1175
1181
1187
1192
17.1.8 Gleichungen lösen . . . . . . . . . . . . . . . . . .
17.1.9 Pattern Matching . . . . . . . . . . . . . . . . . . .
17.1.10 Lineare Algebra . . . . . . . . . . . . . . . . . . .
17.1.11 Plotting . . . . . . . . . . . . . . . . . . . . . . . .
Effiziente numerische Berechnungen mit numpy und scipy .
17.2.1 numpy . . . . . . . . . . . . . . . . . . . . . . . .
17.2.2 scipy . . . . . . . . . . . . . . . . . . . . . . . . .
Plotten mit pylab (a.k.a. matplotlib) . . . . . . . . . . . . .
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1196
1199
1201
1219
1220
1222
1244
1249
1253
Stichwortverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1255
16.5
16.6
Text-basierte GUIs . . . . . . . . . . . . . . . . . . . .
16.4.1 pythondialog . . . . . . . . . . . . . . . . . .
16.4.2 Weitere NGUI . . . . . . . . . . . . . . . . . .
Low-level APIs . . . . . . . . . . . . . . . . . . . . . .
16.5.1 Ein Blick unter die Haube: Rohe Events . . . .
16.5.2 GUI-Toolkits vereinfachen eine komplexe API
Zusammenfassung . . . . . . . . . . . . . . . . . . .
17 Python für Wissenschaftler . . . . . . . . . . . . . . . .
17.1 Das Computer Algebra System sympy . . . . . . .
17.1.1 sympy installieren . . . . . . . . . . . . .
17.1.2 Die Datentypen Rational, Real und Integer
17.1.3 Ein paar Konstanten . . . . . . . . . . . .
17.1.4 Ausdrücke . . . . . . . . . . . . . . . . .
17.1.5 Differenzial- und Integralrechnung . . . .
17.1.6 Polynome . . . . . . . . . . . . . . . . . .
17.1.7 Reihen . . . . . . . . . . . . . . . . . . .
17.2
17.3
17.4
xvi
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
open source library
Einführung
Willkommen zum Python-Praxisbuch!
Was ist Python?
Python ist eine Allzweck-Programmiersprache, die verschiedene Paradigmen unterstützt: Objekt-orientiert, imperativ und funktional. Sie ist interpretiert, kann aber in
C/C++ und anderen Programmiersprachen erstellte Binary-Module laden und ohne
Geschwindigkeitseinbußen ausführen. Eines ihrer besonderen Merkmale, das Umsteigern und vielen erfahrenen Programmierern sofort ins Auge fällt, ist die ungewohnte
und zum Teil umstrittene Syntax durch Einrückung, die aber einen maßgeblichen Beitrag zur Lesbarkeit und Wartbarkeit von Python-Code leistet.
Die Syntax von Python gilt im Gegensatz zu der anderer Sprachen wie Perl, C++
usw. als minimalistisch. Darum ist Python besonders als Einstiegssprache für Anfänger
geeignet. Doch was gut für Anfänger ist, muss nicht schlecht für Fortgeschrittene sein!
Zum einen bietet Python so gut wie alle Features, die sich ein Programmiererherz
wünschen kann, und zum anderen ist gerade die klare, einfache Syntax maßgeblich
entscheidend für die Wartbarkeit von eigenem und fremdem Code.
Eine Programmiersprache wäre nur halb so nützlich, wenn sie nicht auch mit einer mächtigen und ausführlichen Standardbibliothek ausgestattet wäre. Aus diesem
Grunde wird Python mit einer umfangreichen Sammlung von Modulen ausgeliefert.
Diese Sammlung, Python Standard Library genannt, befindet sich überall dort, wo der
Python-Interpreter installiert ist. Ihr großer Umfang und ihre Vielseitigkeit haben die
Bezeichnung batteries included inspiriert, und es ist auch tatsächlich so: Viele PythonProgramme benötigen nicht mehr als die Standardmodule.
Natürlich ist die Python Standard Library (PSL) nur eine Auswahl möglicher Module.
In der Praxis wird man je nach Anwendungsgebiet nicht umhin kommen, Drittanbietermodule aus dem Netz herunterzuladen, um so die PSL zu erweitern. Ähnlich wie bei
Perls CPAN werden viele dieser Erweiterungsmodule im Cheese Shop PyPI zusammen-
open source library
Einführung
gefasst und können mit einem einzigen Kommando automatisch heruntergeladen, bei
Bedarf kompiliert und installiert werden. Abhängigkeiten werden selbstverständlich
automatisch berücksichtigt.
Warum dieses Buch?
In der schnelllebigen Welt der Programmiersprachen ist Python schon ziemlich alt:
Sie wurde von Guido van Rossum 1991 erstmals veröffentlicht und hat im Laufe der
Jahre immer mehr Anhänger und Anwendungsgebiete hinzugewonnen. Konnte man
sich noch in den Anfängen von Python einen guten Überblick verschaffen, ist dies
in letzter Zeit aufgrund der großen Zahl neuer Module etwas schwieriger geworden.
Ja, Python ist gewachsen und hat sich zu einer ausgereiften Sprache samt eigenem
Ökosystem entwickelt!
Wer Python erlernen möchte, wird in der Regel auf die Python-Website http://www
.python.org/ gehen und dort mit dem hervorragenden Tutorial anfangen. Anschließend heißt es für angehende Pythonistas (wie sich Python-Hacker oft und gern bezeichnen): ab in die ausführliche Dokumentation der Python Standard Library und
lesen, lesen, lesen . . .
Das Python-Praxisbuch versucht die Lernkurve etwas zu verkürzen, indem es als
Wegweiser durch das Labyrinth der vielen Dokumentationsseiten und unzähligen
Standard- und Drittanbietermodule dient. Anstatt über alle möglichen Module etwas
zu sagen (was von Natur aus schon unmöglich ist und auf ein Abschreiben der Dokumentation hinauslaufen würde), werden wir uns auf eine Auswahl interessanter
Module beschränken.
Eine solche Auswahl wird immer subjektiv sein, denn sie hängt von den Vorlieben,
Neigungen und besonderen Kenntnissen eines Autors ab. Darum wird es immer Module oder ganze Anwendungsgebiete geben, die im Python-Praxisbuch nicht einmal
erwähnt werden. Dies ist nicht als Wertung zu verstehen: Es liegt einfach in der Natur
der Sache, dass die Seitenzahl und die Zeit zum Schreiben eines Buches beide endliche
Ressourcen sind!
Wir werden nicht die erwähnten und vorgeführten Module dokumentieren, dies
können sie selbst viel besser tun! Sie werden beim Lesen dieses Buches ein Grundprinzip erkennen, das sich wie ein roter Faden durch alle Kapitel zieht: Nachdem
wir ein Modul eingeführt haben, demonstrieren wir, wie man mit Hilfe der PythonShell oder des pydoc-Programms das Modul dazu bringen kann, seine Dokumentation
preiszugeben. Mit anderen Worten: Wir werden zeigen, wie man sich selbst hilft und
Python-Module interaktiv erkunden kann.
Dieses interaktive Erkunden von Python-Modulen ist in meinen Augen ein essenzieller
Bestandteil der Python-Erfahrung. Gleichgültig, ob Sie ein Standardmodul der PSL
xviii
oder ein völlig unbekanntes Drittanbietermodul zum ersten Mal benutzen möchten,
es wird sich immer die Frage stellen: Was kann ich mit diesem Modul so alles anstellen?
Oder noch kürzer: Welche API stellt mir dieses Modul zur Verfügung?
Selbstverständlich liest niemand gern API-Dokumentationen. Schließlich können solche endlosen Listen von Funktionen und ihre Signaturen samt zugehörigen Kommentaren sehr öde sein. Python hat aber hier eine gute Alternative gegen die Langeweile:
die interaktive Python-Shell!
In der Python-Shell kann man u.a. unbekannte Module importieren und anschließend
erkunden, indem man ihre Dokumentation aufruft. Doch was interessanter ist: Man
kann direkt am Python-Prompt Code-Fragmente ausprobieren, neue Funktionen aufrufen und sofort erkennen, was diese Funktionen zurückgeben. Sind das komplizierte
Datenstrukturen, dann kann man sie ebenfalls unter die Lupe nehmen. Der große
Umweg, den man bei anderen Programmiersprachen (inklusive manch interpretierter Sprachen wie Perl) nehmen muss, um Datenstrukturen zu inspizieren oder kleine
Testprogramme zu schreiben, entfällt bei Python komplett: Ausprobieren kann man
direkt am Python-Prompt!
Was enthält dieses Buch?
Das Python-Praxisbuch gliedert sich in drei Hauptteile:
Teil I: Die Python-Umgebung
Teil II: Python-Grundlagen
Teil III: Anwendungen
Der erste Teil zeigt, wie man Python installiert, die Python-Shell bedient, ein einfaches
Programm startet und vor allem, wie man sich selbst helfen kann, um z.B. Dokumentation zu finden und anzuzeigen.
Bei der Installation von Python hat man die Wahl zwischen einer systemweiten Installation und einer Installation, die nur für einen Benutzer gilt (etwa wenn man keine
ausreichenden Schreibrechte auf Systemverzeichnisse besitzt). Wir werden sehen, wie
beide Installationen bewerkstelligt werden und nebeneinander koexistieren können.
Da Erweiterungsmodule in Python oft C/C++ Code enthalten, werden wir auch im
Falle von Windows den MinGW-Compiler installieren und konfigurieren. Außerdem
werden wir die setuptools unserer Python-Installation hinzufügen, um Module aus
dem Cheese Shop PyPI automatisch herunterzuladen und zu installieren.
Die wichtigste Information aus diesem ersten Teil ist es, wie man sich in der PythonShell selbst helfen kann, d.h. wie man neue Module interaktiv erkundet und ihre Dokumentation anzeigen kann. Nachdem Sie den ersten Teil gelesen haben, sollten Sie
xix
open source library
Was enthält dieses Buch?